@matterailab/orbcode 0.1.13 → 0.1.14

package/README.md

@@ -157,6 +157,51 @@ The two Axon models are built in; `/model` opens a scroll-and-select picker
 image input. Cost comes from the API's usage chunks (`is_byok`-aware) and is
 shown in the status bar.
 
+### Other providers (Anthropic, OpenAI-compatible)
+
+The Axon models go through the MatterAI gateway as before. A `customModels`
+entry that sets a `provider` is instead served through the
+[Vercel AI SDK](https://sdk.vercel.ai), reusing the same agent loop, tools, and
+approvals — auth is the provider's own key (env var or `apiKey`), not the
+MatterAI login.
+
+```json
+{
+  "model": "claude-opus-4-8",
+  "customModels": [
+    {
+      "id": "claude-opus-4-8",
+      "name": "Claude Opus 4.8",
+      "provider": "anthropic",
+      "contextWindow": 1000000,
+      "maxOutputTokens": 64000,
+      "inputPrice": 0.000005,
+      "outputPrice": 0.000025,
+      "effort": "high"
+    },
+    {
+      "id": "some-model",
+      "provider": "openai-compatible",
+      "baseUrl": "https://api.other-host.com/v1"
+    }
+  ]
+}
+```
+
+- `provider: "anthropic"` → native `/v1/messages` (`@ai-sdk/anthropic`). Key from
+  `ANTHROPIC_API_KEY` (or `apiKey` on the entry). Adaptive thinking + reasoning
+  streaming are on by default; `effort` (`low`…`max`) tunes depth; prompt
+  caching breakpoints are set on the system prompt and conversation prefix
+  automatically. Thinking blocks are preserved across turns (stored with the
+  session and replayed with their signatures), so interleaved thinking with
+  tool use round-trips correctly. Set `"reasoning": false` to disable thinking
+  (e.g. for models that don't support `effort`).
+- `provider: "openai-compatible"` → any OpenAI-compatible endpoint; requires
+  `baseUrl`. Key from `apiKey` on the entry.
+
+Anything without a `provider` (or `provider: "matterai"`) keeps using the
+MatterAI gateway untouched.
+
 ## The TUI
 
 ```

package/dist/api/aiSdkClient.js

@@ -0,0 +1,260 @@
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { jsonSchema, streamText, tool, } from "ai";
+import { REASONING_DETAILS_FIELD } from "./llmClient.js";
+/**
+ * LLM transport backed by the Vercel AI SDK. Serves any non-MatterAI provider
+ * (Anthropic native `/v1/messages`, or any OpenAI-compatible endpoint) while
+ * speaking the same OpenAI-shaped message/tool contract the agent loop uses —
+ * translation happens entirely at this boundary. Auth is the provider's own
+ * key (env var or settings), never the MatterAI token.
+ */
+export class AiSdkClient {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async *createMessage(systemPrompt, messages, tools, abortSignal) {
+        const model = this.options.model;
+        const isAnthropic = model.provider === "anthropic";
+        // Replay stored thinking blocks only on Anthropic, where they round-trip
+        // with their signatures; other providers ignore the side-channel.
+        const aiMessages = toModelMessages(messages, isAnthropic);
+        if (isAnthropic)
+            applyCacheBreakpoint(aiMessages);
+        const aiTools = toAiTools(tools);
+        const hasTools = Object.keys(aiTools).length > 0;
+        const result = streamText({
+            model: this.resolveModel(),
+            system: this.buildSystem(systemPrompt, isAnthropic),
+            messages: aiMessages,
+            ...(hasTools ? { tools: aiTools, toolChoice: "auto" } : {}),
+            maxOutputTokens: model.maxOutputTokens,
+            // No `temperature`: the current Claude models reject sampling params.
+            abortSignal,
+            providerOptions: this.providerOptions(isAnthropic),
+        });
+        for await (const part of result.fullStream) {
+            switch (part.type) {
+                case "text-delta":
+                    if (part.text)
+                        yield { type: "text", text: part.text };
+                    break;
+                case "reasoning-delta":
+                    if (part.text)
+                        yield { type: "reasoning", text: part.text };
+                    break;
+                case "tool-call":
+                    yield {
+                        type: "native_tool_calls",
+                        toolCalls: [
+                            {
+                                id: part.toolCallId,
+                                type: "function",
+                                function: {
+                                    name: part.toolName,
+                                    arguments: JSON.stringify(part.input ?? {}),
+                                },
+                            },
+                        ],
+                    };
+                    break;
+                case "finish":
+                    yield this.usageChunk(part.totalUsage);
+                    break;
+                case "error":
+                    throw asError(part.error);
+            }
+        }
+        // Capture this turn's thinking blocks (with their provider signatures) so
+        // the agent can stash them on the assistant message and replay them next
+        // turn — required for interleaved thinking + tool use on the same model.
+        const reasoning = collectReasoningParts((await result.response).messages);
+        if (reasoning.length > 0) {
+            yield { type: "reasoning_details", details: reasoning };
+        }
+    }
+    /** Build the provider model handle for this request. */
+    resolveModel() {
+        const { provider, id, baseUrl, apiKey } = this.options.model;
+        switch (provider) {
+            case "anthropic":
+                // createAnthropic reads ANTHROPIC_API_KEY from the env when apiKey is absent.
+                return createAnthropic(apiKey ? { apiKey } : {})(id);
+            default: {
+                // Any OpenAI-compatible endpoint (OpenRouter, Together, Groq, a local
+                // server, even api.openai.com/v1). Adding a native provider package
+                // (e.g. @ai-sdk/google) is a new `case` here.
+                if (!baseUrl) {
+                    throw new Error(`Model "${id}" uses provider "${provider}" but no baseUrl is set. Add a "baseUrl" to its customModels entry in settings.json.`);
+                }
+                return createOpenAICompatible({ name: provider ?? "openai-compatible", baseURL: baseUrl, apiKey })(id);
+            }
+        }
+    }
+    /** Cache the system prompt (and, on Anthropic, the tool list with it). */
+    buildSystem(systemPrompt, isAnthropic) {
+        if (!isAnthropic)
+            return systemPrompt;
+        return {
+            role: "system",
+            content: systemPrompt,
+            providerOptions: { anthropic: { cacheControl: { type: "ephemeral" } } },
+        };
+    }
+    /** Adaptive thinking + effort + reasoning replay for Anthropic; nothing otherwise. */
+    providerOptions(isAnthropic) {
+        if (!isAnthropic)
+            return undefined;
+        const model = this.options.model;
+        if (model.reasoning === false)
+            return undefined;
+        return {
+            anthropic: {
+                thinking: { type: "adaptive", display: "summarized" },
+                effort: model.effort ?? "high",
+                sendReasoning: true,
+            },
+        };
+    }
+    usageChunk(usage) {
+        const model = this.options.model;
+        const inputTokens = usage.inputTokens ?? 0;
+        const outputTokens = usage.outputTokens ?? 0;
+        return {
+            type: "usage",
+            inputTokens,
+            outputTokens,
+            cacheReadTokens: usage.inputTokenDetails?.cacheReadTokens,
+            reasoningTokens: usage.outputTokenDetails?.reasoningTokens,
+            totalCost: model.free ? 0 : inputTokens * model.inputPrice + outputTokens * model.outputPrice,
+            inferenceProvider: model.provider,
+        };
+    }
+}
+/** Translate OpenAI-shaped function tools into the AI SDK's client-side tool set
+ *  (no `execute` — the agent loop runs the tool and feeds the result back). */
+function toAiTools(tools) {
+    const set = {};
+    for (const t of tools) {
+        if (t.type !== "function")
+            continue;
+        set[t.function.name] = tool({
+            description: t.function.description,
+            inputSchema: jsonSchema(t.function.parameters ?? { type: "object", properties: {} }),
+        });
+    }
+    return set;
+}
+/** Translate the OpenAI conversation history into AI SDK `ModelMessage`s.
+ *  When `includeReasoning`, stored thinking blocks are prepended to each
+ *  assistant turn (first, ahead of text/tool-call parts) for same-model replay. */
+function toModelMessages(messages, includeReasoning) {
+    // tool_result parts need the tool name, which OpenAI only carries on the
+    // originating assistant tool_call — index it first.
+    const toolNameById = new Map();
+    for (const message of messages) {
+        if (message.role === "assistant" && message.tool_calls) {
+            for (const call of message.tool_calls) {
+                if (call.type === "function")
+                    toolNameById.set(call.id, call.function.name);
+            }
+        }
+    }
+    const out = [];
+    for (const message of messages) {
+        switch (message.role) {
+            case "user":
+                out.push({ role: "user", content: contentToText(message.content) });
+                break;
+            case "assistant": {
+                const parts = [];
+                if (includeReasoning)
+                    parts.push(...storedReasoningParts(message));
+                const text = contentToText(message.content);
+                if (text)
+                    parts.push({ type: "text", text });
+                for (const call of message.tool_calls ?? []) {
+                    if (call.type !== "function")
+                        continue;
+                    parts.push({
+                        type: "tool-call",
+                        toolCallId: call.id,
+                        toolName: call.function.name,
+                        input: safeParseJson(call.function.arguments),
+                    });
+                }
+                out.push({ role: "assistant", content: parts.length > 0 ? parts : "" });
+                break;
+            }
+            case "tool": {
+                const result = {
+                    type: "tool-result",
+                    toolCallId: message.tool_call_id,
+                    toolName: toolNameById.get(message.tool_call_id) ?? "tool",
+                    output: { type: "text", value: contentToText(message.content) },
+                };
+                out.push({ role: "tool", content: [result] });
+                break;
+            }
+            // "system"/"developer"/"function" roles don't appear in OrbCode history
+            // (the system prompt is passed separately) — ignore defensively.
+        }
+    }
+    return out;
+}
+/** Pull the reasoning parts out of the assistant message(s) the SDK assembled
+ *  for this turn — these carry the provider signature needed to replay them. */
+function collectReasoningParts(messages) {
+    const parts = [];
+    for (const message of messages) {
+        if (message.role !== "assistant" || !Array.isArray(message.content))
+            continue;
+        for (const part of message.content) {
+            if (part.type === "reasoning")
+                parts.push(part);
+        }
+    }
+    return parts;
+}
+/** Read back the reasoning parts the agent stashed on a prior assistant turn. */
+function storedReasoningParts(message) {
+    const details = message[REASONING_DETAILS_FIELD];
+    return Array.isArray(details) ? details : [];
+}
+/** Tag the last message so Anthropic caches the conversation prefix up to here. */
+function applyCacheBreakpoint(messages) {
+    const last = messages[messages.length - 1];
+    if (!last)
+        return;
+    last.providerOptions = {
+        ...last.providerOptions,
+        anthropic: { ...last.providerOptions?.anthropic, cacheControl: { type: "ephemeral" } },
+    };
+}
+/** Flatten OpenAI string-or-parts content down to plain text. */
+function contentToText(content) {
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((part) => part && typeof part === "object" && "text" in part ? String(part.text ?? "") : "")
+            .join("");
+    }
+    return "";
+}
+function safeParseJson(raw) {
+    if (!raw)
+        return {};
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+function asError(error) {
+    if (error instanceof Error)
+        return error;
+    return new Error(typeof error === "string" ? error : JSON.stringify(error));
+}

package/dist/api/client.js

@@ -1,6 +1,7 @@
 import OpenAI from "openai";
 import { API_GATEWAY_PATH, getUrlFromToken } from "../auth/auth.js";
 import { DEFAULT_HEADERS, X_AXONCODE_TASKID, X_AXON_REPO, X_ORGANIZATIONID } from "./headers.js";
+import { stripReasoningDetails } from "./llmClient.js";
 import { getModel } from "./models.js";
 export class AxonClient {
     client;
@@ -26,7 +27,7 @@ export class AxonClient {
         const requestOptions = {
             model: model.id,
             temperature: 0.2,
-            messages: [{ role: "system", content: systemPrompt }, ...messages],
+            messages: [{ role: "system", content: systemPrompt }, ...stripReasoningDetails(messages)],
             stream: true,
             stream_options: { include_usage: true },
             max_tokens: model.maxOutputTokens,

package/dist/api/llmClient.js

@@ -0,0 +1,19 @@
+/**
+ * Non-standard field stashed on a persisted assistant message holding opaque
+ * reasoning blocks (with provider signatures) for same-model replay. Only the
+ * AI SDK client reads/writes it; it is stripped before any OpenAI request.
+ */
+export const REASONING_DETAILS_FIELD = "_reasoningDetails";
+/** Drop the reasoning side-channel from assistant messages bound for an OpenAI
+ *  `/chat/completions` request (it isn't a valid input field there). */
+export function stripReasoningDetails(messages) {
+    return messages.map((message) => {
+        if (message.role !== "assistant")
+            return message;
+        const record = message;
+        if (!(REASONING_DETAILS_FIELD in record))
+            return message;
+        const { [REASONING_DETAILS_FIELD]: _omit, ...rest } = record;
+        return rest;
+    });
+}

package/dist/api/models.js

@@ -1,4 +1,94 @@
+/** Providers served by the built-in MatterAI gateway rather than the AI SDK. */
+const MATTERAI_PROVIDERS = new Set(["matterai", "axon"]);
+/** True when the model should be served via the Vercel AI SDK transport. */
+export function usesAiSdk(model) {
+    return Boolean(model.provider) && !MATTERAI_PROVIDERS.has(model.provider);
+}
+/**
+ * Well-known Claude models, served natively via the Anthropic provider (AI SDK,
+ * `/v1/messages`). Built in so `--model claude-…` works without a settings.json
+ * entry; auth is `ANTHROPIC_API_KEY` (or a per-model `apiKey`), never MatterAI.
+ * Adaptive thinking + effort are on by default (see AiSdkClient); Haiku 4.5 sets
+ * `reasoning: false` because it rejects the `effort` parameter.
+ */
+export const ANTHROPIC_MODELS = {
+    "claude-opus-4-8": {
+        id: "claude-opus-4-8",
+        name: "Claude Opus 4.8",
+        description: "Anthropic's most capable Opus model — long-horizon agentic work, knowledge work, and coding.",
+        contextWindow: 1_000_000,
+        maxOutputTokens: 64000,
+        supportsImages: true,
+        inputPrice: 0.000005,
+        outputPrice: 0.000025,
+        free: false,
+        provider: "anthropic",
+    },
+    "claude-opus-4-7": {
+        id: "claude-opus-4-7",
+        name: "Claude Opus 4.7",
+        description: "Previous-generation Opus — highly autonomous, strong on agentic, vision, and memory tasks.",
+        contextWindow: 1_000_000,
+        maxOutputTokens: 64000,
+        supportsImages: true,
+        inputPrice: 0.000005,
+        outputPrice: 0.000025,
+        free: false,
+        provider: "anthropic",
+    },
+    "claude-opus-4-6": {
+        id: "claude-opus-4-6",
+        name: "Claude Opus 4.6",
+        description: "Older Opus with adaptive thinking; 1M context.",
+        contextWindow: 1_000_000,
+        maxOutputTokens: 64000,
+        supportsImages: true,
+        inputPrice: 0.000005,
+        outputPrice: 0.000025,
+        free: false,
+        provider: "anthropic",
+    },
+    "claude-sonnet-4-6": {
+        id: "claude-sonnet-4-6",
+        name: "Claude Sonnet 4.6",
+        description: "Anthropic's best balance of speed and intelligence; adaptive thinking, 1M context.",
+        contextWindow: 1_000_000,
+        maxOutputTokens: 64000,
+        supportsImages: true,
+        inputPrice: 0.000003,
+        outputPrice: 0.000015,
+        free: false,
+        provider: "anthropic",
+    },
+    "claude-haiku-4-5": {
+        id: "claude-haiku-4-5",
+        name: "Claude Haiku 4.5",
+        description: "Fastest, most cost-effective Claude model for simple, latency-sensitive tasks.",
+        contextWindow: 200_000,
+        maxOutputTokens: 64000,
+        supportsImages: true,
+        inputPrice: 0.000001,
+        outputPrice: 0.000005,
+        free: false,
+        provider: "anthropic",
+        // Haiku 4.5 rejects the `effort` parameter, so don't send thinking/effort.
+        reasoning: false,
+    },
+    "claude-fable-5": {
+        id: "claude-fable-5",
+        name: "Claude Fable 5",
+        description: "Anthropic's most capable widely released model — most demanding reasoning and long-horizon work.",
+        contextWindow: 1_000_000,
+        maxOutputTokens: 64000,
+        supportsImages: true,
+        inputPrice: 0.00001,
+        outputPrice: 0.00005,
+        free: false,
+        provider: "anthropic",
+    },
+};
 export const AXON_MODELS = {
+    ...ANTHROPIC_MODELS,
     "axon-code-2-5-mini": {
         id: "axon-code-2-5-mini",
         name: "Axon Code 2.5 Mini (free)",
@@ -32,6 +122,17 @@ export const AXON_MODELS = {
         outputPrice: 0.000009,
         free: false,
     },
+    "axon-eido-3-code-mini": {
+        id: "axon-eido-3-code-mini",
+        name: "Axon Eido 3 Mini",
+        description: "Axon Eido 3 Mini is a general purpose super intelligent LLM coding model for low-effort day-to-day tasks",
+        contextWindow: 400000,
+        maxOutputTokens: 64000,
+        supportsImages: true,
+        inputPrice: 0.000001,
+        outputPrice: 0.000003,
+        free: false,
+    },
 };
 export const DEFAULT_MODEL_ID = "axon-code-2-5-pro";
 /** Add user-defined models (from settings.json) to the registry. */
@@ -49,6 +150,11 @@ export function registerCustomModels(models) {
             inputPrice: model.inputPrice ?? 0,
             outputPrice: model.outputPrice ?? 0,
             free: (model.inputPrice ?? 0) === 0 && (model.outputPrice ?? 0) === 0,
+            provider: model.provider,
+            baseUrl: model.baseUrl,
+            apiKey: model.apiKey,
+            effort: model.effort,
+            reasoning: model.reasoning,
         };
     }
 }

package/dist/api/provider.js

@@ -0,0 +1,16 @@
+import { AiSdkClient } from "./aiSdkClient.js";
+import { AxonClient } from "./client.js";
+import { getModel, usesAiSdk } from "./models.js";
+/**
+ * Pick the transport for a model. MatterAI/Axon models keep using `AxonClient`
+ * (OpenAI `/chat/completions` against the gateway, with all its auth/headers/
+ * cost handling); anything declaring another `provider` goes through the Vercel
+ * AI SDK. Both implement `LLMClient`, so the agent loop is unaffected.
+ */
+export function createLLMClient(options) {
+    const model = getModel(options.modelId);
+    if (usesAiSdk(model)) {
+        return new AiSdkClient({ model });
+    }
+    return new AxonClient(options);
+}

package/dist/core/agent.js

@@ -1,7 +1,8 @@
 import { execSync } from "node:child_process";
 import * as path from "node:path";
 import { randomUUID } from "node:crypto";
-import { AxonClient } from "../api/client.js";
+import { REASONING_DETAILS_FIELD } from "../api/llmClient.js";
+import { createLLMClient } from "../api/provider.js";
 import { buildSystemPrompt } from "../prompts/system.js";
 import { describeToolCall, executeTool, getActiveTools, getApprovalKind, } from "../tools/index.js";
 import { walkFiles } from "../tools/executors/listFiles.js";
@@ -107,7 +108,7 @@ export class Agent {
         }
         this.sessionApproveEdits = options.autoApproveEdits;
         this.systemPrompt = buildSystemPrompt(options.cwd);
-        this.client = new AxonClient({
+        this.client = createLLMClient({
             token: options.token,
             modelId: options.modelId,
             taskId: this.taskId,
@@ -118,7 +119,7 @@ export class Agent {
     }
     setModel(modelId) {
         this.options.modelId = modelId;
-        this.client = new AxonClient({
+        this.client = createLLMClient({
             token: this.options.token,
             modelId,
             taskId: this.taskId,
@@ -448,6 +449,7 @@ User time zone: ${timeZone}, UTC${timeZoneOffsetStr}`;
         let assistantText = "";
         let hadReasoning = false;
         let reasoningStart = 0;
+        let reasoningDetails;
         const toolCallsByIndex = new Map();
         let nextSyntheticIndex = 10000;
         const stream = this.client.createMessage(this.systemPrompt, this.outgoingMessages(), getActiveTools(), signal);
@@ -466,6 +468,10 @@ User time zone: ${timeZone}, UTC${timeZoneOffsetStr}`;
                     }
                     onEvent({ type: "reasoning-delta", text: chunk.text });
                     break;
+                case "reasoning_details":
+                    // Opaque thinking blocks (with signatures) for next-turn replay.
+                    reasoningDetails = chunk.details;
+                    break;
                 case "native_tool_calls":
                     for (const tc of chunk.toolCalls) {
                         const index = tc.index ?? nextSyntheticIndex++;
@@ -513,6 +519,12 @@ User time zone: ${timeZone}, UTC${timeZoneOffsetStr}`;
                 function: { name: tc.name, arguments: tc.arguments || "{}" },
             }));
         }
+        // Stash reasoning blocks (opaque) so the next turn can replay them. The
+        // field is persisted with the session and stripped on the OpenAI path.
+        if (reasoningDetails !== undefined) {
+            ;
+            assistantMessage[REASONING_DETAILS_FIELD] = reasoningDetails;
+        }
         this.messages.push(assistantMessage);
         if (toolCalls.length === 0) {
             return true;

package/dist/headless.js

@@ -1,10 +1,23 @@
+import { getModel, isValidAxonModel, usesAiSdk } from "./api/models.js";
 import { getAuthToken, getPendingProjectHooks, loadSettings } from "./config/settings.js";
 import { Agent } from "./core/agent.js";
 /** Non-interactive `orbcode -p "prompt"` mode: prints the final response to stdout. */
 export async function runHeadless(prompt, yolo) {
     const settings = loadSettings();
+    // An unknown --model (or ORBCODE_MODEL) silently resolves to the default; say
+    // so on stderr instead of quietly running a different model than requested.
+    const requestedModel = process.env.ORBCODE_MODEL;
+    if (requestedModel && !isValidAxonModel(requestedModel)) {
+        process.stderr.write(`warning: unknown model "${requestedModel}"; using "${settings.model}". ` +
+            `Add it under "customModels" in settings.json (with a "provider") to use it.\n`);
+    }
     const token = getAuthToken(settings);
-    if (!token) {
+    // MatterAI/Axon models authenticate with the login token. AI-SDK providers
+    // (Anthropic, etc.) authenticate with their own key — resolved by the
+    // provider from the env (e.g. ANTHROPIC_API_KEY) or the model's `apiKey` —
+    // so they don't need a MatterAI login. Only gate on the token when the
+    // selected model actually goes through the MatterAI gateway.
+    if (!token && !usesAiSdk(getModel(settings.model))) {
         console.error("Not signed in. Run `orbcode login`, set ORBCODE_TOKEN, or put an apiKey in settings.json.");
         process.exit(1);
     }
@@ -24,7 +37,9 @@ export async function runHeadless(prompt, yolo) {
     let completionResult = "";
     const agent = new Agent({
         cwd: process.cwd(),
-        token,
+        // May be empty for AI-SDK providers; AiSdkClient ignores it and uses the
+        // provider's own key. AxonClient only runs when a token is present.
+        token: token ?? "",
         modelId: settings.model,
         organizationId: settings.organizationId,
         baseUrl: settings.baseUrl,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterailab/orbcode",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "description": "OrbCode CLI — agentic coding in your terminal, powered by Axon models by MatterAI",
   "type": "module",
   "bin": {
@@ -36,6 +36,9 @@
     "prepublishOnly": "npm run typecheck && npm run build"
   },
   "dependencies": {
+    "@ai-sdk/anthropic": "^3.0.85",
+    "@ai-sdk/openai-compatible": "^2.0.51",
+    "ai": "^6.0.207",
     "chalk": "^5.3.0",
     "ink": "^5.2.1",
     "open": "^10.1.0",