@matterailab/orbcode 0.1.10 → 0.1.14

package/README.md

@@ -24,6 +24,7 @@ activity rows, edit/command approvals, and todo tracking.
 - [Approvals & safety](#approvals--safety)
 - [Headless mode](#headless-mode)
 - [Configuration](#configuration)
+- [Hooks](#hooks)
 - [Architecture](#architecture)
 - [Tools](#tools)
 - [Agent loop](#agent-loop)
@@ -156,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
 
 ```
@@ -291,9 +337,9 @@ Two kinds of files under `~/.orbcode/`:
 
 All keys are optional. `customModels` entries appear in the `/model` picker
 alongside the built-in Axon models; `baseUrl` points the chat client at any
-OpenAI-compatible gateway; `env` is applied to the process at startup.
-Precedence: env vars > project settings.json > user settings.json >
-config.json.
+OpenAI-compatible gateway; `env` is applied to the process at startup; `hooks`
+configures lifecycle hooks (see [Hooks](#hooks)). Precedence: env vars > project
+settings.json > user settings.json > config.json.
 
 Sessions are stored in `~/.orbcode/sessions/<id>.json` and power `/resume`
 and `--resume <id>`.
@@ -312,6 +358,97 @@ and `--resume <id>`.
 approval prompts (dangerous commands still always prompt); shift+tab cycles
 them at runtime.
 
+## Hooks
+
+Hooks are shell commands OrbCode runs at fixed points in the agent loop — use
+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).
+
+> 📖 **This is the overview. The complete, example-driven reference —
+> per-event input/output, a copy-paste cookbook, debugging, and security — is in
+> [docs/HOOKS.md](https://github.com/MatterAIOrg/OrbCode/blob/main/docs/HOOKS.md).**
+
+### Two-minute example
+
+Make OrbCode block `rm -rf` and append the git branch to every prompt.
+
+**1.** Drop a guard script at `~/.orbcode/hooks/guard.sh` (and `chmod +x` it):
+
+```bash
+#!/usr/bin/env bash
+input=$(cat)                                    # OrbCode sends JSON on stdin
+cmd=$(printf '%s' "$input" | jq -r '.tool_input.command // empty')
+if printf '%s' "$cmd" | grep -Eq 'rm -rf (/|~|\*)'; then
+  echo "Refusing destructive command: $cmd" >&2 # stderr = the reason
+  exit 2                                         # exit 2 = block the tool
+fi
+exit 0
+```
+
+**2.** Register it in `~/.orbcode/settings.json` (user-level) or a project's
+`.orbcode/settings.json` — both are **merged**, so projects can add hooks
+without clobbering your global ones. (User hooks always run; **project hooks are
+disabled until you approve them** in a one-time trust prompt, since they run
+shell commands from a repo — see [Security](https://github.com/MatterAIOrg/OrbCode/blob/main/docs/HOOKS.md#security).)
+
+```json
+{
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "execute_command",
+        "hooks": [{ "type": "command", "command": "~/.orbcode/hooks/guard.sh", "timeout": 30 }]
+      }
+    ],
+    "UserPromptSubmit": [
+      { "hooks": [{ "type": "command", "command": "echo \"Git branch: $(git branch --show-current 2>/dev/null)\"" }] }
+    ]
+  }
+}
+```
+
+Start OrbCode normally — that's all. Each event maps to a list of matchers; a
+matcher has an optional `matcher` regex (omit, or use `"*"`, to match
+everything; the regex is auto-anchored so `"execute_command"` matches exactly
+that tool name) and a list of `command` hooks (`timeout` is per-command
+seconds, default 10).
+
+### Events at a glance
+
+| event              | when it fires                                  | matcher tests |
+| ------------------ | ---------------------------------------------- | ------------- |
+| `SessionStart`     | first turn of a session (or after `--resume`)  | `source`      |
+| `UserPromptSubmit` | before each prompt is sent to the model        | —             |
+| `PreToolUse`       | before a tool runs (and before its approval)   | tool name     |
+| `PostToolUse`      | after a tool returns                           | tool name     |
+| `Notification`     | when OrbCode needs permission or a follow-up   | —             |
+| `Stop`             | when the model is about to finish the turn     | —             |
+| `PreCompact`       | before `/compact` summarizes the conversation  | `trigger`     |
+| `SessionEnd`       | on quit, `/logout`, or end of a `-p` run       | `reason`      |
+| `SubagentStop`     | reserved; OrbCode has no subagents yet         | —             |
+
+### How a hook talks back
+
+A hook receives a JSON payload on **stdin** (`session_id`, `transcript_path`,
+`cwd`, `hook_event_name`, plus event fields like `tool_name`/`tool_input`,
+`prompt`, …) and influences OrbCode via its **exit code** — `0` success
+(stdout becomes context for `UserPromptSubmit`/`SessionStart`), `2` block
+(stderr is the reason), other = non-blocking warning — and/or a **JSON object
+on stdout** for fine control (`decision`, `continue`, `systemMessage`, and a
+`hookSpecificOutput` with `permissionDecision` allow/deny/ask, `updatedInput`,
+`additionalContext`). When several hooks match, they run in parallel, the most
+restrictive permission wins (`deny` > `ask` > `allow`), and a failing/slow hook
+is timed out and never crashes the agent. Hooks run with a **redacted
+environment** (your API token and other credential-like vars are stripped) and
+injected context is wrapped in `<hook_context>` tags the model treats as
+untrusted.
+
+**→ Full reference with worked recipes for every event:
+[docs/HOOKS.md](https://github.com/MatterAIOrg/OrbCode/blob/main/docs/HOOKS.md).**
+
 ## Architecture
 
 ```
@@ -336,6 +473,7 @@ src/
   core/
     agent.ts         the agent loop (see below)
     events.ts        AgentEvent model consumed by the UI
+    hooks.ts         lifecycle hooks engine, Claude-Code compatible (see Hooks)
   ui/
     App.tsx          main Ink app: static finalized rows + dynamic streaming area
     LoginView.tsx    device-flow login screen with paste fallback

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);
+}