gsd-pi 2.63.0-dev.026d309 → 2.63.0-dev.786f0ff

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

package/dist/resources/extensions/ollama/ollama-client.js

@@ -1,4 +1,5 @@
 // GSD2 — HTTP client for Ollama REST API
+import { parseNDJsonStream } from "./ndjson-stream.js";
 const DEFAULT_HOST = "http://localhost:11434";
 const PROBE_TIMEOUT_MS = 1500;
 const REQUEST_TIMEOUT_MS = 10000;
@@ -104,40 +105,30 @@ export async function pullModel(name, onProgress, signal) {
     if (!response.body) {
         throw new Error("Ollama /api/pull returned no body");
     }
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-    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)
-                continue;
-            try {
-                const progress = JSON.parse(trimmed);
-                onProgress?.(progress);
-            }
-            catch {
-                // Skip malformed lines
-            }
-        }
-    }
-    // Process remaining buffer
-    if (buffer.trim()) {
-        try {
-            const progress = JSON.parse(buffer.trim());
-            onProgress?.(progress);
-        }
-        catch {
-            // Ignore
-        }
+    for await (const progress of parseNDJsonStream(response.body, signal)) {
+        onProgress?.(progress);
     }
 }
+/**
+ * Stream a chat completion via /api/chat.
+ * Returns an async generator yielding each NDJSON response chunk.
+ */
+export async function* chat(request, signal) {
+    const response = await fetch(`${getOllamaHost()}/api/chat`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(request),
+        signal,
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Ollama /api/chat returned ${response.status}: ${text}`);
+    }
+    if (!response.body) {
+        throw new Error("Ollama /api/chat returned no body");
+    }
+    yield* parseNDJsonStream(response.body, signal, true);
+}
 /**
  * Delete a local model.
  */

package/dist/resources/extensions/ollama/ollama-discovery.js

@@ -6,7 +6,7 @@
  *
  * Returns models in the format expected by pi.registerProvider().
  */
-import { listModels, getOllamaHost } from "./ollama-client.js";
+import { listModels } from "./ollama-client.js";
 import { estimateContextFromParams, formatModelSize, getModelCapabilities, humanizeModelName, } from "./model-capabilities.js";
 const ZERO_COST = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
 function enrichModel(info) {
@@ -32,6 +32,7 @@ function enrichModel(info) {
         maxTokens,
         sizeBytes: info.size,
         parameterSize,
+        ollamaOptions: caps.ollamaOptions,
     };
 }
 /**
@@ -61,9 +62,3 @@ export function formatModelForDisplay(model) {
     }
     return parts.join(" ");
 }
-/**
- * Build the OpenAI-compat base URL for Ollama.
- */
-export function getOllamaOpenAIBaseUrl() {
-    return `${getOllamaHost()}/v1`;
-}

package/dist/resources/extensions/ollama/ollama-tool.js

@@ -19,6 +19,8 @@ export function registerOllamaTool(pi) {
         promptGuidelines: [
             "Use 'list' to see what models are available locally before trying to use one.",
             "Use 'pull' to download a model that isn't available yet.",
+            "Use 'remove' to delete a local model that is no longer needed.",
+            "Use 'show' to get detailed info about a model (parameters, quantization, families).",
             "Use 'status' to check if Ollama is running.",
             "Use 'ps' to see which models are loaded in memory and VRAM usage.",
             "Common models: llama3.1:8b, qwen2.5-coder:7b, deepseek-r1:8b, codestral:22b",
@@ -27,6 +29,8 @@ export function registerOllamaTool(pi) {
             action: Type.Union([
                 Type.Literal("list"),
                 Type.Literal("pull"),
+                Type.Literal("remove"),
+                Type.Literal("show"),
                 Type.Literal("status"),
                 Type.Literal("ps"),
             ], { description: "Action to perform" }),
@@ -134,6 +138,64 @@ export function registerOllamaTool(pi) {
                             details: { action, modelCount: ps.models.length, durationMs: Date.now() - startTime },
                         };
                     }
+                    case "remove": {
+                        if (!model) {
+                            return {
+                                content: [{ type: "text", text: "Error: 'model' parameter is required for remove action." }],
+                                isError: true,
+                                details: { action, durationMs: Date.now() - startTime, error: "missing_model" },
+                            };
+                        }
+                        const running = await client.isRunning();
+                        if (!running) {
+                            return {
+                                content: [{ type: "text", text: "Ollama is not running." }],
+                                isError: true,
+                                details: { action, model, durationMs: Date.now() - startTime, error: "not_running" },
+                            };
+                        }
+                        await client.deleteModel(model);
+                        return {
+                            content: [{ type: "text", text: `Successfully removed ${model}` }],
+                            details: { action, model, durationMs: Date.now() - startTime },
+                        };
+                    }
+                    case "show": {
+                        if (!model) {
+                            return {
+                                content: [{ type: "text", text: "Error: 'model' parameter is required for show action." }],
+                                isError: true,
+                                details: { action, durationMs: Date.now() - startTime, error: "missing_model" },
+                            };
+                        }
+                        const running = await client.isRunning();
+                        if (!running) {
+                            return {
+                                content: [{ type: "text", text: "Ollama is not running." }],
+                                isError: true,
+                                details: { action, model, durationMs: Date.now() - startTime, error: "not_running" },
+                            };
+                        }
+                        const info = await client.showModel(model);
+                        const details = info.details;
+                        const infoLines = [
+                            `Model: ${model}`,
+                            `Family: ${details.family}`,
+                            `Parameters: ${details.parameter_size}`,
+                            `Quantization: ${details.quantization_level}`,
+                            `Format: ${details.format}`,
+                        ];
+                        if (details.families?.length) {
+                            infoLines.push(`Families: ${details.families.join(", ")}`);
+                        }
+                        if (info.parameters) {
+                            infoLines.push(`\nModelfile parameters:\n${info.parameters}`);
+                        }
+                        return {
+                            content: [{ type: "text", text: infoLines.join("\n") }],
+                            details: { action, model, durationMs: Date.now() - startTime },
+                        };
+                    }
                     default:
                         return {
                             content: [{ type: "text", text: `Unknown action: ${action}` }],

package/dist/resources/extensions/ollama/thinking-parser.js

@@ -0,0 +1,104 @@
+// GSD2 — Ollama Extension: Stateful <think> tag stream parser
+const OPEN_TAG = "<think>";
+const CLOSE_TAG = "</think>";
+const MAX_TAG_LEN = Math.max(OPEN_TAG.length, CLOSE_TAG.length);
+export class ThinkingTagParser {
+    buffer = "";
+    inThinking = false;
+    /**
+     * Feed a chunk of text and get back parsed segments.
+     * May return zero or more segments depending on tag boundaries.
+     */
+    push(chunk) {
+        const results = [];
+        let input = this.buffer + chunk;
+        this.buffer = "";
+        while (input.length > 0) {
+            if (this.inThinking) {
+                const closeIdx = input.indexOf(CLOSE_TAG);
+                if (closeIdx !== -1) {
+                    // Found close tag — emit thinking content before it
+                    const thinking = input.slice(0, closeIdx);
+                    if (thinking)
+                        results.push({ type: "thinking", text: thinking });
+                    this.inThinking = false;
+                    input = input.slice(closeIdx + CLOSE_TAG.length);
+                }
+                else if (this.couldBePartialTag(input, CLOSE_TAG)) {
+                    // Possible partial close tag at end — buffer only the matching tail
+                    const tailLen = this.getPartialTagTailLength(input, CLOSE_TAG);
+                    const safe = input.slice(0, input.length - tailLen);
+                    if (safe)
+                        results.push({ type: "thinking", text: safe });
+                    this.buffer = input.slice(-tailLen);
+                    break;
+                }
+                else {
+                    // No close tag — emit all as thinking
+                    results.push({ type: "thinking", text: input });
+                    break;
+                }
+            }
+            else {
+                const openIdx = input.indexOf(OPEN_TAG);
+                if (openIdx !== -1) {
+                    // Found open tag — emit text before it
+                    const text = input.slice(0, openIdx);
+                    if (text)
+                        results.push({ type: "text", text });
+                    this.inThinking = true;
+                    input = input.slice(openIdx + OPEN_TAG.length);
+                }
+                else if (this.couldBePartialTag(input, OPEN_TAG)) {
+                    // Possible partial open tag at end — buffer only the matching tail
+                    const tailLen = this.getPartialTagTailLength(input, OPEN_TAG);
+                    const safe = input.slice(0, input.length - tailLen);
+                    if (safe)
+                        results.push({ type: "text", text: safe });
+                    this.buffer = input.slice(-tailLen);
+                    break;
+                }
+                else {
+                    // No open tag — emit all as text
+                    results.push({ type: "text", text: input });
+                    break;
+                }
+            }
+        }
+        return results;
+    }
+    /**
+     * Flush any remaining buffered content. Call at end of stream.
+     */
+    flush() {
+        if (!this.buffer)
+            return [];
+        const result = {
+            type: this.inThinking ? "thinking" : "text",
+            text: this.buffer,
+        };
+        this.buffer = "";
+        return [result];
+    }
+    /**
+     * Check if the end of input could be the start of a partial tag.
+     * Only buffers when the tail of input matches a prefix of the tag.
+     */
+    couldBePartialTag(input, tag) {
+        return this.getPartialTagTailLength(input, tag) > 0;
+    }
+    /**
+     * Get the length of the tail of input that matches a prefix of the tag.
+     * Returns 0 if no partial match.
+     */
+    getPartialTagTailLength(input, tag) {
+        const maxCheck = Math.min(input.length, tag.length - 1);
+        for (let len = maxCheck; len >= 1; len--) {
+            const tail = input.slice(-len);
+            if (tag.startsWith(tail)) {
+                return len;
+            }
+        }
+        return 0;
+    }
+}

package/dist/update-cmd.js

@@ -10,18 +10,20 @@ export async function runUpdate() {
     const reset = '\x1b[0m';
     process.stdout.write(`${dim}Current version:${reset} v${current}\n`);
     process.stdout.write(`${dim}Checking npm registry...${reset}\n`);
-    // Fetch latest version
+    // Fetch latest version — bypass npm client cache to avoid stale results (#3445)
     let latest;
     try {
-        latest = execSync(`npm view ${NPM_PACKAGE} version`, {
+        latest = execSync(`npm view ${NPM_PACKAGE} version --fetch-retry-mintimeout=3000`, {
             encoding: 'utf-8',
             stdio: ['ignore', 'pipe', 'ignore'],
+            env: { ...process.env, npm_config_cache: '' },
         }).trim();
     }
     catch {
         process.stderr.write(`${yellow}Failed to reach npm registry.${reset}\n`);
         process.exit(1);
     }
+    process.stdout.write(`${dim}Latest version:${reset}  v${latest}\n`);
     if (compareSemver(latest, current) <= 0) {
         process.stdout.write(`${green}Already up to date.${reset}\n`);
         return;

package/dist/web/standalone/.next/BUILD_ID

@@ -1 +1 @@
-TTlAguZQ5vR9EOv6G8cel
+SDB1T-4NqkMjYirjjqQhr