gsd-pi 2.58.0 → 2.59.0-dev.023bd39

package/src/resources/extensions/mcp-client/tests/server-name-spaces.test.ts

@@ -0,0 +1,55 @@
+/**
+ * Regression test for #3029 — mcp_discover fails for server names with spaces.
+ *
+ * The getServerConfig lookup must handle:
+ *   1. Exact match (already works)
+ *   2. Names with leading/trailing whitespace (trimming)
+ *   3. Case-insensitive matching (e.g. "Langgraph code" vs "langgraph Code")
+ *
+ * We test at the source level since getServerConfig is not exported.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const source = readFileSync(join(__dirname, "..", "index.ts"), "utf-8");
+
+test("#3029: getServerConfig trims whitespace from input name", () => {
+	assert.ok(
+		source.includes(".trim()"),
+		"getServerConfig should trim the input name before comparison",
+	);
+});
+
+test("#3029: getServerConfig performs case-insensitive matching", () => {
+	assert.ok(
+		source.includes(".toLowerCase()"),
+		"getServerConfig should compare names case-insensitively",
+	);
+});
+
+test("#3029: getOrConnect normalizes name for connection cache lookup", () => {
+	// The connections Map key must use the canonical (config) name, not the
+	// raw user input, so that subsequent lookups hit the cache even when the
+	// user's casing differs.
+	const getOrConnectMatch = source.match(
+		/async function getOrConnect\(name: string[\s\S]*?const existing = connections\.get\(/,
+	);
+	assert.ok(
+		getOrConnectMatch,
+		"getOrConnect function should exist",
+	);
+	// After the fix, getOrConnect should normalize the name via getServerConfig
+	// or use config.name as the canonical cache key.
+	assert.ok(
+		source.includes("connections.get(config.name") ||
+		source.includes("connections.set(config.name"),
+		"getOrConnect should use config.name (canonical) as the connections cache key",
+	);
+});

package/src/resources/extensions/ollama/index.ts

@@ -0,0 +1,130 @@
+// GSD2 — Ollama Extension: First-class local LLM support
+/**
+ * Ollama Extension
+ *
+ * Auto-detects a running Ollama instance, discovers locally pulled models,
+ * and registers them as a first-class provider. No configuration required —
+ * if Ollama is running, models appear automatically.
+ *
+ * Features:
+ * - Auto-discovery of local models via /api/tags
+ * - Capability detection (vision, reasoning, context window)
+ * - /ollama slash commands for model management
+ * - ollama_manage tool for LLM-driven model operations
+ * - Zero-cost model registration (local inference)
+ *
+ * Respects OLLAMA_HOST env var for non-default endpoints.
+ */
+
+import { importExtensionModule, type ExtensionAPI } from "@gsd/pi-coding-agent";
+import type { OpenAICompletionsCompat } from "@gsd/pi-ai";
+import * as client from "./ollama-client.js";
+import { discoverModels, getOllamaOpenAIBaseUrl } from "./ollama-discovery.js";
+import { registerOllamaCommands } from "./ollama-commands.js";
+
+/** Default compat settings for Ollama models via OpenAI-compat endpoint */
+const OLLAMA_COMPAT: OpenAICompletionsCompat = {
+	supportsDeveloperRole: false,
+	supportsReasoningEffort: false,
+	supportsUsageInStreaming: false,
+	maxTokensField: "max_tokens",
+	supportsStore: false,
+};
+
+let toolsPromise: Promise<void> | null = null;
+
+async function registerOllamaTools(pi: ExtensionAPI): Promise<void> {
+	if (!toolsPromise) {
+		toolsPromise = (async () => {
+			const { registerOllamaTool } = await importExtensionModule<
+				typeof import("./ollama-tool.js")
+			>(import.meta.url, "./ollama-tool.js");
+			registerOllamaTool(pi);
+		})().catch((error) => {
+			toolsPromise = null;
+			throw error;
+		});
+	}
+	return toolsPromise;
+}
+
+/** Track whether we've registered models so we can clean up on shutdown */
+let providerRegistered = false;
+
+/**
+ * Probe Ollama and register discovered models.
+ * Safe to call multiple times — re-discovers and re-registers.
+ */
+async function probeAndRegister(pi: ExtensionAPI): Promise<boolean> {
+	const running = await client.isRunning();
+	if (!running) {
+		if (providerRegistered) {
+			pi.unregisterProvider("ollama");
+			providerRegistered = false;
+		}
+		return false;
+	}
+
+	const models = await discoverModels();
+	if (models.length === 0) return true; // Running but no models pulled
+
+	const baseUrl = getOllamaOpenAIBaseUrl();
+
+	pi.registerProvider("ollama", {
+		authMode: "none",
+		baseUrl,
+		api: "openai-completions",
+		isReady: () => true,
+		models: models.map((m) => ({
+			id: m.id,
+			name: m.name,
+			reasoning: m.reasoning,
+			input: m.input,
+			cost: m.cost,
+			contextWindow: m.contextWindow,
+			maxTokens: m.maxTokens,
+			compat: OLLAMA_COMPAT,
+		})),
+	});
+
+	providerRegistered = true;
+	return true;
+}
+
+export default function ollama(pi: ExtensionAPI) {
+	// Register slash commands immediately (they check Ollama availability themselves)
+	registerOllamaCommands(pi);
+
+	pi.on("session_start", async (_event, ctx) => {
+		// Register tool (deferred to avoid blocking startup)
+		if (ctx.hasUI) {
+			void registerOllamaTools(pi).catch((error) => {
+				ctx.ui.notify(
+					`Ollama tool failed to load: ${error instanceof Error ? error.message : String(error)}`,
+					"warning",
+				);
+			});
+		} else {
+			await registerOllamaTools(pi);
+		}
+
+		// Async probe — don't block startup
+		probeAndRegister(pi)
+			.then((found) => {
+				if (found && ctx.hasUI) {
+					ctx.ui.setStatus("ollama", "Ollama");
+				}
+			})
+			.catch(() => {
+				// Silently ignore probe failures
+			});
+	});
+
+	pi.on("session_shutdown", async () => {
+		if (providerRegistered) {
+			pi.unregisterProvider("ollama");
+			providerRegistered = false;
+		}
+		toolsPromise = null;
+	});
+}

package/src/resources/extensions/ollama/model-capabilities.ts

@@ -0,0 +1,145 @@
+// GSD2 — Known model capability table for Ollama models
+
+/**
+ * Maps well-known Ollama model families to their capabilities.
+ * Used to enrich auto-discovered models with accurate context windows,
+ * vision support, and reasoning detection.
+ *
+ * Fallback: estimate from parameter count if model isn't in the table.
+ */
+
+export interface ModelCapability {
+	contextWindow?: number;
+	maxTokens?: number;
+	input?: ("text" | "image")[];
+	reasoning?: boolean;
+}
+
+/**
+ * Known model family capabilities.
+ * Keys are matched as prefixes against the model name (before the colon/tag).
+ * More specific entries should appear first.
+ */
+const KNOWN_MODELS: Array<[pattern: string, caps: ModelCapability]> = [
+	// ─── Reasoning models ───────────────────────────────────────────────
+	["deepseek-r1", { contextWindow: 131072, reasoning: true }],
+	["qwq", { contextWindow: 131072, reasoning: true }],
+
+	// ─── 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"] }],
+
+	// ─── 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 }],
+
+	// ─── 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 }],
+
+	// ─── Qwen family ────────────────────────────────────────────────────
+	["qwen3", { contextWindow: 131072, maxTokens: 32768 }],
+	["qwen2.5", { contextWindow: 131072, maxTokens: 32768 }],
+	["qwen2", { contextWindow: 131072, maxTokens: 32768 }],
+
+	// ─── Gemma family ───────────────────────────────────────────────────
+	["gemma3", { contextWindow: 131072, maxTokens: 16384 }],
+	["gemma2", { contextWindow: 8192, maxTokens: 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 }],
+
+	// ─── Phi family ─────────────────────────────────────────────────────
+	["phi4", { contextWindow: 16384, maxTokens: 16384 }],
+	["phi3.5", { contextWindow: 131072, maxTokens: 16384 }],
+	["phi3", { contextWindow: 131072, maxTokens: 4096 }],
+
+	// ─── Command R ──────────────────────────────────────────────────────
+	["command-r-plus", { contextWindow: 131072, maxTokens: 16384 }],
+	["command-r", { contextWindow: 131072, maxTokens: 16384 }],
+];
+
+/**
+ * Look up capabilities for a model by name.
+ * Matches the longest prefix from the known models table.
+ */
+export function getModelCapabilities(modelName: string): ModelCapability {
+	// Strip tag (everything after the colon) for matching
+	const baseName = modelName.split(":")[0].toLowerCase();
+
+	for (const [pattern, caps] of KNOWN_MODELS) {
+		if (baseName === pattern || baseName.startsWith(pattern)) {
+			return caps;
+		}
+	}
+
+	return {};
+}
+
+/**
+ * Estimate context window from parameter size string (e.g. "7B", "70B", "1.5B").
+ * Used as fallback when model isn't in the known table.
+ */
+export function estimateContextFromParams(parameterSize: string): number {
+	const match = parameterSize.match(/([\d.]+)\s*([BbMm])/);
+	if (!match) return 8192;
+
+	const size = parseFloat(match[1]);
+	const unit = match[2].toUpperCase();
+
+	// Convert to billions
+	const billions = unit === "M" ? size / 1000 : size;
+
+	// Rough heuristics: larger models tend to support larger contexts
+	if (billions >= 70) return 131072;
+	if (billions >= 30) return 65536;
+	if (billions >= 13) return 32768;
+	if (billions >= 7) return 16384;
+	return 8192;
+}
+
+/**
+ * Humanize a model name for display (e.g. "llama3.1:8b" → "Llama 3.1 8B").
+ */
+export function humanizeModelName(modelName: string): string {
+	const [base, tag] = modelName.split(":");
+
+	// Capitalize first letter, add spaces around version numbers
+	let name = base
+		.replace(/([a-z])(\d)/g, "$1 $2")
+		.replace(/(\d)([a-z])/g, "$1 $2")
+		.replace(/^./, (c) => c.toUpperCase());
+
+	// Clean up common patterns
+	name = name.replace(/\s*-\s*/g, " ");
+
+	if (tag && tag !== "latest") {
+		name += ` ${tag.toUpperCase()}`;
+	}
+
+	return name;
+}
+
+/**
+ * Format byte size for display (e.g. 4700000000 → "4.7 GB").
+ */
+export function formatModelSize(bytes: number): string {
+	if (bytes >= 1e9) return `${(bytes / 1e9).toFixed(1)} GB`;
+	if (bytes >= 1e6) return `${(bytes / 1e6).toFixed(1)} MB`;
+	return `${(bytes / 1e3).toFixed(0)} KB`;
+}

package/src/resources/extensions/ollama/ollama-client.ts

@@ -0,0 +1,196 @@
+// GSD2 — HTTP client for Ollama REST API
+
+/**
+ * Low-level HTTP client for the Ollama REST API.
+ * Respects the OLLAMA_HOST environment variable for non-default endpoints.
+ *
+ * Reference: https://github.com/ollama/ollama/blob/main/docs/api.md
+ */
+
+import type {
+	OllamaPsResponse,
+	OllamaPullProgress,
+	OllamaShowResponse,
+	OllamaTagsResponse,
+	OllamaVersionResponse,
+} from "./types.js";
+
+const DEFAULT_HOST = "http://localhost:11434";
+const PROBE_TIMEOUT_MS = 1500;
+const REQUEST_TIMEOUT_MS = 10000;
+
+/**
+ * Get the Ollama host URL from OLLAMA_HOST or default.
+ */
+export function getOllamaHost(): string {
+	const host = process.env.OLLAMA_HOST;
+	if (!host) return DEFAULT_HOST;
+
+	// OLLAMA_HOST can be just a host:port without scheme
+	if (host.startsWith("http://") || host.startsWith("https://")) return host;
+	return `http://${host}`;
+}
+
+async function fetchWithTimeout(url: string, options: RequestInit = {}, timeoutMs = REQUEST_TIMEOUT_MS): Promise<Response> {
+	const controller = new AbortController();
+	const timeout = setTimeout(() => controller.abort(), timeoutMs);
+	try {
+		return await fetch(url, { ...options, signal: controller.signal });
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+
+/**
+ * Check if Ollama is running and reachable.
+ */
+export async function isRunning(): Promise<boolean> {
+	try {
+		const response = await fetchWithTimeout(`${getOllamaHost()}/`, {}, PROBE_TIMEOUT_MS);
+		return response.ok;
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Get Ollama version.
+ */
+export async function getVersion(): Promise<string | null> {
+	try {
+		const response = await fetchWithTimeout(`${getOllamaHost()}/api/version`);
+		if (!response.ok) return null;
+		const data = (await response.json()) as OllamaVersionResponse;
+		return data.version;
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * List all locally available models.
+ */
+export async function listModels(): Promise<OllamaTagsResponse> {
+	const response = await fetchWithTimeout(`${getOllamaHost()}/api/tags`);
+	if (!response.ok) {
+		throw new Error(`Ollama /api/tags returned ${response.status}: ${response.statusText}`);
+	}
+	return (await response.json()) as OllamaTagsResponse;
+}
+
+/**
+ * Get detailed information about a specific model.
+ */
+export async function showModel(name: string): Promise<OllamaShowResponse> {
+	const response = await fetchWithTimeout(`${getOllamaHost()}/api/show`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ name }),
+	});
+	if (!response.ok) {
+		throw new Error(`Ollama /api/show returned ${response.status}: ${response.statusText}`);
+	}
+	return (await response.json()) as OllamaShowResponse;
+}
+
+/**
+ * List currently loaded/running models.
+ */
+export async function getRunningModels(): Promise<OllamaPsResponse> {
+	const response = await fetchWithTimeout(`${getOllamaHost()}/api/ps`);
+	if (!response.ok) {
+		throw new Error(`Ollama /api/ps returned ${response.status}: ${response.statusText}`);
+	}
+	return (await response.json()) as OllamaPsResponse;
+}
+
+/**
+ * Pull a model with streaming progress.
+ * Calls onProgress for each progress update.
+ * Returns when the pull is complete.
+ */
+export async function pullModel(
+	name: string,
+	onProgress?: (progress: OllamaPullProgress) => void,
+	signal?: AbortSignal,
+): Promise<void> {
+	const response = await fetch(`${getOllamaHost()}/api/pull`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ name, stream: true }),
+		signal,
+	});
+
+	if (!response.ok) {
+		const text = await response.text();
+		throw new Error(`Ollama /api/pull returned ${response.status}: ${text}`);
+	}
+
+	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) as OllamaPullProgress;
+				onProgress?.(progress);
+			} catch {
+				// Skip malformed lines
+			}
+		}
+	}
+
+	// Process remaining buffer
+	if (buffer.trim()) {
+		try {
+			const progress = JSON.parse(buffer.trim()) as OllamaPullProgress;
+			onProgress?.(progress);
+		} catch {
+			// Ignore
+		}
+	}
+}
+
+/**
+ * Delete a local model.
+ */
+export async function deleteModel(name: string): Promise<void> {
+	const response = await fetchWithTimeout(`${getOllamaHost()}/api/delete`, {
+		method: "DELETE",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ name }),
+	});
+	if (!response.ok) {
+		const text = await response.text();
+		throw new Error(`Ollama /api/delete returned ${response.status}: ${text}`);
+	}
+}
+
+/**
+ * Copy a model to a new name.
+ */
+export async function copyModel(source: string, destination: string): Promise<void> {
+	const response = await fetchWithTimeout(`${getOllamaHost()}/api/copy`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ source, destination }),
+	});
+	if (!response.ok) {
+		const text = await response.text();
+		throw new Error(`Ollama /api/copy returned ${response.status}: ${text}`);
+	}
+}