@matterailab/orbcode 0.1.13 → 0.2.0

package/README.md

@@ -130,10 +130,10 @@ Fallbacks & overrides:
 - **settings.json key**: set `apiKey` in `~/.orbcode/settings.json` (or a
   project's `.orbcode/settings.json`) to skip login. The login screen itself is
   browser-redirect only.
-- **Env token**: set `ORBCODE_TOKEN` to skip login entirely (takes precedence
+- **Env token**: set `MATTERAI_TOKEN` to skip login entirely (takes precedence
   over everything).
-- **Dev endpoints**: `ORBCODE_BACKEND_URL` (default `https://api.matterai.so`)
-  and `ORBCODE_APP_URL` (default `https://app.matterai.so`) override where the
+- **Dev endpoints**: `MATTERAI_BACKEND_URL` (default `https://api.matterai.so`)
+  and `MATTERAI_APP_URL` (default `https://app.matterai.so`) override where the
   device flow points — useful against a local backend/webapp.
 - Tokens are MatterAI JWTs. A token whose payload has `env: "development"`
   automatically routes API calls to `http://localhost:3000`, matching the
@@ -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
 
 ```
@@ -301,13 +346,13 @@ and `--resume <id>`.
 
 | env var               | effect                                                            |
 | --------------------- | ----------------------------------------------------------------- |
-| `ORBCODE_TOKEN`       | auth token (overrides everything)                                 |
-| `ORBCODE_API_KEY`     | same as `apiKey` in settings.json                                 |
-| `ORBCODE_BASE_URL`    | same as `baseUrl` in settings.json                                |
-| `ORBCODE_MODEL`       | model override (what `--model` sets internally)                   |
-| `ORBCODE_CONFIG_DIR`  | config directory (default `~/.orbcode`)                           |
-| `ORBCODE_BACKEND_URL` | device-auth backend (default `https://api.matterai.so`)           |
-| `ORBCODE_APP_URL`     | webapp for the authorize page (default `https://app.matterai.so`) |
+| `MATTERAI_TOKEN`       | auth token (overrides everything)                                 |
+| `MATTERAI_API_KEY`     | same as `apiKey` in settings.json                                 |
+| `MATTERAI_BASE_URL`    | same as `baseUrl` in settings.json                                |
+| `MATTERAI_MODEL`       | model override (what `--model` sets internally)                   |
+| `MATTERAI_CONFIG_DIR`  | config directory (default `~/.orbcode`)                           |
+| `MATTERAI_BACKEND_URL` | device-auth backend (default `https://api.matterai.so`)           |
+| `MATTERAI_APP_URL`     | webapp for the authorize page (default `https://app.matterai.so`) |
 
 `autoApproveEdits` / `autoApproveSafeCommands` set the session defaults for the
 approval prompts (dangerous commands still always prompt); shift+tab cycles
@@ -320,7 +365,7 @@ them to **block** dangerous actions, **auto-approve** trusted ones, **rewrite**
 tool inputs, **inject context** into the model, **format code** after edits,
 **notify** you, or **keep the agent working** until a condition is met. They use
 the **same contract as Claude Code's hooks**, so scripts written for it work
-here (just use `$ORBCODE_PROJECT_DIR` and OrbCode's tool names).
+here (just use `$MATTERAI_PROJECT_DIR` and OrbCode's tool names).
 
 > 📖 **This is the overview. The complete, example-driven reference —
 > per-event input/output, a copy-paste cookbook, debugging, and security — is in
@@ -543,8 +588,8 @@ node test-device-auth.mjs  # device-auth polling flow against a local mock
   command runs `dist/`, and the version is read from `package.json` at runtime.
 - **Stale link after the rename** — `npm unlink -g orbitalcode && npm link`.
 - **Login times out** — the device code lives 10 minutes; press Enter to retry,
-  or paste a token manually. Against a local stack, set `ORBCODE_BACKEND_URL`
-  and `ORBCODE_APP_URL`.
+  or paste a token manually. Against a local stack, set `MATTERAI_BACKEND_URL`
+  and `MATTERAI_APP_URL`.
 - **401 on chat** — token expired: `/logout` then `/login`.
 - **Keyboard input does nothing** — OrbCode needs a real TTY (raw mode); it
   won't accept piped stdin. Use `-p` for non-interactive runs.

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/auth/auth.js

@@ -32,10 +32,10 @@ export function getSignInUrl() {
     return `${APP_URL}/authentication/sign-in?loginType=extension&source=cli`;
 }
 function deviceAuthBaseUrl() {
-    return process.env.ORBCODE_BACKEND_URL || DEFAULT_BACKEND_URL;
+    return process.env.MATTERAI_BACKEND_URL || DEFAULT_BACKEND_URL;
 }
 function deviceAuthAppUrl() {
-    return process.env.ORBCODE_APP_URL || APP_URL;
+    return process.env.MATTERAI_APP_URL || APP_URL;
 }
 export async function startDeviceAuth() {
     const response = await fetch(`${deviceAuthBaseUrl()}/orbcode/auth/start`, {

package/dist/config/settings.js

@@ -20,7 +20,7 @@ const SETTINGS_KEYS = [
     "env",
 ];
 export function getConfigDir() {
-    return process.env.ORBCODE_CONFIG_DIR || path.join(os.homedir(), ".orbcode");
+    return process.env.MATTERAI_CONFIG_DIR || path.join(os.homedir(), ".orbcode");
 }
 function getConfigPath() {
     return path.join(getConfigDir(), "config.json");
@@ -76,7 +76,7 @@ function isProjectHooksTrusted(cwd, hash) {
     // stdin is not a TTY (so a stray export in a shell rc file can't silently
     // disable the trust gate for interactive sessions). A non-TTY check keeps
     // the gate meaningful in the TUI while still letting CI opt in.
-    if (process.env.ORBCODE_TRUST_PROJECT_HOOKS === "1" && !process.stdin.isTTY)
+    if (process.env.MATTERAI_TRUST_PROJECT_HOOKS === "1" && !process.stdin.isTTY)
         return true;
     const store = readJson(getTrustStorePath());
     return Boolean(store && store[cwd] === hash);
@@ -179,23 +179,23 @@ export function loadSettings() {
         }
     }
     // Environment variables take precedence over all files.
-    if (process.env.ORBCODE_BASE_URL)
-        settings.baseUrl = process.env.ORBCODE_BASE_URL;
-    if (process.env.ORBCODE_API_KEY)
-        settings.apiKey = process.env.ORBCODE_API_KEY;
-    if (process.env.ORBCODE_MODEL)
-        settings.model = process.env.ORBCODE_MODEL;
+    if (process.env.MATTERAI_BASE_URL)
+        settings.baseUrl = process.env.MATTERAI_BASE_URL;
+    if (process.env.MATTERAI_API_KEY)
+        settings.apiKey = process.env.MATTERAI_API_KEY;
+    if (process.env.MATTERAI_MODEL)
+        settings.model = process.env.MATTERAI_MODEL;
     if (!isValidAxonModel(settings.model)) {
         settings.model = DEFAULT_MODEL_ID;
     }
     return settings;
 }
 /**
- * Effective credential: ORBCODE_TOKEN env > apiKey (settings.json / env) >
+ * Effective credential: MATTERAI_TOKEN env > apiKey (settings.json / env) >
  * stored login token.
  */
 export function getAuthToken(settings) {
-    return process.env.ORBCODE_TOKEN || settings.apiKey || settings.token;
+    return process.env.MATTERAI_TOKEN || settings.apiKey || settings.token;
 }
 /** Persist app state to config.json. settings.json-only fields are skipped. */
 export function saveSettings(settings) {

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/core/hooks.js

@@ -260,11 +260,11 @@ function capContext(text) {
 }
 /** Keys always stripped from the hook environment (OrbCode credentials/config). */
 const HOOK_ENV_REDACT_EXACT = new Set([
-    "ORBCODE_TOKEN",
-    "ORBCODE_API_KEY",
-    "ORBCODE_CONFIG_DIR",
-    "ORBCODE_BACKEND_URL",
-    "ORBCODE_APP_URL",
+    "MATTERAI_TOKEN",
+    "MATTERAI_API_KEY",
+    "MATTERAI_CONFIG_DIR",
+    "MATTERAI_BACKEND_URL",
+    "MATTERAI_APP_URL",
 ]);
 /** Pattern for credential-like env var names (TOKEN, KEY, SECRET, …) so
  *  third-party secrets (GITHUB_TOKEN, AWS_SECRET_ACCESS_KEY, …) are redacted
@@ -274,7 +274,7 @@ const HOOK_ENV_REDACT_PATTERN = /(?:^|_)(TOKEN|KEY|SECRET|PASSWORD|PASSWD|CREDEN
  *  (so PATH, HOME, npx, git, … all work) minus anything that looks like a
  *  credential — hooks must never see the user's API token. */
 function buildHookEnv(cwd) {
-    const env = { ORBCODE_PROJECT_DIR: cwd };
+    const env = { MATTERAI_PROJECT_DIR: cwd };
     for (const [key, value] of Object.entries(process.env)) {
         if (value === undefined)
             continue;

package/dist/headless.js

@@ -1,11 +1,24 @@
+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 MATTERAI_MODEL) silently resolves to the default; say
+    // so on stderr instead of quietly running a different model than requested.
+    const requestedModel = process.env.MATTERAI_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) {
-        console.error("Not signed in. Run `orbcode login`, set ORBCODE_TOKEN, or put an apiKey in settings.json.");
+    // 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 MATTERAI_TOKEN, or put an apiKey in settings.json.");
         process.exit(1);
     }
     // There's no interactive trust prompt in headless mode, so untrusted project
@@ -13,7 +26,7 @@ export async function runHeadless(prompt, yolo) {
     const pendingHooks = getPendingProjectHooks();
     if (pendingHooks) {
         process.stderr.write(`note: ${pendingHooks.commands.length} project hook(s) in .orbcode/settings.json are untrusted and were skipped. ` +
-            `Trust them in an interactive session, or set ORBCODE_TRUST_PROJECT_HOOKS=1.\n`);
+            `Trust them in an interactive session, or set MATTERAI_TRUST_PROJECT_HOOKS=1.\n`);
     }
     let exitCode = 0;
     // Only the final content is printed: either the attempt_completion result
@@ -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/dist/index.js

@@ -88,9 +88,9 @@ async function main() {
     }
     const model = takeFlagValue(args, "model") ?? takeFlagValue(args, "m");
     if (model) {
-        // loadSettings() treats ORBCODE_MODEL as the highest-precedence override,
+        // loadSettings() treats MATTERAI_MODEL as the highest-precedence override,
         // so the flag reaches both the TUI and headless mode without plumbing.
-        process.env.ORBCODE_MODEL = model;
+        process.env.MATTERAI_MODEL = model;
     }
     let initialSession;
     const resumeId = takeFlagValue(args, "resume") ?? takeFlagValue(args, "r");

package/dist/ui/App.js

@@ -523,7 +523,7 @@ export function App({ initialView, initialPrompt, initialSession, updateCheck, }
                         `Version     ${VERSION}`,
                         `Model       ${model.name} (${model.id})`,
                         `Directory   ${process.cwd()}`,
-                        `Account     ${getAuthToken(settings) ? (settings.apiKey || process.env.ORBCODE_TOKEN ? "API key" : "signed in") : "signed out"}${settings.organizationId ? ` · org ${settings.organizationId}` : ""}`,
+                        `Account     ${getAuthToken(settings) ? (settings.apiKey || process.env.MATTERAI_TOKEN ? "API key" : "signed in") : "signed out"}${settings.organizationId ? ` · org ${settings.organizationId}` : ""}`,
                         `Gateway     ${settings.baseUrl ?? "MatterAI (default)"}`,
                         `Context     ${contextTokens.toLocaleString()} / ${model.contextWindow.toLocaleString()} tokens (${contextPct}%)`,
                         `Cost        $${totalCost.toFixed(4)} this session`,

package/dist/ui/LoginView.js

@@ -78,5 +78,5 @@ export function LoginView({ onLogin }) {
             void beginBrowserLogin();
         }
     });
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: COLORS.primary, paddingX: 1, children: [_jsxs(Text, { bold: true, color: COLORS.primary, children: ["Sign in to ", PRODUCT_NAME] }), phase === "waiting" ? (_jsxs(_Fragment, { children: [_jsx(Box, { marginTop: 1, children: _jsx(Spinner, { label: "Waiting for authorization in your browser" }) }), _jsx(Text, { dimColor: true, children: "Approve the \"Authorize OrbCode CLI\" dialog at:" }), _jsxs(Text, { dimColor: true, children: [" ", authorizeUrl] }), _jsx(Text, { dimColor: true, children: "Esc to cancel" })] })) : (_jsxs(Text, { children: ["Press ", _jsx(Text, { bold: true, children: "Enter" }), " to open MatterAI in your browser and authorize OrbCode CLI."] })), phase === "starting" && _jsx(Text, { color: COLORS.thinking, children: "Contacting sign-in service\u2026" }), phase === "verifying" && _jsx(Text, { color: COLORS.thinking, children: "Verifying\u2026" }), error && _jsxs(Text, { color: COLORS.error, children: ["\u2717 ", error] }), _jsx(Text, { dimColor: true, children: "To use a token instead, set apiKey in ~/.orbcode/settings.json or the ORBCODE_TOKEN env var." })] }));
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: COLORS.primary, paddingX: 1, children: [_jsxs(Text, { bold: true, color: COLORS.primary, children: ["Sign in to ", PRODUCT_NAME] }), phase === "waiting" ? (_jsxs(_Fragment, { children: [_jsx(Box, { marginTop: 1, children: _jsx(Spinner, { label: "Waiting for authorization in your browser" }) }), _jsx(Text, { dimColor: true, children: "Approve the \"Authorize OrbCode CLI\" dialog at:" }), _jsxs(Text, { dimColor: true, children: [" ", authorizeUrl] }), _jsx(Text, { dimColor: true, children: "Esc to cancel" })] })) : (_jsxs(Text, { children: ["Press ", _jsx(Text, { bold: true, children: "Enter" }), " to open MatterAI in your browser and authorize OrbCode CLI."] })), phase === "starting" && _jsx(Text, { color: COLORS.thinking, children: "Contacting sign-in service\u2026" }), phase === "verifying" && _jsx(Text, { color: COLORS.thinking, children: "Verifying\u2026" }), error && _jsxs(Text, { color: COLORS.error, children: ["\u2717 ", error] }), _jsx(Text, { dimColor: true, children: "To use a token instead, set apiKey in ~/.orbcode/settings.json or the MATTERAI_TOKEN env var." })] }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterailab/orbcode",
-  "version": "0.1.13",
+  "version": "0.2.0",
   "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",