gsd-pi 2.63.0 → 2.64.0

package/src/resources/extensions/ollama/tests/ollama-chat-provider-stream.test.ts

@@ -0,0 +1,82 @@
+// GSD2 — Regression test: Ollama streaming must not drop content on done:true chunks (#3576)
+// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+/**
+ * This test validates the streaming logic pattern used in ollama-chat-provider.ts.
+ * The bug: content on the terminal done:true chunk was silently dropped because
+ * the stream loop only emitted content when `!chunk.done`.
+ *
+ * The fix: process chunk.message.content regardless of chunk.done, then handle
+ * done metadata. This test exercises that logic path with a simulated chunk stream.
+ */
+
+interface OllamaChunk {
+  done: boolean;
+  done_reason?: string;
+  message?: { content?: string; tool_calls?: unknown[] };
+  prompt_eval_count?: number;
+  eval_count?: number;
+}
+
+function simulateStreamLoop(chunks: OllamaChunk[]): string {
+  let output = "";
+
+  for (const chunk of chunks) {
+    // This mirrors the fixed logic in ollama-chat-provider.ts
+    const content = chunk.message?.content ?? "";
+    if (content) {
+      output += content;
+    }
+
+    if (chunk.done) {
+      break;
+    }
+  }
+
+  return output;
+}
+
+describe("Ollama stream terminal chunk handling", () => {
+  it("captures content from done:true chunk", () => {
+    const chunks: OllamaChunk[] = [
+      { done: false, message: { content: "Hello " } },
+      { done: false, message: { content: "world" } },
+      { done: true, done_reason: "stop", message: { content: "!" } },
+    ];
+
+    const result = simulateStreamLoop(chunks);
+    assert.equal(result, "Hello world!", "trailing content on done chunk must not be dropped");
+  });
+
+  it("works when done chunk has no content", () => {
+    const chunks: OllamaChunk[] = [
+      { done: false, message: { content: "Hello" } },
+      { done: true, done_reason: "stop", message: {} },
+    ];
+
+    const result = simulateStreamLoop(chunks);
+    assert.equal(result, "Hello");
+  });
+
+  it("works when done chunk has empty string content", () => {
+    const chunks: OllamaChunk[] = [
+      { done: false, message: { content: "data" } },
+      { done: true, done_reason: "stop", message: { content: "" } },
+    ];
+
+    const result = simulateStreamLoop(chunks);
+    assert.equal(result, "data");
+  });
+
+  it("handles single done chunk with content", () => {
+    const chunks: OllamaChunk[] = [
+      { done: true, done_reason: "stop", message: { content: "one-shot" } },
+    ];
+
+    const result = simulateStreamLoop(chunks);
+    assert.equal(result, "one-shot", "single done chunk with content should work");
+  });
+});

package/src/resources/extensions/ollama/tests/ollama-discovery.test.ts

@@ -1,28 +1 @@
 // GSD2 — Tests for Ollama model discovery and enrichment
-import { describe, it, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import { getOllamaOpenAIBaseUrl } from "../ollama-discovery.js";
-
-// ─── getOllamaOpenAIBaseUrl ─────────────────────────────────────────────────
-
-describe("getOllamaOpenAIBaseUrl", () => {
-	const originalHost = process.env.OLLAMA_HOST;
-
-	afterEach(() => {
-		if (originalHost === undefined) {
-			delete process.env.OLLAMA_HOST;
-		} else {
-			process.env.OLLAMA_HOST = originalHost;
-		}
-	});
-
-	it("returns default OpenAI-compat URL", () => {
-		delete process.env.OLLAMA_HOST;
-		assert.equal(getOllamaOpenAIBaseUrl(), "http://localhost:11434/v1");
-	});
-
-	it("appends /v1 to custom OLLAMA_HOST", () => {
-		process.env.OLLAMA_HOST = "http://remote:9999";
-		assert.equal(getOllamaOpenAIBaseUrl(), "http://remote:9999/v1");
-	});
-});

package/src/resources/extensions/ollama/thinking-parser.ts

@@ -0,0 +1,116 @@
+// GSD2 — Ollama Extension: Stateful <think> tag stream parser
+
+/**
+ * Extracts <think>...</think> thinking blocks from a streaming text response.
+ * Handles the case where tag boundaries span multiple chunks by buffering
+ * up to 8 characters (length of "</think>") at chunk boundaries.
+ *
+ * Used for reasoning models like deepseek-r1 and qwq that embed thinking
+ * inline in their text output.
+ */
+
+export type ParsedChunk =
+	| { type: "thinking"; text: string }
+	| { type: "text"; text: string };
+
+const OPEN_TAG = "<think>";
+const CLOSE_TAG = "</think>";
+const MAX_TAG_LEN = Math.max(OPEN_TAG.length, CLOSE_TAG.length);
+
+export class ThinkingTagParser {
+	private buffer = "";
+	private inThinking = false;
+
+	/**
+	 * Feed a chunk of text and get back parsed segments.
+	 * May return zero or more segments depending on tag boundaries.
+	 */
+	push(chunk: string): ParsedChunk[] {
+		const results: ParsedChunk[] = [];
+		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(): ParsedChunk[] {
+		if (!this.buffer) return [];
+
+		const result: ParsedChunk = {
+			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.
+	 */
+	private couldBePartialTag(input: string, tag: string): boolean {
+		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.
+	 */
+	private getPartialTagTailLength(input: string, tag: string): number {
+		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/src/resources/extensions/ollama/types.ts

@@ -72,11 +72,31 @@ export interface OllamaVersionResponse {
 
 // ─── /api/chat ──────────────────────────────────────────────────────────────
 
+/** Per-model Ollama inference options carried via Model.providerOptions. */
+export interface OllamaChatOptions {
+	/** How long to keep the model loaded after the last request. e.g. "5m", "0" to unload. */
+	keep_alive?: string;
+	/** Number of GPU layers to offload. -1 = all. */
+	num_gpu?: number;
+	/** Override the context window for Ollama requests. Only sent when explicitly set. */
+	num_ctx?: number;
+	/** Sampling: top-k most likely tokens. Default: 40 */
+	top_k?: number;
+	/** Sampling: nucleus sampling threshold. */
+	top_p?: number;
+	/** Sampling: penalize repeating tokens. Default: 1.1 */
+	repeat_penalty?: number;
+	/** Sampling: fixed seed for reproducibility. */
+	seed?: number;
+}
+
 export interface OllamaChatMessage {
 	role: "system" | "user" | "assistant" | "tool";
 	content: string;
 	images?: string[];
 	tool_calls?: OllamaToolCall[];
+	/** Tool name — required for role: "tool" messages to correlate results with calls. */
+	name?: string;
 }
 
 export interface OllamaToolCall {
@@ -110,7 +130,10 @@ export interface OllamaChatRequest {
 		temperature?: number;
 		top_p?: number;
 		top_k?: number;
+		repeat_penalty?: number;
+		seed?: number;
 		stop?: string[];
+		num_gpu?: number;
 	};
 	keep_alive?: string;
 }