gsd-pi 2.63.0 → 2.64.0-dev.9c14bd0

package/dist/resources/extensions/mcp-client/index.js

@@ -18,6 +18,7 @@ import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js"
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { readFileSync, existsSync } from "node:fs";
 import { join } from "node:path";
+import { buildHttpTransportOpts } from "./auth.js";
 // ─── Connection Manager ───────────────────────────────────────────────────────
 const connections = new Map();
 let configCache = null;
@@ -51,6 +52,8 @@ function readConfigs() {
                     : hasUrl
                         ? "http"
                         : "unknown";
+                const hasHeaders = hasUrl && config.headers && typeof config.headers === "object";
+                const hasOAuth = hasUrl && config.oauth && typeof config.oauth === "object";
                 servers.push({
                     name,
                     transport,
@@ -63,6 +66,8 @@ function readConfigs() {
                         cwd: typeof config.cwd === "string" ? config.cwd : undefined,
                     }),
                     ...(hasUrl && { url: config.url }),
+                    headers: hasHeaders ? config.headers : undefined,
+                    oauth: hasOAuth ? config.oauth : undefined,
                 });
             }
         }
@@ -113,7 +118,11 @@ async function getOrConnect(name, signal) {
     }
     else if (config.transport === "http" && config.url) {
         const resolvedUrl = config.url.replace(/\$\{([^}]+)\}/g, (_, varName) => process.env[varName] ?? "");
-        transport = new StreamableHTTPClientTransport(new URL(resolvedUrl));
+        const httpOpts = buildHttpTransportOpts({
+            headers: config.headers,
+            oauth: config.oauth,
+        });
+        transport = new StreamableHTTPClientTransport(new URL(resolvedUrl), httpOpts);
     }
     else {
         throw new Error(`Server "${config.name}" has unsupported transport: ${config.transport}`);

package/dist/resources/extensions/ollama/index.js

@@ -17,16 +17,9 @@
  */
 import { importExtensionModule } from "@gsd/pi-coding-agent";
 import * as client from "./ollama-client.js";
-import { discoverModels, getOllamaOpenAIBaseUrl } from "./ollama-discovery.js";
+import { discoverModels } from "./ollama-discovery.js";
 import { registerOllamaCommands } from "./ollama-commands.js";
-/** Default compat settings for Ollama models via OpenAI-compat endpoint */
-const OLLAMA_COMPAT = {
-    supportsDeveloperRole: false,
-    supportsReasoningEffort: false,
-    supportsUsageInStreaming: false,
-    maxTokensField: "max_tokens",
-    supportsStore: false,
-};
+import { streamOllamaChat } from "./ollama-chat-provider.js";
 let toolsPromise = null;
 async function registerOllamaTools(pi) {
     if (!toolsPromise) {
@@ -58,11 +51,17 @@ async function probeAndRegister(pi) {
     const models = await discoverModels();
     if (models.length === 0)
         return true; // Running but no models pulled
-    const baseUrl = getOllamaOpenAIBaseUrl();
+    const baseUrl = client.getOllamaHost();
+    // Use authMode "apiKey" with a dummy key (#3440).
+    // authMode "none" requires a custom streamSimple handler, but Ollama uses
+    // the standard OpenAI-compatible streaming endpoint. Ollama ignores the
+    // Authorization header so the dummy key is harmless.
     pi.registerProvider("ollama", {
-        authMode: "none",
+        authMode: "apiKey",
+        apiKey: "ollama",
         baseUrl,
-        api: "openai-completions",
+        api: "ollama-chat",
+        streamSimple: streamOllamaChat,
         isReady: () => true,
         models: models.map((m) => ({
             id: m.id,
@@ -72,7 +71,7 @@ async function probeAndRegister(pi) {
             cost: m.cost,
             contextWindow: m.contextWindow,
             maxTokens: m.maxTokens,
-            compat: OLLAMA_COMPAT,
+            providerOptions: (m.ollamaOptions ?? {}),
         })),
     });
     providerRegistered = true;
@@ -91,16 +90,23 @@ export default function ollama(pi) {
         else {
             await registerOllamaTools(pi);
         }
-        // Async probe — don't block startup
-        probeAndRegister(pi)
-            .then((found) => {
-            if (found && ctx.hasUI) {
-                ctx.ui.setStatus("ollama", "Ollama");
+        // In headless/auto mode, await the probe so the fallback resolver can
+        // see Ollama before the first LLM call (#3531 race condition).
+        // In interactive mode, keep it async for fast startup.
+        if (!ctx.hasUI) {
+            try {
+                await probeAndRegister(pi);
             }
-        })
-            .catch(() => {
-            // Silently ignore probe failures
-        });
+            catch { /* non-fatal */ }
+        }
+        else {
+            probeAndRegister(pi)
+                .then((found) => {
+                if (found)
+                    ctx.ui.setStatus("ollama", "Ollama");
+            })
+                .catch(() => { });
+        }
     });
     pi.on("session_shutdown", async () => {
         if (providerRegistered) {

package/dist/resources/extensions/ollama/model-capabilities.js

@@ -4,50 +4,53 @@
  * Keys are matched as prefixes against the model name (before the colon/tag).
  * More specific entries should appear first.
  */
+// Note: ollamaOptions.num_ctx is set for known model families where the context
+// window is authoritative. For unknown/estimated models, num_ctx is NOT sent
+// to avoid OOM risk — Ollama uses its own safe default instead.
 const KNOWN_MODELS = [
     // ─── Reasoning models ───────────────────────────────────────────────
-    ["deepseek-r1", { contextWindow: 131072, reasoning: true }],
-    ["qwq", { contextWindow: 131072, reasoning: true }],
+    ["deepseek-r1", { contextWindow: 131072, reasoning: true, ollamaOptions: { num_ctx: 131072 } }],
+    ["qwq", { contextWindow: 131072, reasoning: true, ollamaOptions: { num_ctx: 131072 } }],
     // ─── Vision models ──────────────────────────────────────────────────
-    ["llava", { contextWindow: 4096, input: ["text", "image"] }],
-    ["bakllava", { contextWindow: 4096, input: ["text", "image"] }],
-    ["moondream", { contextWindow: 8192, input: ["text", "image"] }],
-    ["llama3.2-vision", { contextWindow: 131072, input: ["text", "image"] }],
-    ["minicpm-v", { contextWindow: 4096, input: ["text", "image"] }],
+    ["llava", { contextWindow: 4096, input: ["text", "image"], ollamaOptions: { num_ctx: 4096 } }],
+    ["bakllava", { contextWindow: 4096, input: ["text", "image"], ollamaOptions: { num_ctx: 4096 } }],
+    ["moondream", { contextWindow: 8192, input: ["text", "image"], ollamaOptions: { num_ctx: 8192 } }],
+    ["llama3.2-vision", { contextWindow: 131072, input: ["text", "image"], ollamaOptions: { num_ctx: 131072 } }],
+    ["minicpm-v", { contextWindow: 4096, input: ["text", "image"], ollamaOptions: { num_ctx: 4096 } }],
     // ─── Code models ────────────────────────────────────────────────────
-    ["codestral", { contextWindow: 262144, maxTokens: 32768 }],
-    ["qwen2.5-coder", { contextWindow: 131072, maxTokens: 32768 }],
-    ["deepseek-coder-v2", { contextWindow: 131072, maxTokens: 16384 }],
-    ["starcoder2", { contextWindow: 16384, maxTokens: 8192 }],
-    ["codegemma", { contextWindow: 8192, maxTokens: 8192 }],
-    ["codellama", { contextWindow: 16384, maxTokens: 8192 }],
-    ["devstral", { contextWindow: 131072, maxTokens: 32768 }],
+    ["codestral", { contextWindow: 262144, maxTokens: 32768, ollamaOptions: { num_ctx: 262144 } }],
+    ["qwen2.5-coder", { contextWindow: 131072, maxTokens: 32768, ollamaOptions: { num_ctx: 131072 } }],
+    ["deepseek-coder-v2", { contextWindow: 131072, maxTokens: 16384, ollamaOptions: { num_ctx: 131072 } }],
+    ["starcoder2", { contextWindow: 16384, maxTokens: 8192, ollamaOptions: { num_ctx: 16384 } }],
+    ["codegemma", { contextWindow: 8192, maxTokens: 8192, ollamaOptions: { num_ctx: 8192 } }],
+    ["codellama", { contextWindow: 16384, maxTokens: 8192, ollamaOptions: { num_ctx: 16384 } }],
+    ["devstral", { contextWindow: 131072, maxTokens: 32768, ollamaOptions: { num_ctx: 131072 } }],
     // ─── Llama family ───────────────────────────────────────────────────
-    ["llama3.3", { contextWindow: 131072, maxTokens: 16384 }],
-    ["llama3.2", { contextWindow: 131072, maxTokens: 16384 }],
-    ["llama3.1", { contextWindow: 131072, maxTokens: 16384 }],
-    ["llama3", { contextWindow: 8192, maxTokens: 8192 }],
-    ["llama2", { contextWindow: 4096, maxTokens: 4096 }],
+    ["llama3.3", { contextWindow: 131072, maxTokens: 16384, ollamaOptions: { num_ctx: 131072 } }],
+    ["llama3.2", { contextWindow: 131072, maxTokens: 16384, ollamaOptions: { num_ctx: 131072 } }],
+    ["llama3.1", { contextWindow: 131072, maxTokens: 16384, ollamaOptions: { num_ctx: 131072 } }],
+    ["llama3", { contextWindow: 8192, maxTokens: 8192, ollamaOptions: { num_ctx: 8192 } }],
+    ["llama2", { contextWindow: 4096, maxTokens: 4096, ollamaOptions: { num_ctx: 4096 } }],
     // ─── Qwen family ────────────────────────────────────────────────────
-    ["qwen3", { contextWindow: 131072, maxTokens: 32768 }],
-    ["qwen2.5", { contextWindow: 131072, maxTokens: 32768 }],
-    ["qwen2", { contextWindow: 131072, maxTokens: 32768 }],
+    ["qwen3", { contextWindow: 131072, maxTokens: 32768, ollamaOptions: { num_ctx: 131072 } }],
+    ["qwen2.5", { contextWindow: 131072, maxTokens: 32768, ollamaOptions: { num_ctx: 131072 } }],
+    ["qwen2", { contextWindow: 131072, maxTokens: 32768, ollamaOptions: { num_ctx: 131072 } }],
     // ─── Gemma family ───────────────────────────────────────────────────
-    ["gemma3", { contextWindow: 131072, maxTokens: 16384 }],
-    ["gemma2", { contextWindow: 8192, maxTokens: 8192 }],
+    ["gemma3", { contextWindow: 131072, maxTokens: 16384, ollamaOptions: { num_ctx: 131072 } }],
+    ["gemma2", { contextWindow: 8192, maxTokens: 8192, ollamaOptions: { num_ctx: 8192 } }],
     // ─── Mistral family ─────────────────────────────────────────────────
-    ["mistral-large", { contextWindow: 131072, maxTokens: 16384 }],
-    ["mistral-small", { contextWindow: 131072, maxTokens: 16384 }],
-    ["mistral-nemo", { contextWindow: 131072, maxTokens: 16384 }],
-    ["mistral", { contextWindow: 32768, maxTokens: 8192 }],
-    ["mixtral", { contextWindow: 32768, maxTokens: 8192 }],
+    ["mistral-large", { contextWindow: 131072, maxTokens: 16384, ollamaOptions: { num_ctx: 131072 } }],
+    ["mistral-small", { contextWindow: 131072, maxTokens: 16384, ollamaOptions: { num_ctx: 131072 } }],
+    ["mistral-nemo", { contextWindow: 131072, maxTokens: 16384, ollamaOptions: { num_ctx: 131072 } }],
+    ["mistral", { contextWindow: 32768, maxTokens: 8192, ollamaOptions: { num_ctx: 32768 } }],
+    ["mixtral", { contextWindow: 32768, maxTokens: 8192, ollamaOptions: { num_ctx: 32768 } }],
     // ─── Phi family ─────────────────────────────────────────────────────
-    ["phi4", { contextWindow: 16384, maxTokens: 16384 }],
-    ["phi3.5", { contextWindow: 131072, maxTokens: 16384 }],
-    ["phi3", { contextWindow: 131072, maxTokens: 4096 }],
+    ["phi4", { contextWindow: 16384, maxTokens: 16384, ollamaOptions: { num_ctx: 16384 } }],
+    ["phi3.5", { contextWindow: 131072, maxTokens: 16384, ollamaOptions: { num_ctx: 131072 } }],
+    ["phi3", { contextWindow: 131072, maxTokens: 4096, ollamaOptions: { num_ctx: 131072 } }],
     // ─── Command R ──────────────────────────────────────────────────────
-    ["command-r-plus", { contextWindow: 131072, maxTokens: 16384 }],
-    ["command-r", { contextWindow: 131072, maxTokens: 16384 }],
+    ["command-r-plus", { contextWindow: 131072, maxTokens: 16384, ollamaOptions: { num_ctx: 131072 } }],
+    ["command-r", { contextWindow: 131072, maxTokens: 16384, ollamaOptions: { num_ctx: 131072 } }],
 ];
 /**
  * Look up capabilities for a model by name.

package/dist/resources/extensions/ollama/ndjson-stream.js

@@ -0,0 +1,54 @@
+// GSD2 — Ollama Extension: NDJSON streaming parser
+/**
+ * Parses a streaming NDJSON (newline-delimited JSON) response body into
+ * typed objects. Used for Ollama's /api/chat and /api/pull endpoints.
+ *
+ * @param strict When true, malformed JSON lines throw instead of being skipped.
+ *   Use strict mode for inference streams where silent data loss is unacceptable.
+ *   Use permissive mode (default) for progress endpoints like /api/pull.
+ */
+export async function* parseNDJsonStream(body, signal, strict = false) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+        while (true) {
+            if (signal?.aborted)
+                break;
+            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)
+                    continue;
+                try {
+                    yield JSON.parse(trimmed);
+                }
+                catch (err) {
+                    if (strict) {
+                        throw new Error(`Malformed NDJSON line from Ollama: ${trimmed.slice(0, 200)}`);
+                    }
+                    // Permissive mode: skip malformed lines
+                }
+            }
+        }
+        // Flush remaining buffer (skip if aborted)
+        if (buffer.trim() && !signal?.aborted) {
+            try {
+                yield JSON.parse(buffer.trim());
+            }
+            catch (err) {
+                if (strict) {
+                    throw new Error(`Malformed NDJSON line from Ollama: ${buffer.trim().slice(0, 200)}`);
+                }
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}

package/dist/resources/extensions/ollama/ollama-chat-provider.js

@@ -0,0 +1,380 @@
+// GSD2 — Ollama Extension: Native /api/chat stream provider
+/**
+ * Implements the "ollama-chat" API provider, streaming responses directly
+ * from Ollama's native /api/chat endpoint instead of the OpenAI compatibility
+ * shim. This exposes Ollama-specific options (num_ctx, keep_alive, num_gpu,
+ * sampling parameters) and surfaces inference performance metrics.
+ */
+import { EventStream, } from "@gsd/pi-ai";
+import { chat } from "./ollama-client.js";
+import { ThinkingTagParser } from "./thinking-parser.js";
+/** Create an AssistantMessageEventStream using the base EventStream class. */
+function createStream() {
+    return new EventStream((event) => event.type === "done" || event.type === "error", (event) => {
+        if (event.type === "done")
+            return event.message;
+        if (event.type === "error")
+            return event.error;
+        throw new Error("Unexpected event type for final result");
+    });
+}
+// ─── Stream handler ─────────────────────────────────────────────────────────
+export function streamOllamaChat(model, context, options) {
+    const stream = createStream();
+    (async () => {
+        const output = buildInitialOutput(model);
+        try {
+            const request = buildRequest(model, context, options);
+            stream.push({ type: "start", partial: output });
+            const useThinkingParser = model.reasoning;
+            const thinkParser = useThinkingParser ? new ThinkingTagParser() : null;
+            let contentIndex = -1;
+            let currentBlockType = null;
+            function startBlock(type) {
+                contentIndex++;
+                currentBlockType = type;
+                if (type === "text") {
+                    output.content.push({ type: "text", text: "" });
+                    stream.push({ type: "text_start", contentIndex, partial: output });
+                }
+                else {
+                    output.content.push({ type: "thinking", thinking: "" });
+                    stream.push({ type: "thinking_start", contentIndex, partial: output });
+                }
+            }
+            function endBlock() {
+                if (currentBlockType === null)
+                    return;
+                if (currentBlockType === "text") {
+                    const block = output.content[contentIndex];
+                    stream.push({ type: "text_end", contentIndex, content: block.text, partial: output });
+                }
+                else {
+                    const block = output.content[contentIndex];
+                    stream.push({ type: "thinking_end", contentIndex, content: block.thinking, partial: output });
+                }
+                currentBlockType = null;
+            }
+            function emitDelta(type, text) {
+                if (!text)
+                    return;
+                if (currentBlockType !== type) {
+                    endBlock();
+                    startBlock(type);
+                }
+                if (type === "text") {
+                    output.content[contentIndex].text += text;
+                    stream.push({ type: "text_delta", contentIndex, delta: text, partial: output });
+                }
+                else {
+                    output.content[contentIndex].thinking += text;
+                    stream.push({ type: "thinking_delta", contentIndex, delta: text, partial: output });
+                }
+            }
+            function processChunks(chunks) {
+                for (const chunk of chunks) {
+                    emitDelta(chunk.type, chunk.text);
+                }
+            }
+            function processToolCalls(toolCalls) {
+                endBlock();
+                for (const tc of toolCalls) {
+                    contentIndex++;
+                    const toolCall = {
+                        type: "toolCall",
+                        id: `ollama_tc_${contentIndex}`,
+                        name: tc.function.name,
+                        arguments: tc.function.arguments,
+                    };
+                    output.content.push(toolCall);
+                    stream.push({ type: "toolcall_start", contentIndex, partial: output });
+                    // Emit a delta with the serialized arguments (convention: start/delta/end)
+                    stream.push({
+                        type: "toolcall_delta",
+                        contentIndex,
+                        delta: JSON.stringify(tc.function.arguments),
+                        partial: output,
+                    });
+                    stream.push({
+                        type: "toolcall_end",
+                        contentIndex,
+                        toolCall,
+                        partial: output,
+                    });
+                }
+                output.stopReason = "toolUse";
+            }
+            for await (const chunk of chat(request, options?.signal)) {
+                // Handle text content — process independently of tool_calls
+                // (a chunk may contain both content and tool_calls)
+                const content = chunk.message?.content ?? "";
+                if (content) {
+                    if (thinkParser) {
+                        processChunks(thinkParser.push(content));
+                    }
+                    else {
+                        emitDelta("text", content);
+                    }
+                }
+                // Handle tool calls (Ollama sends them complete, may be on done:true chunk)
+                if (chunk.message?.tool_calls?.length) {
+                    processToolCalls(chunk.message.tool_calls);
+                }
+                if (chunk.done) {
+                    // Final chunk — extract metrics and usage
+                    if (thinkParser)
+                        processChunks(thinkParser.flush());
+                    endBlock();
+                    output.usage = buildUsage(chunk);
+                    output.inferenceMetrics = extractMetrics(chunk);
+                    // Preserve "toolUse" if tool calls were processed
+                    if (output.stopReason !== "toolUse") {
+                        output.stopReason = mapStopReason(chunk.done_reason);
+                    }
+                    break;
+                }
+            }
+            assertStreamSuccess(output, options?.signal);
+            finalizeStream(stream, output);
+        }
+        catch (error) {
+            handleStreamError(stream, output, error, options?.signal);
+        }
+    })();
+    return stream;
+}
+// ─── Request building ───────────────────────────────────────────────────────
+function buildRequest(model, context, options) {
+    const ollamaOpts = (model.providerOptions ?? {});
+    const request = {
+        model: model.id,
+        messages: convertMessages(context),
+        stream: true,
+    };
+    // Build options block with all Ollama-specific parameters
+    const reqOptions = {};
+    // Context window — only sent when explicitly configured via providerOptions.
+    // Sending inferred/estimated values risks OOM on constrained hosts.
+    // Users can set num_ctx per-model in models.json ollamaOptions or the
+    // capability table can provide it for known model families.
+    if (ollamaOpts.num_ctx !== undefined && ollamaOpts.num_ctx > 0) {
+        reqOptions.num_ctx = ollamaOpts.num_ctx;
+    }
+    // Max output tokens
+    const maxTokens = options?.maxTokens ?? model.maxTokens;
+    if (maxTokens > 0) {
+        reqOptions.num_predict = maxTokens;
+    }
+    // Temperature
+    if (options?.temperature !== undefined) {
+        reqOptions.temperature = options.temperature;
+    }
+    // Per-model sampling options from providerOptions
+    if (ollamaOpts.top_p !== undefined)
+        reqOptions.top_p = ollamaOpts.top_p;
+    if (ollamaOpts.top_k !== undefined)
+        reqOptions.top_k = ollamaOpts.top_k;
+    if (ollamaOpts.repeat_penalty !== undefined)
+        reqOptions.repeat_penalty = ollamaOpts.repeat_penalty;
+    if (ollamaOpts.seed !== undefined)
+        reqOptions.seed = ollamaOpts.seed;
+    if (ollamaOpts.num_gpu !== undefined)
+        reqOptions.num_gpu = ollamaOpts.num_gpu;
+    if (Object.keys(reqOptions).length > 0) {
+        request.options = reqOptions;
+    }
+    // Keep alive
+    if (ollamaOpts.keep_alive !== undefined) {
+        request.keep_alive = ollamaOpts.keep_alive;
+    }
+    // Tools
+    if (context.tools?.length) {
+        request.tools = convertTools(context.tools);
+    }
+    return request;
+}
+// ─── Message conversion ─────────────────────────────────────────────────────
+function convertMessages(context) {
+    const messages = [];
+    // System prompt
+    if (context.systemPrompt) {
+        messages.push({ role: "system", content: context.systemPrompt });
+    }
+    for (const msg of context.messages) {
+        switch (msg.role) {
+            case "user":
+                messages.push(convertUserMessage(msg));
+                break;
+            case "assistant":
+                messages.push(convertAssistantMessage(msg));
+                break;
+            case "toolResult":
+                messages.push({
+                    role: "tool",
+                    content: msg.content
+                        .filter((c) => c.type === "text")
+                        .map((c) => c.text)
+                        .join("\n"),
+                    name: msg.toolName,
+                });
+                break;
+        }
+    }
+    return messages;
+}
+function convertUserMessage(msg) {
+    if (typeof msg.content === "string") {
+        return { role: "user", content: msg.content };
+    }
+    const textParts = [];
+    const images = [];
+    for (const part of msg.content) {
+        if (part.type === "text") {
+            textParts.push(part.text);
+        }
+        else if (part.type === "image") {
+            // Strip data URI prefix if present
+            let data = part.data;
+            const commaIdx = data.indexOf(",");
+            if (commaIdx !== -1 && data.startsWith("data:")) {
+                data = data.slice(commaIdx + 1);
+            }
+            images.push(data);
+        }
+    }
+    const result = {
+        role: "user",
+        content: textParts.join("\n"),
+    };
+    if (images.length > 0) {
+        result.images = images;
+    }
+    return result;
+}
+function convertAssistantMessage(msg) {
+    let content = "";
+    const toolCalls = [];
+    for (const block of msg.content) {
+        if (block.type === "thinking") {
+            // Serialize thinking back inline for round-trip with Ollama
+            content += `<think>${block.thinking}</think>`;
+        }
+        else if (block.type === "text") {
+            content += block.text;
+        }
+        else if (block.type === "toolCall") {
+            const tc = block;
+            toolCalls.push({
+                function: {
+                    name: tc.name,
+                    arguments: tc.arguments,
+                },
+            });
+        }
+    }
+    const result = { role: "assistant", content };
+    if (toolCalls.length > 0) {
+        result.tool_calls = toolCalls;
+    }
+    return result;
+}
+// ─── Tool conversion ────────────────────────────────────────────────────────
+function convertTools(tools) {
+    return tools.map((tool) => {
+        const params = tool.parameters;
+        return {
+            type: "function",
+            function: {
+                name: tool.name,
+                description: tool.description,
+                parameters: {
+                    type: "object",
+                    required: params.required,
+                    properties: params.properties ?? {},
+                },
+            },
+        };
+    });
+}
+// ─── Response mapping ───────────────────────────────────────────────────────
+function mapStopReason(doneReason) {
+    switch (doneReason) {
+        case "stop":
+            return "stop";
+        case "length":
+            return "length";
+        default:
+            return "stop";
+    }
+}
+function buildUsage(chunk) {
+    const input = chunk.prompt_eval_count ?? 0;
+    const outputTokens = chunk.eval_count ?? 0;
+    return {
+        input,
+        output: outputTokens,
+        cacheRead: 0,
+        cacheWrite: 0,
+        totalTokens: input + outputTokens,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+    };
+}
+function extractMetrics(chunk) {
+    if (!chunk.eval_duration && !chunk.total_duration)
+        return undefined;
+    const evalCount = chunk.eval_count ?? 0;
+    const evalDurationNs = chunk.eval_duration ?? 0;
+    const evalDurationMs = evalDurationNs / 1e6;
+    const tokensPerSecond = evalDurationNs > 0 ? evalCount / (evalDurationNs / 1e9) : 0;
+    return {
+        tokensPerSecond,
+        totalDurationMs: (chunk.total_duration ?? 0) / 1e6,
+        evalDurationMs,
+        promptEvalDurationMs: (chunk.prompt_eval_duration ?? 0) / 1e6,
+    };
+}
+// ─── Stream lifecycle helpers ───────────────────────────────────────────────
+// Replicated from openai-shared.ts (not exported from @gsd/pi-ai)
+function buildInitialOutput(model) {
+    return {
+        role: "assistant",
+        content: [],
+        api: model.api,
+        provider: model.provider,
+        model: model.id,
+        usage: {
+            input: 0,
+            output: 0,
+            cacheRead: 0,
+            cacheWrite: 0,
+            totalTokens: 0,
+            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+        },
+        stopReason: "stop",
+        timestamp: Date.now(),
+    };
+}
+function assertStreamSuccess(output, signal) {
+    if (signal?.aborted) {
+        throw new Error("Request was aborted");
+    }
+    if (output.stopReason === "aborted" || output.stopReason === "error") {
+        throw new Error("An unknown error occurred");
+    }
+}
+function finalizeStream(stream, output) {
+    stream.push({
+        type: "done",
+        reason: output.stopReason,
+        message: output,
+    });
+    stream.end();
+}
+function handleStreamError(stream, output, error, signal) {
+    for (const block of output.content)
+        delete block.index;
+    output.stopReason = signal?.aborted ? "aborted" : "error";
+    output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
+    stream.push({ type: "error", reason: output.stopReason, error: output });
+    stream.end();
+}