@esankhan3/anvil-agent-core 0.1.0

package/dist/opencode-adapter.js

@@ -0,0 +1,105 @@
+/**
+ * OpenCode Go adapter — agentic HTTPS proxy for OpenCode's subscription
+ * service (https://opencode.ai/docs/go).
+ *
+ * OpenCode Go is a $10/month subscription that exposes a curated set of
+ * open coding models (Qwen3.5/3.6 Plus, Kimi K2.5/K2.6, GLM-5/5.1,
+ * DeepSeek V4, MiniMax M2.5/M2.7, MiMo …) via an OpenAI-compatible API
+ * at `https://opencode.ai/zen/go/v1/`. From our perspective it's just
+ * another OpenAI-compatible endpoint — same SSE format, same tool-call
+ * delta protocol — so we inherit `OpenRouterAdapter`'s agentic loop
+ * and override the config.
+ *
+ * Models in the registry are addressed as `opencode/<model>` (e.g.
+ * `opencode/qwen3.5-plus`). The adapter strips the `opencode/` prefix
+ * before sending to the upstream API. No binary, no daemon, no local
+ * SDK — just HTTP + an API key from the user's Go subscription.
+ *
+ * Replaces Ollama as the cheap local-tier provider when the user has
+ * a Go subscription: VRAM cost drops from ~12 GB (Ollama hosting
+ * qwen3:14b) to 0 GB, RAM cost stays nominal. Inference happens on
+ * OpenCode's hosted infrastructure.
+ */
+import { OpenRouterAdapter } from './openrouter-adapter.js';
+const PREFIX = 'opencode/';
+/**
+ * Pricing fallbacks for known OpenCode Go models. The proxy also
+ * returns `usage.cost` directly (mirrors OpenRouter's behavior); when
+ * present the inherited base class prefers that over this table. These
+ * entries are for the offline path / cost estimates before a call
+ * runs. Pricing reflects model-card list rates as of 2026-05.
+ */
+const OPENCODE_GO_PRICING = {
+    // GLM family
+    'glm-5': [0.50, 2.00],
+    'glm-5.1': [0.60, 2.40],
+    // Kimi family
+    'kimi-k2.5': [0.30, 1.20],
+    'kimi-k2.6': [0.50, 2.00],
+    // MiMo
+    'mimo-v2-pro': [0.40, 1.60],
+    'mimo-v2-omni': [0.20, 0.80],
+    'mimo-v2.5-pro': [0.40, 1.60],
+    'mimo-v2.5': [0.20, 0.80],
+    // MiniMax
+    'minimax-m2.5': [0.10, 0.40],
+    'minimax-m2.7': [0.20, 0.80],
+    // Qwen
+    'qwen3.5-plus': [0.05, 0.20],
+    'qwen3.6-plus': [0.20, 0.80],
+    // DeepSeek
+    'deepseek-v4-pro': [0.20, 0.80],
+    'deepseek-v4-flash': [0.02, 0.08],
+};
+export class OpenCodeAdapter extends OpenRouterAdapter {
+    provider = 'opencode';
+    // -- Configuration overrides ----------------------------------------------
+    getApiKey() {
+        return process.env.OPENCODE_API_KEY;
+    }
+    getBaseUrl() {
+        // Default endpoint per https://opencode.ai/docs/go. Allow override
+        // via OPENCODE_BASE_URL so users on different regions or testing
+        // against a local opencode serve instance can redirect.
+        return (process.env.OPENCODE_BASE_URL ?? 'https://opencode.ai/zen/go/v1').replace(/\/+$/, '');
+    }
+    getExtraHeaders() {
+        return {
+            // X-Title shows up in OpenCode's usage console; HTTP-Referer is
+            // OpenRouter-specific and not required here.
+            'X-Title': 'Anvil',
+        };
+    }
+    // -- Model id handling ----------------------------------------------------
+    supportsModel(modelId) {
+        // Registry uses the `opencode/` prefix to disambiguate from
+        // OpenRouter's `<provider>/<model>` slugs (which pass the same
+        // `includes('/')` test the parent uses).
+        return modelId.startsWith(PREFIX);
+    }
+    getModelPricing(modelId) {
+        const stripped = modelId.startsWith(PREFIX) ? modelId.slice(PREFIX.length) : modelId;
+        return OPENCODE_GO_PRICING[stripped] ?? null;
+    }
+    // -- Run override: strip prefix before calling upstream -------------------
+    async run(config, output) {
+        if (!config.model.startsWith(PREFIX)) {
+            // Safety net — caller should always send a properly-prefixed id,
+            // but if they don't we tolerate it rather than 500'ing.
+            return super.run(config, output);
+        }
+        const upstreamModel = config.model.slice(PREFIX.length);
+        const result = await super.run({ ...config, model: upstreamModel }, output);
+        // Re-stamp the result with our prefixed id so downstream telemetry
+        // attributes the call to the OpenCode adapter, not OpenRouter.
+        return { ...result, provider: this.provider, model: config.model };
+    }
+    // -- Availability ---------------------------------------------------------
+    async checkAvailability() {
+        const key = this.getApiKey();
+        if (!key)
+            return { available: false, error: 'OPENCODE_API_KEY is not set (subscribe at https://opencode.ai/zen)' };
+        return { available: true };
+    }
+}
+//# sourceMappingURL=opencode-adapter.js.map

package/dist/opencode-adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"opencode-adapter.js","sourceRoot":"","sources":["../src/opencode-adapter.ts"],"names":[],"mappings":"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"}

package/dist/openrouter-adapter.d.ts

@@ -0,0 +1,69 @@
+/**
+ * OpenRouter adapter — agentic OpenAI-compatible client.
+ *
+ * OpenRouter aggregates many providers (Anthropic / Google / Meta / OpenAI…)
+ * behind one OpenAI-compatible API. Models advertise via the `provider/model`
+ * id format (e.g. `anthropic/claude-sonnet-4-6`).
+ *
+ * Two modes, picked at runtime by the presence of `config.toolExecutor`:
+ *
+ *   1. Single-shot chat — no executor. Drains one /v1/chat/completions
+ *      response, emits text + result. Backwards-compatible with every
+ *      caller that existed before agentic support landed.
+ *
+ *   2. Agentic loop — executor present. Each turn the adapter sends
+ *      `tools: [...]` (OpenAI function-calling shape), reassembles
+ *      `tool_calls` from streaming deltas (OpenAI streams arguments
+ *      piecemeal, indexed), executes via the executor, appends the
+ *      assistant + tool messages to history, and re-POSTs. Loops up
+ *      to maxToolIterations (default 32).
+ *
+ * Capabilities flip to `tier: 'agentic'` because the adapter now drives
+ * a full agentic loop, same as OllamaAdapter. Stage-policy.yaml's
+ * build/validate/ship can route here when ANVIL_LLM_PROVIDER=openrouter
+ * or via per-stage models.yaml entries.
+ */
+import type { ModelAdapter, ModelAdapterConfig, ModelAdapterResult, ProviderCapabilities, ProviderName } from './types.js';
+/**
+ * Re-export the shared `UpstreamError` so existing imports
+ * (`import { UpstreamError } from '@esankhan3/anvil-agent-core/openrouter-adapter'`)
+ * keep working. The class itself lives in `upstream-error.ts` and is
+ * shared by every adapter that talks to a remote provider.
+ */
+export { UpstreamError } from './upstream-error.js';
+export declare class OpenRouterAdapter implements ModelAdapter {
+    readonly provider: ProviderName;
+    readonly capabilities: ProviderCapabilities;
+    /**
+     * In-flight AbortControllers — one per concurrent run() invocation.
+     * The adapter is a singleton (registered once with ProviderRegistry),
+     * but per-repo stages run multiple repos in parallel against it. A
+     * single instance-level field would let one call's `finally` block
+     * null out the controller while another call is still mid-fetch,
+     * causing "Cannot read properties of null (reading 'signal')". The
+     * Set lets every concurrent call own its own AbortController without
+     * trampling, and `kill()` aborts ALL of them (matches legacy
+     * "stop the run" semantics).
+     */
+    private activeControllers;
+    protected getApiKey(): string | undefined;
+    protected getBaseUrl(): string;
+    protected getExtraHeaders(): Record<string, string>;
+    supportsModel(modelId: string): boolean;
+    getModelPricing(modelId: string): [number, number] | null;
+    checkAvailability(): Promise<{
+        available: boolean;
+        version?: string;
+        error?: string;
+    }>;
+    kill(): void;
+    run(config: ModelAdapterConfig, output: NodeJS.WritableStream): Promise<ModelAdapterResult>;
+    private runOneTurn;
+    /**
+     * Drain the SSE stream. Reassembles `tool_calls` from streamed deltas
+     * (OpenAI sends arguments as multiple chunks indexed by tool-call
+     * `index`). Emits text deltas to the output stream as they arrive.
+     */
+    private consumeSSE;
+}
+//# sourceMappingURL=openrouter-adapter.d.ts.map

package/dist/openrouter-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openrouter-adapter.d.ts","sourceRoot":"","sources":["../src/openrouter-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAGH,OAAO,KAAK,EACV,YAAY,EACZ,kBAAkB,EAClB,kBAAkB,EAClB,oBAAoB,EACpB,YAAY,EAIb,MAAM,YAAY,CAAC;AAKpB;;;;;GAKG;AACH,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAoHpD,qBAAa,iBAAkB,YAAW,YAAY;IACpD,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAgB;IAE/C,QAAQ,CAAC,YAAY,EAAE,oBAAoB,CAYzC;IAEF;;;;;;;;;;OAUG;IACH,OAAO,CAAC,iBAAiB,CAA8B;IAIvD,SAAS,CAAC,SAAS,IAAI,MAAM,GAAG,SAAS;IAIzC,SAAS,CAAC,UAAU,IAAI,MAAM;IAI9B,SAAS,CAAC,eAAe,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAWnD,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAMvC,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI;IAInD,iBAAiB,IAAI,OAAO,CAAC;QAAE,SAAS,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAM5F,IAAI,IAAI,IAAI;IAON,GAAG,CAAC,MAAM,EAAE,kBAAkB,EAAE,MAAM,EAAE,MAAM,CAAC,cAAc,GAAG,OAAO,CAAC,kBAAkB,CAAC;YA+HnF,UAAU;IAsDxB;;;;OAIG;YACW,UAAU;CAgKzB"}

package/dist/openrouter-adapter.js

@@ -0,0 +1,481 @@
+/**
+ * OpenRouter adapter — agentic OpenAI-compatible client.
+ *
+ * OpenRouter aggregates many providers (Anthropic / Google / Meta / OpenAI…)
+ * behind one OpenAI-compatible API. Models advertise via the `provider/model`
+ * id format (e.g. `anthropic/claude-sonnet-4-6`).
+ *
+ * Two modes, picked at runtime by the presence of `config.toolExecutor`:
+ *
+ *   1. Single-shot chat — no executor. Drains one /v1/chat/completions
+ *      response, emits text + result. Backwards-compatible with every
+ *      caller that existed before agentic support landed.
+ *
+ *   2. Agentic loop — executor present. Each turn the adapter sends
+ *      `tools: [...]` (OpenAI function-calling shape), reassembles
+ *      `tool_calls` from streaming deltas (OpenAI streams arguments
+ *      piecemeal, indexed), executes via the executor, appends the
+ *      assistant + tool messages to history, and re-POSTs. Loops up
+ *      to maxToolIterations (default 32).
+ *
+ * Capabilities flip to `tier: 'agentic'` because the adapter now drives
+ * a full agentic loop, same as OllamaAdapter. Stage-policy.yaml's
+ * build/validate/ship can route here when ANVIL_LLM_PROVIDER=openrouter
+ * or via per-stage models.yaml entries.
+ */
+import { randomUUID } from 'node:crypto';
+import { emitContent, emitResult, emitToolResult, emitToolUse } from './stream-format.js';
+const DEFAULT_MAX_ITERATIONS = 32;
+/**
+ * Re-export the shared `UpstreamError` so existing imports
+ * (`import { UpstreamError } from '@esankhan3/anvil-agent-core/openrouter-adapter'`)
+ * keep working. The class itself lives in `upstream-error.ts` and is
+ * shared by every adapter that talks to a remote provider.
+ */
+export { UpstreamError } from './upstream-error.js';
+import { UpstreamError as _UpstreamError } from './upstream-error.js';
+// ───────────────────────────────────────────────────────────────────────
+// Pricing fallbacks for well-known OpenRouter slugs. OpenRouter itself
+// returns `usage.cost` in the response when available — that wins. This
+// table is just a fallback for older API versions that don't report it.
+// Price = [inputPer1MTokens, outputPer1MTokens]
+// ───────────────────────────────────────────────────────────────────────
+const OPENROUTER_PRICING = {
+    // OpenAI
+    'openai/gpt-4o': [2.5, 10.0],
+    'openai/gpt-4o-mini': [0.15, 0.60],
+    'openai/gpt-4-turbo': [10.0, 30.0],
+    'openai/o1': [15.0, 60.0],
+    'openai/o3': [10.0, 40.0],
+    'openai/o3-mini': [1.1, 4.4],
+    // Anthropic — current generation
+    'anthropic/claude-haiku-4-5': [1.0, 5.0],
+    'anthropic/claude-sonnet-4-6': [3.0, 15.0],
+    'anthropic/claude-sonnet-4-7': [3.0, 15.0],
+    'anthropic/claude-opus-4-7': [15.0, 75.0],
+    // Google
+    'google/gemini-2.5-flash': [0.30, 2.50],
+    'google/gemini-2.5-pro': [1.25, 10.0],
+    // Meta
+    'meta-llama/llama-3.3-70b-instruct': [0.59, 0.79],
+    // DeepSeek
+    'deepseek/deepseek-r1': [0.55, 2.19],
+};
+// ───────────────────────────────────────────────────────────────────────
+// Adapter
+// ───────────────────────────────────────────────────────────────────────
+export class OpenRouterAdapter {
+    provider = 'openrouter';
+    capabilities = {
+        tier: 'agentic',
+        streaming: true,
+        toolUse: true,
+        fileSystem: true,
+        shellExecution: true,
+        sessionResume: false,
+        promptCaching: true, // OpenRouter passes through provider caching
+        cache: 'auto',
+        cacheTtlSeconds: 600,
+        structuredOutput: 'strict',
+        maxOutputTokens: true,
+    };
+    /**
+     * In-flight AbortControllers — one per concurrent run() invocation.
+     * The adapter is a singleton (registered once with ProviderRegistry),
+     * but per-repo stages run multiple repos in parallel against it. A
+     * single instance-level field would let one call's `finally` block
+     * null out the controller while another call is still mid-fetch,
+     * causing "Cannot read properties of null (reading 'signal')". The
+     * Set lets every concurrent call own its own AbortController without
+     * trampling, and `kill()` aborts ALL of them (matches legacy
+     * "stop the run" semantics).
+     */
+    activeControllers = new Set();
+    // -- Configuration --------------------------------------------------------
+    getApiKey() {
+        return process.env.OPENROUTER_API_KEY;
+    }
+    getBaseUrl() {
+        return (process.env.OPENROUTER_BASE_URL ?? 'https://openrouter.ai/api/v1').replace(/\/+$/, '');
+    }
+    getExtraHeaders() {
+        return {
+            // OpenRouter-recommended attribution headers — surface in their
+            // analytics and rankings dashboards.
+            'HTTP-Referer': 'https://anvil.dev',
+            'X-Title': 'Anvil',
+        };
+    }
+    // -- ModelAdapter interface -----------------------------------------------
+    supportsModel(modelId) {
+        // OpenRouter slugs are `provider/model`. Catches Anthropic, OpenAI,
+        // Google, Meta, etc. without ambiguity vs other adapters.
+        return modelId.includes('/');
+    }
+    getModelPricing(modelId) {
+        return OPENROUTER_PRICING[modelId] ?? null;
+    }
+    async checkAvailability() {
+        const key = this.getApiKey();
+        if (!key)
+            return { available: false, error: 'OPENROUTER_API_KEY is not set' };
+        return { available: true };
+    }
+    kill() {
+        for (const ac of this.activeControllers) {
+            try {
+                ac.abort();
+            }
+            catch { /* already aborted */ }
+        }
+        this.activeControllers.clear();
+    }
+    async run(config, output) {
+        const apiKey = this.getApiKey();
+        if (!apiKey)
+            throw new Error('OPENROUTER_API_KEY is not set');
+        const abortController = new AbortController();
+        this.activeControllers.add(abortController);
+        const startMs = Date.now();
+        const messages = [];
+        if (config.projectPrompt)
+            messages.push({ role: 'system', content: config.projectPrompt });
+        messages.push({ role: 'user', content: config.userPrompt });
+        const tools = config.toolExecutor ? mapSchemasToOpenAI(config.toolExecutor.listSchemas()) : undefined;
+        const maxIter = config.maxToolIterations ?? DEFAULT_MAX_ITERATIONS;
+        let aggregatedText = '';
+        let totalIn = 0;
+        let totalOut = 0;
+        let totalCachedReadTokens = 0;
+        let totalReasoningTokens = 0;
+        let openRouterCost = 0;
+        let stopReason;
+        let providerFinishReason;
+        try {
+            for (let iter = 0; iter < maxIter; iter++) {
+                const turn = await this.runOneTurn(apiKey, messages, tools, config, output, abortController.signal);
+                aggregatedText += turn.text;
+                totalIn += turn.inputTokens;
+                totalOut += turn.outputTokens;
+                totalCachedReadTokens += turn.cachedReadTokens;
+                totalReasoningTokens += turn.reasoningTokens;
+                openRouterCost += turn.cost;
+                if (turn.finishReason)
+                    providerFinishReason = turn.finishReason;
+                if (turn.toolCalls.length === 0 || !config.toolExecutor) {
+                    stopReason = turn.toolCalls.length === 0 ? 'end_turn' : 'tools_unsupported';
+                    break;
+                }
+                // Append assistant turn to history so the model sees its own
+                // tool_calls when we re-prompt with results. Thinking models
+                // (DeepSeek V4, Kimi K2, GLM thinking variants…) require the
+                // reasoning trace echoed back — without it they 400 with
+                // "reasoning_content is missing in assistant tool call".
+                // Send both `reasoning` (string) and `reasoning_details`
+                // (structured) so OpenRouter can map to whichever shape the
+                // upstream provider expects.
+                messages.push({
+                    role: 'assistant',
+                    content: turn.text || null,
+                    ...(turn.reasoning ? { reasoning: turn.reasoning } : {}),
+                    ...(turn.reasoningDetails.length > 0 ? { reasoning_details: turn.reasoningDetails } : {}),
+                    tool_calls: turn.toolCalls,
+                });
+                for (const tc of turn.toolCalls) {
+                    const args = parseArgs(tc.function.arguments);
+                    const call = { id: tc.id, name: tc.function.name, arguments: args };
+                    emitToolUse(output, call.name, args, tc.id);
+                    const result = await invokeTool(config.toolExecutor, call, config.workingDir, abortController.signal);
+                    emitToolResult(output, { toolUseId: tc.id, content: result.content, isError: result.isError });
+                    messages.push({
+                        role: 'tool',
+                        content: result.content,
+                        tool_call_id: tc.id,
+                    });
+                }
+                if (abortController.signal.aborted) {
+                    stopReason = 'aborted';
+                    break;
+                }
+            }
+            if (stopReason === undefined)
+                stopReason = 'iteration_limit';
+        }
+        finally {
+            this.activeControllers.delete(abortController);
+        }
+        const durationMs = Date.now() - startMs;
+        // Cost: prefer OpenRouter's reported cost (covers all providers it
+        // knows). Fall back to our pricing table when absent. When the table
+        // also misses, costUsd = 0 and downstream telemetry will catch the
+        // gap via the central cost table in cost.ts.
+        let costUsd = openRouterCost;
+        if (costUsd === 0) {
+            const pricing = this.getModelPricing(config.model);
+            if (pricing) {
+                costUsd = (totalIn / 1_000_000) * pricing[0] + (totalOut / 1_000_000) * pricing[1];
+            }
+        }
+        // Normalize length finish-reason like OpenAIAdapter does so callers
+        // can detect truncation provider-agnostically.
+        const normalizedStopReason = stopReason === 'end_turn' && providerFinishReason === 'length'
+            ? 'max_tokens'
+            : stopReason;
+        emitResult(output, {
+            text: aggregatedText,
+            costUsd,
+            inputTokens: totalIn,
+            outputTokens: totalOut,
+            durationMs,
+            cacheReadTokens: totalCachedReadTokens,
+        });
+        return {
+            output: aggregatedText,
+            inputTokens: totalIn,
+            outputTokens: totalOut,
+            costUsd,
+            durationMs,
+            provider: this.provider,
+            model: config.model,
+            stopReason: normalizedStopReason,
+            cacheReadTokens: totalCachedReadTokens || undefined,
+            reasoningTokens: totalReasoningTokens || undefined,
+            toolCallCount: countToolCalls(messages),
+        };
+    }
+    // -- Per-turn round-trip --------------------------------------------------
+    async runOneTurn(apiKey, messages, tools, config, output, signal) {
+        const url = `${this.getBaseUrl()}/chat/completions`;
+        const body = {
+            model: config.model,
+            messages,
+            stream: true,
+            stream_options: { include_usage: true },
+        };
+        if (tools && tools.length > 0) {
+            body.tools = tools;
+            body.tool_choice = 'auto';
+        }
+        if (typeof config.maxOutputTokens === 'number' && config.maxOutputTokens > 0) {
+            body.max_tokens = config.maxOutputTokens;
+        }
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${apiKey}`,
+                ...this.getExtraHeaders(),
+            },
+            body: JSON.stringify(body),
+            signal,
+        });
+        if (!response.ok) {
+            const errBody = await response.text();
+            throw new _UpstreamError(response.status, errBody, { provider: this.provider });
+        }
+        if (!response.body)
+            throw new _UpstreamError(0, `${this.provider} returned no response body`, { provider: this.provider });
+        return this.consumeSSE(response, output);
+    }
+    /**
+     * Drain the SSE stream. Reassembles `tool_calls` from streamed deltas
+     * (OpenAI sends arguments as multiple chunks indexed by tool-call
+     * `index`). Emits text deltas to the output stream as they arrive.
+     */
+    async consumeSSE(response, output) {
+        let text = '';
+        let reasoning = '';
+        const reasoningDetails = [];
+        let inputTokens = 0;
+        let outputTokens = 0;
+        let cachedReadTokens = 0;
+        let reasoningTokens = 0;
+        let cost = 0;
+        let finishReason;
+        const toolCallsByIndex = new Map();
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        // Buffer text deltas and flush at natural breaks (newline OR every
+        // ~80 chars). Without this, OpenAI-compatible streams that emit
+        // one token per chunk produce one activity card per word in the
+        // dashboard — every "passes", "(", "all", ")" gets its own row.
+        // Flushing on `\n` or threshold gives readable line-sized chunks.
+        let pendingText = '';
+        const FLUSH_THRESHOLD = 80;
+        const flushPending = () => {
+            if (pendingText.length === 0)
+                return;
+            emitContent(output, pendingText);
+            pendingText = '';
+        };
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split('\n');
+            buffer = lines.pop() ?? '';
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed || trimmed.startsWith(':'))
+                    continue; // empty / SSE comment
+                if (!trimmed.startsWith('data: '))
+                    continue;
+                const payload = trimmed.slice(6);
+                if (payload === '[DONE]')
+                    continue;
+                let chunk;
+                try {
+                    chunk = JSON.parse(payload);
+                }
+                catch {
+                    continue;
+                }
+                const choice = chunk.choices?.[0];
+                const delta = choice?.delta;
+                if (delta?.content) {
+                    text += delta.content;
+                    pendingText += delta.content;
+                    // Split the accumulated buffer on newlines so the flush is
+                    // always anchored at a natural line boundary; emit each
+                    // complete line, retain the trailing partial line.
+                    while (pendingText.includes('\n')) {
+                        const nl = pendingText.indexOf('\n');
+                        const line = pendingText.slice(0, nl + 1);
+                        emitContent(output, line);
+                        pendingText = pendingText.slice(nl + 1);
+                    }
+                    // No newline yet but buffer is large — flush so very long
+                    // single-line outputs (e.g. one paragraph) don't sit
+                    // pending until the very end of the stream.
+                    if (pendingText.length >= FLUSH_THRESHOLD) {
+                        emitContent(output, pendingText);
+                        pendingText = '';
+                    }
+                }
+                if (delta?.reasoning) {
+                    // Accumulate but don't stream to user — reasoning is for the
+                    // upstream's continuation, not for the dashboard activity log.
+                    reasoning += delta.reasoning;
+                }
+                if (delta?.reasoning_details && Array.isArray(delta.reasoning_details)) {
+                    for (const rd of delta.reasoning_details) {
+                        // Merge by index — like tool_calls, reasoning_details are
+                        // streamed piecewise and grouped by `index`.
+                        const idx = typeof rd.index === 'number' ? rd.index : reasoningDetails.length;
+                        const existing = reasoningDetails[idx];
+                        if (!existing) {
+                            reasoningDetails[idx] = { ...rd, text: rd.text ?? '' };
+                        }
+                        else if (rd.text) {
+                            existing.text = (existing.text ?? '') + rd.text;
+                        }
+                    }
+                }
+                if (delta?.tool_calls) {
+                    for (const tcDelta of delta.tool_calls) {
+                        const existing = toolCallsByIndex.get(tcDelta.index);
+                        if (!existing) {
+                            toolCallsByIndex.set(tcDelta.index, {
+                                id: tcDelta.id ?? randomUUID(),
+                                type: 'function',
+                                function: {
+                                    name: tcDelta.function?.name ?? '',
+                                    arguments: tcDelta.function?.arguments ?? '',
+                                },
+                            });
+                        }
+                        else {
+                            if (tcDelta.id)
+                                existing.id = tcDelta.id;
+                            if (tcDelta.function?.name)
+                                existing.function.name += tcDelta.function.name;
+                            if (tcDelta.function?.arguments)
+                                existing.function.arguments += tcDelta.function.arguments;
+                        }
+                    }
+                }
+                if (typeof choice?.finish_reason === 'string') {
+                    finishReason = choice.finish_reason;
+                }
+                if (chunk.usage) {
+                    inputTokens = chunk.usage.prompt_tokens ?? inputTokens;
+                    outputTokens = chunk.usage.completion_tokens ?? outputTokens;
+                    cachedReadTokens = chunk.usage.prompt_tokens_details?.cached_tokens ?? cachedReadTokens;
+                    reasoningTokens = chunk.usage.completion_tokens_details?.reasoning_tokens ?? reasoningTokens;
+                    if (typeof chunk.usage.cost === 'number')
+                        cost = chunk.usage.cost;
+                }
+            }
+        }
+        // Flush any trailing content that didn't end on a newline so the
+        // last line of the response surfaces in the activity log.
+        flushPending();
+        // Sort tool_calls by their original index so loop dispatch order
+        // mirrors what the model intended.
+        const toolCalls = [...toolCallsByIndex.entries()]
+            .sort(([a], [b]) => a - b)
+            .map(([, v]) => v);
+        return {
+            text,
+            reasoning,
+            reasoningDetails: reasoningDetails.filter(Boolean),
+            toolCalls,
+            inputTokens,
+            outputTokens,
+            cachedReadTokens,
+            reasoningTokens,
+            cost,
+            finishReason,
+        };
+    }
+}
+// ───────────────────────────────────────────────────────────────────────
+// Helpers
+// ───────────────────────────────────────────────────────────────────────
+function mapSchemasToOpenAI(schemas) {
+    return schemas.map((s) => ({
+        type: 'function',
+        function: {
+            name: s.name,
+            description: s.description,
+            parameters: s.inputSchema,
+        },
+    }));
+}
+/**
+ * OpenAI streams `tool_calls.arguments` as a JSON-encoded string built
+ * up across many deltas. Parse it, fall back to `{ _raw }` when the
+ * model emitted malformed JSON so the executor still gets a chance to
+ * react.
+ */
+function parseArgs(raw) {
+    if (!raw)
+        return {};
+    try {
+        const parsed = JSON.parse(raw);
+        return typeof parsed === 'object' && parsed !== null ? parsed : { _raw: raw };
+    }
+    catch {
+        return { _raw: raw };
+    }
+}
+async function invokeTool(executor, call, workingDir, abortSignal) {
+    try {
+        return await executor.execute(call, { workingDir, abortSignal });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { content: `Tool execution threw: ${msg}`, isError: true };
+    }
+}
+function countToolCalls(messages) {
+    let n = 0;
+    for (const m of messages) {
+        if (m.role === 'assistant' && m.tool_calls)
+            n += m.tool_calls.length;
+    }
+    return n;
+}
+//# sourceMappingURL=openrouter-adapter.js.map