feat: add OrcaRouter provider support and update context windows:

apps/supercode-cli/server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supercode-cli",
-  "version": "0.1.77",
+  "version": "0.1.79",
   "description": "AI-powered coding agent CLI",
   "main": "dist/main.js",
   "bin": {

apps/supercode-cli/server/src/cli/ai/context-windows.ts

@@ -21,6 +21,12 @@ const CONTEXT_WINDOWS: Record<string, number> = {
   "anthropic/claude-opus-4-8": 1_000_000,
   "anthropic/claude-opus-4-7": 1_000_000,
   "openai/gpt-5.5": 1_100_000,
+  "anthropic/claude-sonnet-4.6": 200_000,
+  "anthropic/claude-opus-4.7": 200_000,
+  "deepseek/deepseek-chat": 128_000,
+  "deepseek/deepseek-reasoner": 128_000,
+  "grok/grok-4-fast-reasoning": 131_072,
+  "orcarouter/auto": 128_000,
 }
 
 const FALLBACK_CONTEXT_WINDOW = 128_000

apps/supercode-cli/server/src/cli/ai/orcarouter-service.ts

@@ -0,0 +1,269 @@
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible"
+import { streamText, stepCountIs, type ModelMessage, type LanguageModel, type LanguageModelUsage } from "ai"
+import chalk from "chalk"
+import { orcarouterConfig } from "../../config/orcarouter.config.ts"
+import { recordUsage } from "../../lib/track-usage"
+import { computeCost } from "../../lib/pricing"
+import { isEmptyToolResult, isDeniedToolResult, summarizeToolResult, tcName } from "./tool-result"
+
+const HIGH_VALUE_MODELS: string[] = []
+
+export class OrcaRouterService {
+  model: LanguageModel
+  readonly modelName: string
+
+  constructor(modelName?: string) {
+    if (!orcarouterConfig.apiKey) {
+      throw new Error(
+        "OrcaRouter is not configured.\n\n  Set ORCAROUTER_API_KEY in your environment:\n" +
+        "    export ORCAROUTER_API_KEY=<your-key>\n\n" +
+        "  Get a key at: https://orcarouter.ai",
+      )
+    }
+
+    this.modelName = modelName || orcarouterConfig.model
+
+    const client = createOpenAICompatible({
+      name: "orcarouter",
+      baseURL: orcarouterConfig.baseUrl,
+      headers: { Authorization: `Bearer ${orcarouterConfig.apiKey}` },
+    })
+
+    this.model = client.chatModel(this.modelName)
+  }
+
+  async sendMessage(
+    messages: ModelMessage[],
+    onChunk?: (chunk: string) => void,
+    tools?: any,
+    onToolCall?: any,
+    signal?: AbortSignal,
+    onReasoning?: (chunk: string) => void,
+    onToolResult?: (params: { toolName: string; args: unknown; result: string }) => void,
+    onStepFinish?: (params: { stepNumber: number; toolCalls: Array<{ toolName: string; args: unknown }>; toolResults: Array<{ toolName: string; args: unknown; result: string }> }) => void,
+  ) {
+    const streamAbortController = new AbortController()
+    const streamTimeout = setTimeout(() => streamAbortController.abort(), 120_000)
+    const signalHandler = signal ? () => streamAbortController.abort() : undefined
+    signalHandler && signal!.addEventListener("abort", signalHandler, { once: true })
+
+    try {
+      const systemMessages = messages.filter(m => m.role === "system")
+      const nonSystemMessages = messages.filter(m => m.role !== "system")
+      const system = systemMessages.map(m => m.content).join("\n")
+
+      const hasTools = tools && Object.keys(tools).length > 0
+
+      if (!hasTools) {
+        const result = streamText({
+          model: this.model,
+          messages: nonSystemMessages,
+          system,
+          abortSignal: streamAbortController.signal,
+          ...(!HIGH_VALUE_MODELS.includes(this.modelName) ? { maxOutputTokens: 8192 } : {}),
+        })
+
+        let fullResponse = ""
+        for await (const chunk of result.textStream) {
+          fullResponse += chunk
+          onChunk?.(chunk)
+        }
+
+        const [finishReason, usage] = await Promise.all([
+          result.finishReason,
+          result.usage,
+        ])
+
+        recordUsage({
+          provider: "orcarouter",
+          model: this.modelName,
+          inputTokens: usage.inputTokens ?? 0,
+          outputTokens: usage.outputTokens ?? 0,
+          cachedInputTokens: usage.inputTokenDetails?.cacheReadTokens ?? 0,
+          totalTokens: usage.totalTokens ?? 0,
+          costUsd: computeCost(this.modelName, usage.inputTokens ?? 0, usage.outputTokens ?? 0, usage.inputTokenDetails?.cacheReadTokens ?? 0),
+          durationMs: null,
+        })
+
+        return {
+          content: fullResponse,
+          finishReason,
+          usage,
+        }
+      }
+
+      let fullResponse = ""
+      const seenStepResults: Array<{ toolName: string; result: string }> = []
+      const deniedCounts = new Map<string, number>()
+      let stopForDenialLoop = false
+      const toolCallHistory: Array<{ toolName: string; argsKey: string }> = []
+      let stopForRepetition = false
+
+      const result = streamText({
+        model: this.model,
+        messages: nonSystemMessages,
+        system,
+        tools,
+        ...(!HIGH_VALUE_MODELS.includes(this.modelName) ? { maxOutputTokens: 8192 } : {} as Record<string, never>),
+        stopWhen: stepCountIs(8),
+        abortSignal: streamAbortController.signal,
+        prepareStep: async ({ messages }) => {
+          if (stopForRepetition) {
+            return {
+              messages: [
+                ...messages,
+                {
+                  role: "system" as const,
+                  content:
+                    "SYSTEM NOTICE: You have called the same tools with the same arguments " +
+                    "multiple times without making progress. Stop repeating yourself. " +
+                    "Analyze what you already have and respond to the user.",
+                },
+              ],
+            }
+          }
+          if (stopForDenialLoop) {
+            return {
+              messages: [
+                ...messages,
+                {
+                  role: "system" as const,
+                  content:
+                    "SYSTEM NOTICE: You have called the same permission-protected tool multiple " +
+                    "times after the user denied it. Stop calling it. Respond to the user with " +
+                    "what you have so far and ask for guidance.",
+                },
+              ],
+            }
+          }
+          if (seenStepResults.length === 0) return undefined
+          const allEmpty = seenStepResults.every((r) => isEmptyToolResult(r.result))
+          if (!allEmpty) return undefined
+          const summary = seenStepResults
+            .map((r) => `- ${r.toolName}: ${summarizeToolResult(r.result)}`)
+            .join("\n")
+          return {
+            messages: [
+              ...messages,
+              {
+                role: "system" as const,
+                content:
+                  "SYSTEM NOTICE: All tool calls so far have returned empty or error results. " +
+                  "You have NO source material to answer with. Do NOT invent specifications, pricing, " +
+                  "dates, leaderboard rankings, or any factual claims. Tell the user which tools failed " +
+                  "and what you would need to proceed.\n\nTool outcomes:\n" + summary,
+              },
+            ],
+          }
+        },
+        onStepFinish: async (event) => {
+          if (event.toolCalls?.length) {
+            for (const tc of event.toolCalls) {
+              onToolCall?.({ toolName: tc.toolName, args: (tc as any).input as Record<string, unknown> })
+              const args = (tc as any).input ?? {}
+              const argsKey = JSON.stringify(args, Object.keys(args).sort())
+              toolCallHistory.push({ toolName: tc.toolName, argsKey })
+              let repCount = 0
+              for (const h of toolCallHistory) {
+                if (h.toolName === tc.toolName && h.argsKey === argsKey) repCount++
+              }
+              if (repCount >= 3) stopForRepetition = true
+              if (toolCallHistory.length > 12) {
+                toolCallHistory.splice(0, toolCallHistory.length - 12)
+              }
+            }
+          }
+          const inputByCallId = new Map<string, unknown>()
+          if (event.toolCalls?.length) {
+            for (const tc of event.toolCalls) {
+              const id = (tc as any).toolCallId
+              if (typeof id === "string") {
+                inputByCallId.set(id, (tc as any).input)
+              }
+            }
+          }
+          const toolResults = (event as any).toolResults as
+            | Array<{ toolName?: string; toolCallId?: string; input?: unknown; output?: unknown }>
+            | undefined
+          if (toolResults?.length) {
+            for (const tr of toolResults) {
+              const name = tcName(tr.toolName) ?? "unknown"
+              const out = (tr as any).output
+              const text =
+                typeof out === "string"
+                  ? out
+                  : out === undefined || out === null
+                    ? ""
+                    : JSON.stringify(out)
+              seenStepResults.push({ toolName: name, result: text })
+              const args = tr.input ?? (tr.toolCallId ? inputByCallId.get(tr.toolCallId) : undefined)
+              if (onToolResult) {
+                onToolResult({ toolName: name, args, result: text })
+              }
+              if (isDeniedToolResult(text)) {
+                const prev = deniedCounts.get(name) ?? 0
+                const next = prev + 1
+                deniedCounts.set(name, next)
+                if (next >= 2) stopForDenialLoop = true
+              } else {
+                deniedCounts.set(name, 0)
+              }
+            }
+          }
+        },
+      })
+
+      for await (const chunk of result.textStream) {
+        fullResponse += chunk
+        onChunk?.(chunk)
+      }
+
+      const [finishReason, usage] = await Promise.all([
+        result.finishReason,
+        result.usage,
+      ])
+
+      recordUsage({
+        provider: "orcarouter",
+        model: this.modelName,
+        inputTokens: usage.inputTokens ?? 0,
+        outputTokens: usage.outputTokens ?? 0,
+        cachedInputTokens: usage.inputTokenDetails?.cacheReadTokens ?? 0,
+        totalTokens: usage.totalTokens ?? 0,
+        costUsd: computeCost(this.modelName, usage.inputTokens ?? 0, usage.outputTokens ?? 0, usage.inputTokenDetails?.cacheReadTokens ?? 0),
+        durationMs: null,
+      })
+
+      return {
+        content: fullResponse,
+        finishReason,
+        usage,
+      }
+    } catch (error: any) {
+      if (error?.name === "AbortError") throw error
+      const msg = error instanceof Error ? error.message : String(error)
+      const is5xx = /OrcaRouter (?:API )?5\d\d/.test(msg) || /status code 5\d\d/i.test(msg)
+      if (is5xx) {
+        const friendly = new Error(
+          `OrcaRouter gateway error (HTTP 5xx). This is upstream — not your request. ` +
+          `Try again, or run /model to switch providers.\n  ${msg}`,
+        )
+        console.error(chalk.red("OrcaRouter Service Error:"), friendly.message)
+        throw friendly
+      }
+      console.error(chalk.red("OrcaRouter Service Error:"), msg)
+      throw error
+    } finally {
+      clearTimeout(streamTimeout)
+      if (signalHandler) signal!.removeEventListener("abort", signalHandler as any)
+    }
+  }
+
+  async getMessage(messages: ModelMessage[], tools?: any) {
+    let fullResponse = ""
+    const result = await this.sendMessage(messages, (chunk) => {
+      fullResponse += chunk
+    })
+    return result.content
+  }
+}

apps/supercode-cli/server/src/cli/ai/provider.ts

@@ -5,14 +5,16 @@ import { OpenRouterService } from "./openrouter-service.ts"
 import { NvidiaService } from "./nvidia-service.ts"
 import { ConcentrateService } from "./concentrate-service.ts"
 import { MergeDevService } from "./mergedev-service.ts"
+import { OrcaRouterService } from "./orcarouter-service.ts"
 import { ServerProxyService } from "./server-proxy-service.ts"
 import { config } from "../../config/google.config.ts"
 import { minimaxConfig } from "../../config/minimax.config.ts"
 import { openRouterConfig } from "../../config/openrouter.config.ts"
 import { nvidiaConfig } from "../../config/nvidia.config.ts"
 import { mergedevConfig } from "../../config/mergedev.config.ts"
+import { orcarouterConfig } from "../../config/orcarouter.config.ts"
 
-export type ModelProvider = "supercode" | "google" | "minimax" | "openrouter" | "nvidia" | "concentrateai" | "mergedev"
+export type ModelProvider = "supercode" | "google" | "minimax" | "openrouter" | "nvidia" | "concentrateai" | "mergedev" | "orcarouter"
 
 export type ConnectionType = "direct" | "proxy"
 
@@ -47,6 +49,7 @@ export const providerMeta: Record<ModelProvider, { env: string; label: string; d
   nvidia: { env: "NVIDIA_BYOK_PROD_KEY / NVIDIA_BYOK_DEV_KEY", label: "NVIDIA NIM", defaultModel: "minimaxai/minimax-m3" },
   concentrateai: { env: "CONCENTRATE_BYOK_PROD_KEY / CONCENTRATE_BYOK_DEV_KEY", label: "ConcentrateAI", defaultModel: "deepseek-v4-flash", link: "https://concentrate.ai" },
   mergedev: { env: "MERGE_DEV_BYOK_PROD_KEY / MERGE_DEV_BYOK_DEV_KEY", label: "Merge Dev Gateway", defaultModel: "anthropic/claude-opus-4-8", link: "https://app.merge.dev" },
+  orcarouter: { env: "ORCAROUTER_BYOK_PROD_KEY / ORCAROUTER_BYOK_DEV_KEY", label: "OrcaRouter", defaultModel: "openai/gpt-4o-mini", link: "https://orcarouter.ai" },
 }
 
 const providerConfigs: Record<ModelProvider, () => string> = {
@@ -57,6 +60,7 @@ const providerConfigs: Record<ModelProvider, () => string> = {
   nvidia: () => process.env.NVIDIA_BYOK_PROD_KEY || process.env.NVIDIA_BYOK_DEV_KEY || nvidiaConfig.apiKey,
   concentrateai: () => process.env.CONCENTRATE_BYOK_PROD_KEY || process.env.CONCENTRATE_BYOK_DEV_KEY || process.env.CONCENTRATEAI_API_KEY || "",
   mergedev: () => process.env.MERGE_DEV_BYOK_PROD_KEY || process.env.MERGE_DEV_BYOK_DEV_KEY || mergedevConfig.apiKey,
+  orcarouter: () => process.env.ORCAROUTER_BYOK_PROD_KEY || process.env.ORCAROUTER_BYOK_DEV_KEY || orcarouterConfig.apiKey,
 }
 
 export function createProvider(provider: ModelProvider, model?: string): AIProvider {
@@ -142,6 +146,17 @@ export function createProvider(provider: ModelProvider, model?: string): AIProvi
           svc.sendMessage(messages, onChunk, tools, onToolCall, signal, onReasoning, onToolResult, onStepFinish),
       }
     }
+    case "orcarouter": {
+      const svc = new OrcaRouterService(model)
+      return {
+        name: "orcarouter",
+        modelName: svc.modelName,
+        connectionType: "direct",
+        model: svc.model,
+        sendMessage: (messages, onChunk, tools, onToolCall, signal, onReasoning, onToolResult, onStepFinish) =>
+          svc.sendMessage(messages, onChunk, tools, onToolCall, signal, onReasoning, onToolResult, onStepFinish),
+      }
+    }
     default: {
       throw new Error(`Provider "${provider}" is paused or unavailable`)
     }

apps/supercode-cli/server/src/cli/commands/slashCommands/connect.ts

@@ -15,6 +15,7 @@ const PROVIDERS: Array<{ value: ModelProvider; label: string; hint: string; link
   { value: "google", label: "Google Gemini", hint: "gemini-2.5 models", link: "https://aistudio.google.com/apikey" },
   { value: "openrouter", label: "OpenRouter", hint: "multi-provider access", link: "https://openrouter.ai/keys" },
   { value: "nvidia", label: "NVIDIA NIM", hint: "free NVIDIA hosted models", link: "https://build.nvidia.com/explore/discover" },
+  { value: "orcarouter", label: "OrcaRouter", hint: "multi-provider router", link: "https://orcarouter.ai" },
 ]
 
 export async function connectProvider(): Promise<{ type: "connect"; provider?: ModelProvider; model?: string }> {