dsh-local-ai 0.1.0

package/lib/index.js

@@ -0,0 +1,1334 @@
+import { defineTool } from "@deepseek-ai/dsh-tools";
+import z from "@deepseek-ai/schemastery";
+import { CallId, EMPTY_RESPONSE_CODE, LlmAdapter, LlmError, attributionHeaders, contentHasImage, isTokenDelta } from "@deepseek-ai/dsh-llm";
+import { idleWatchdog, timeoutOf } from "@deepseek-ai/dsh-timeout";
+import { tmpdir } from "node:os";
+//#region src/config.ts
+/**
+* Config schema and resolution for `dsh-local-ai`. Every tunable is a
+* validated {@link Config} field changeable from cordis.yml; the resolution
+* step validates URLs, numeric bounds, and route/model entries so
+* misconfiguration fails loud at mount — never silently skips a rule or
+* half-configures the adapter. The plugin is inert until at least one route
+* rule exists or a caller selects the `ollama` provider explicitly: routing
+* every request to a local model requires an explicit opt-in (privacy and
+* cost default: no automatic re-routing).
+* @module dsh-local-ai/config
+*/
+/** Schemastery schema: the loader validates and fills defaults before `apply`. */
+const Config = z.object({
+	baseURL: z.string().default("http://127.0.0.1:11434"),
+	requestTimeoutMs: z.number().default(3e4),
+	graceMs: z.number().default(15e3),
+	defaultContextWindow: z.number().default(8192),
+	maxTokens: z.number().default(4096),
+	temperature: z.number(),
+	models: z.array(z.object({
+		name: z.string().required(),
+		model: z.string(),
+		contextWindow: z.number(),
+		maxTokens: z.number(),
+		temperature: z.number()
+	})).default([]),
+	route: z.array(z.object({
+		model: z.string().required(),
+		purpose: z.union(["compaction", "session-title"]),
+		keywords: z.array(z.string()).default([]),
+		always: z.boolean().default(false)
+	})).default([])
+});
+/** Throw unless `value` is a positive safe integer. */
+function assertPositiveInt(name, value) {
+	if (!Number.isSafeInteger(value) || value <= 0) throw new TypeError(`${name} must be a positive safe integer, got ${String(value)}`);
+}
+/** Throw unless `value` is a finite number in `[min, max]`. */
+function assertFiniteRange(name, value, min, max) {
+	if (typeof value !== "number" || !Number.isFinite(value) || value < min || value > max) throw new TypeError(`${name} must be a finite number in [${min}, ${max}], got ${String(value)}`);
+}
+/**
+* Validate an http(s) URL string and normalize it to a clean base (no query,
+* no fragment, no trailing slash).
+* @param name - config key, for the error message.
+* @param value - raw URL value.
+* @returns the normalized base URL.
+*/
+function normalizeBaseUrl(name, value) {
+	let parsed;
+	try {
+		parsed = new URL(value);
+	} catch (error) {
+		throw new TypeError(`${name} must be a valid URL, got ${JSON.stringify(value)} (${error instanceof Error ? error.message : "invalid URL"})`);
+	}
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") throw new TypeError(`${name} must use http(s), got ${JSON.stringify(parsed.protocol)}`);
+	parsed.search = "";
+	parsed.hash = "";
+	return parsed.href.replace(/\/+$/u, "");
+}
+/**
+* Validate raw values and fill explicit defaults. Invalid URLs, numeric
+* bounds, duplicate model names, or empty route/model names throw here —
+* misconfiguration fails loud at mount even when the plugin is mounted
+* without the Schemastery loader.
+* @param config - raw (possibly partial) plugin config.
+* @returns the fully resolved config.
+*/
+function resolveConfig(config = {}) {
+	const baseURL = normalizeBaseUrl("baseURL", config.baseURL ?? "http://127.0.0.1:11434");
+	const requestTimeoutMs = config.requestTimeoutMs ?? 3e4;
+	assertPositiveInt("requestTimeoutMs", requestTimeoutMs);
+	const graceMs = config.graceMs ?? 15e3;
+	assertPositiveInt("graceMs", graceMs);
+	const defaultContextWindow = config.defaultContextWindow ?? 8192;
+	assertPositiveInt("defaultContextWindow", defaultContextWindow);
+	const maxTokens = config.maxTokens ?? 4096;
+	assertPositiveInt("maxTokens", maxTokens);
+	const temperature = config.temperature;
+	if (temperature !== void 0) assertFiniteRange("temperature", temperature, 0, 2);
+	const seenNames = /* @__PURE__ */ new Set();
+	const models = (config.models ?? []).map((mapping, index) => {
+		if (typeof mapping.name !== "string" || mapping.name.trim().length === 0) throw new TypeError(`models[${index}].name must be a non-empty string`);
+		const name = mapping.name.trim();
+		if (seenNames.has(name)) throw new TypeError(`models[${index}]: duplicate model name ${JSON.stringify(name)}`);
+		seenNames.add(name);
+		const model = (mapping.model ?? name).trim();
+		if (model.length === 0) throw new TypeError(`models[${index}].model must be a non-empty string`);
+		const contextWindow = mapping.contextWindow;
+		if (contextWindow !== void 0) assertPositiveInt(`models[${index}].contextWindow`, contextWindow);
+		const modelMaxTokens = mapping.maxTokens;
+		if (modelMaxTokens !== void 0) assertPositiveInt(`models[${index}].maxTokens`, modelMaxTokens);
+		const modelTemperature = mapping.temperature;
+		if (modelTemperature !== void 0) assertFiniteRange(`models[${index}].temperature`, modelTemperature, 0, 2);
+		return {
+			name,
+			model,
+			...contextWindow === void 0 ? {} : { contextWindow },
+			...modelMaxTokens === void 0 ? {} : { maxTokens: modelMaxTokens },
+			...modelTemperature === void 0 ? {} : { temperature: modelTemperature }
+		};
+	});
+	const route = (config.route ?? []).map((rule, index) => {
+		if (typeof rule.model !== "string" || rule.model.trim().length === 0) throw new TypeError(`route[${index}].model must be a non-empty string`);
+		const keywords = (rule.keywords ?? []).map((keyword, keywordIndex) => {
+			if (typeof keyword !== "string" || keyword.trim().length === 0) throw new TypeError(`route[${index}].keywords[${keywordIndex}] must be a non-empty string`);
+			return keyword;
+		});
+		if (rule.always !== true && rule.purpose === void 0 && keywords.length === 0) throw new TypeError(`route[${index}] must declare a purpose, at least one keyword, or always: true`);
+		return {
+			model: rule.model.trim(),
+			...rule.purpose === void 0 ? {} : { purpose: rule.purpose },
+			keywords,
+			always: rule.always ?? false
+		};
+	});
+	return {
+		baseURL,
+		requestTimeoutMs,
+		graceMs,
+		defaultContextWindow,
+		maxTokens,
+		...temperature === void 0 ? {} : { temperature },
+		models,
+		route
+	};
+}
+//#endregion
+//#region src/sanitize.ts
+/**
+* Display/log sanitization for `dsh-local-ai`. Every value shown to the model
+* or to the user (tool results, the `/ollama` command, error messages) passes
+* through one of these pure functions first, so an endpoint address or a local
+* path can never leak credentials, secret query parameters, or unbounded text.
+*
+* All functions are pure: they depend only on their arguments, never on
+* process state (the caller supplies a home directory for path redaction).
+* @module dsh-local-ai/sanitize
+*/
+/** Placeholder substituted for a redacted secret or credential. */
+const REDACTED = "[REDACTED]";
+/** Control characters (C0 + DEL) stripped from every sanitized value. */
+const CONTROL_CHARS = /[\u0000-\u001f\u007f]/gu;
+/** Secret-shaped query-parameter keys removed from endpoint URLs. */
+const SECRET_KEY_PATTERN = /key|token|secret|password|credential|auth/iu;
+/** Built-in secret literal patterns redacted from arbitrary text. */
+const BUILTIN_SECRET_PATTERNS = [
+	/\bsk-[A-Za-z0-9]{16,}\b/u,
+	/\bghp_[A-Za-z0-9]{20,}\b/u,
+	/\bgho_[A-Za-z0-9]{20,}\b/u,
+	/\bAKIA[0-9A-Z]{16}\b/u,
+	/\bBearer\s+[A-Za-z0-9._~+/=-]{8,}\b/u,
+	/-----BEGIN [A-Z ]*PRIVATE KEY-----[A-Za-z0-9+/=\s]*-----END [A-Z ]*PRIVATE KEY-----/u
+];
+/** Remove C0/DEL control characters from a string. */
+function stripControl(value) {
+	return value.replace(CONTROL_CHARS, "");
+}
+/**
+* Truncate a string to `maxChars`, appending an ellipsis when it was cut.
+* A non-positive `maxChars` yields the empty string.
+* @param value - the string to bound.
+* @param maxChars - maximum returned length, including the ellipsis.
+* @returns the bounded string.
+*/
+function truncate(value, maxChars) {
+	if (value.length <= maxChars) return value;
+	if (maxChars <= 1) return maxChars <= 0 ? "" : "…";
+	return `${value.slice(0, maxChars - 1)}…`;
+}
+/**
+* Sanitize an endpoint address for display: strip the URL userinfo
+* (`user:pass@`), drop query parameters whose key looks like a secret, strip
+* control characters, and bound the length. Values that are not parseable as
+* a URL are still stripped and truncated.
+* @param value - the raw endpoint (URL string or anything stringifiable).
+* @param maxChars - maximum returned length.
+* @returns the sanitized endpoint text.
+*/
+function sanitizeEndpoint(value, maxChars = 2048) {
+	const text = stripControl(typeof value === "string" ? value : String(value));
+	let out;
+	try {
+		const url = new URL(text);
+		url.username = "";
+		url.password = "";
+		for (const key of [...url.searchParams.keys()]) if (SECRET_KEY_PATTERN.test(key)) url.searchParams.delete(key);
+		out = url.href;
+	} catch {
+		out = text;
+	}
+	return truncate(out, maxChars);
+}
+/**
+* Sanitize a local path for display: strip control characters, redact a
+* leading home directory to `~`, and bound the length.
+* @param value - the raw path (string or anything stringifiable).
+* @param home - the user's home directory to redact; omit to skip redaction.
+* @param maxChars - maximum returned length.
+* @returns the sanitized path text.
+*/
+function sanitizePath(value, home = "", maxChars = 1024) {
+	const text = stripControl(typeof value === "string" ? value : String(value));
+	return truncate(home.length > 0 && text.startsWith(home) ? `~${text.slice(home.length)}` : text, maxChars);
+}
+/**
+* Redact built-in secret literals (API keys, GitHub tokens, AWS keys, bearer
+* credentials, PEM private keys) from arbitrary text. Control characters are
+* stripped first.
+* @param value - the raw text (string or anything stringifiable).
+* @returns the text with secret literals replaced by {@link REDACTED}.
+*/
+function redactSecrets(value) {
+	let out = stripControl(typeof value === "string" ? value : String(value));
+	for (const pattern of BUILTIN_SECRET_PATTERNS) out = out.replace(pattern, REDACTED);
+	return out;
+}
+/**
+* Sanitize arbitrary display text: redact secrets, strip control characters,
+* and bound the length.
+* @param value - the raw text (string or anything stringifiable).
+* @param maxChars - maximum returned length.
+* @returns the sanitized text.
+*/
+function sanitizeText(value, maxChars = 4e3) {
+	return truncate(redactSecrets(value), maxChars);
+}
+//#endregion
+//#region src/ollama.ts
+/**
+* Ollama HTTP API client (zero runtime dependencies — plain `fetch`). The
+* harness `LlmAdapter` streams through `/api/chat`; discovery and management
+* tools call `/api/tags`, `/api/show`, `/api/pull`, `/api/delete`, and
+* `/api/version`. Every request carries the harness attribution headers and
+* honors the caller's abort signal; non-2xx responses fail with a normalized
+* `LlmError`. The fetch implementation is injectable for tests.
+* @module dsh-local-ai/ollama
+*/
+/** Build an absolute API URL from a normalized base URL. */
+function endpointUrl(baseURL, path) {
+	return `${baseURL}${path}`;
+}
+/** Map an HTTP status to a stable LlmError code. */
+function httpErrorCode(status) {
+	if (status === 404) return "NOT_FOUND";
+	if (status === 400) return "INVALID_REQUEST";
+	if (status >= 500) return "SERVER";
+	return `HTTP_${status}`;
+}
+/** Throw a normalized LlmError from a non-2xx response, using the body's `error`. */
+async function throwHttpError(response, context) {
+	let message = `Ollama API error (HTTP ${response.status}) from ${sanitizeEndpoint(context)}`;
+	try {
+		const body = await response.json();
+		if (typeof body.error === "string" && body.error.length > 0) message = body.error;
+	} catch {}
+	throw new LlmError(message, httpErrorCode(response.status), { status: response.status });
+}
+/** Send a GET request and parse the JSON response. */
+async function requestJson(baseURL, path, fetchImpl, signal) {
+	const response = await fetchImpl(endpointUrl(baseURL, path), {
+		method: "GET",
+		headers: {
+			accept: "application/json",
+			...attributionHeaders()
+		},
+		...signal === void 0 ? {} : { signal }
+	});
+	if (!response.ok) await throwHttpError(response, endpointUrl(baseURL, path));
+	return response.json();
+}
+/** Send a POST request and parse the JSON response. */
+async function postJson(baseURL, path, body, fetchImpl, signal) {
+	const response = await fetchImpl(endpointUrl(baseURL, path), {
+		method: "POST",
+		headers: {
+			"content-type": "application/json",
+			accept: "application/json",
+			...attributionHeaders()
+		},
+		body: JSON.stringify(body),
+		...signal === void 0 ? {} : { signal }
+	});
+	if (!response.ok) await throwHttpError(response, endpointUrl(baseURL, path));
+	return response.json();
+}
+/** Send a DELETE request and parse the JSON response. */
+async function deleteJson(baseURL, path, body, fetchImpl, signal) {
+	const response = await fetchImpl(endpointUrl(baseURL, path), {
+		method: "DELETE",
+		headers: {
+			"content-type": "application/json",
+			accept: "application/json",
+			...attributionHeaders()
+		},
+		body: JSON.stringify(body),
+		...signal === void 0 ? {} : { signal }
+	});
+	if (!response.ok) await throwHttpError(response, endpointUrl(baseURL, path));
+	return response.json();
+}
+/**
+* Send a POST and return the raw `Response` after validating 2xx. Used by the
+* streaming adapter, which owns body decoding and the idle watchdog.
+*/
+async function postStream(baseURL, path, body, fetchImpl, signal) {
+	const response = await fetchImpl(endpointUrl(baseURL, path), {
+		method: "POST",
+		headers: {
+			"content-type": "application/json",
+			accept: "application/x-ndjson",
+			...attributionHeaders()
+		},
+		body: JSON.stringify(body),
+		...signal === void 0 ? {} : { signal }
+	});
+	if (!response.ok) await throwHttpError(response, endpointUrl(baseURL, path));
+	return response;
+}
+/** List installed models from `/api/tags`. */
+async function listModels(baseURL, fetchImpl, signal) {
+	return (await requestJson(baseURL, "/api/tags", fetchImpl, signal)).models ?? [];
+}
+/** List currently-loaded (running) models from `/api/ps`. */
+async function listRunning(baseURL, fetchImpl, signal) {
+	return (await requestJson(baseURL, "/api/ps", fetchImpl, signal)).models ?? [];
+}
+/** Inspect one model via `/api/show`. */
+async function showModel(baseURL, name, fetchImpl, signal) {
+	return postJson(baseURL, "/api/show", { name }, fetchImpl, signal);
+}
+/** Remove one model via `/api/delete`. */
+async function removeModel(baseURL, name, fetchImpl, signal) {
+	await deleteJson(baseURL, "/api/delete", { name }, fetchImpl, signal);
+}
+/** Query the Ollama server version via `/api/version`. */
+async function apiVersion(baseURL, fetchImpl, signal) {
+	return (await requestJson(baseURL, "/api/version", fetchImpl, signal)).version;
+}
+/**
+* Pull a model via `/api/pull`, consuming the progress stream and returning the
+* final status. An intermediate error status or a non-2xx response fails loud.
+*/
+async function pullModel(baseURL, name, fetchImpl, signal) {
+	const response = await postStream(baseURL, "/api/pull", {
+		name,
+		stream: true
+	}, fetchImpl, signal);
+	if (!response.body) throw new LlmError("Ollama pull returned no response body", "EMPTY_RESPONSE");
+	let last = { status: "success" };
+	for await (const line of readNdjsonLines(response.body)) {
+		if (line.length === 0) continue;
+		const chunk = JSON.parse(line);
+		if (typeof chunk.error === "string" && chunk.error.length > 0) throw new LlmError(chunk.error, "PROVIDER");
+		if (typeof chunk.status === "string") last = { status: chunk.status };
+	}
+	return last;
+}
+/**
+* Decode a `ReadableStream<Uint8Array>` into newline-delimited text lines.
+* The final line is yielded even without a trailing newline; a missing body
+* yields nothing.
+* @param body - the response body stream.
+* @returns text lines in delivery order.
+*/
+async function* readNdjsonLines(body) {
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+			let newline = buffer.indexOf("\n");
+			while (newline >= 0) {
+				const line = buffer.slice(0, newline).replace(/\r$/u, "");
+				buffer = buffer.slice(newline + 1);
+				newline = buffer.indexOf("\n");
+				yield line;
+			}
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	buffer += decoder.decode();
+	if (buffer.length > 0) yield buffer;
+}
+/**
+* Extract the context length from an `/api/show` result by scanning
+* `model_info` for a `*.context_length` or bare `context_length` entry.
+* @param show - the `/api/show` result.
+* @returns the context length, or `undefined` when not reported.
+*/
+function contextLengthOf(show) {
+	const info = show.model_info;
+	if (info === void 0) return void 0;
+	for (const [key, value] of Object.entries(info)) if (key === "context_length" || key.endsWith(".context_length")) {
+		if (typeof value === "number" && Number.isInteger(value) && value > 0) return value;
+	}
+}
+//#endregion
+//#region src/serialize.ts
+/**
+* Serialize harness messages and requests into the Ollama `/api/chat` wire
+* vocabulary. User text is joined; assistant text becomes `content` and tool
+* calls become `tool_calls` (with arguments parsed from the raw JSON string to
+* the object Ollama expects); tool results become separate `tool` messages.
+* Core image blocks are rejected explicitly because this route is text-only;
+* unknown declaration-merged block types retain the documented extension
+* fallback (ignored for content, retained as text where text is expected).
+* @module dsh-local-ai/serialize
+*/
+/** Join the text blocks of a message (used for user/tool-result content). */
+function flattenText(blocks) {
+	return blocks.filter((block) => block.type === "text").map((block) => block.text).join("");
+}
+/** Reject core image content before any text-flattening path can silently erase it. */
+function assertTextOnly(blocks) {
+	if (contentHasImage(blocks)) throw new LlmError("The Ollama adapter does not support image content.", "UNSUPPORTED_CONTENT");
+}
+/**
+* Parse a tool-call argument string into the object Ollama expects. The raw
+* string is guaranteed by the harness contract to be JSON; a malformed value
+* from a hand-built call degrades to a single `value` field rather than
+* bricking the whole session.
+* @param raw - the raw JSON string produced by the model.
+* @returns the parsed object, or a `{ value }` fallback.
+*/
+function parseToolArguments(raw) {
+	try {
+		const parsed = JSON.parse(raw);
+		if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) return parsed;
+		return { value: raw };
+	} catch {
+		return { value: raw };
+	}
+}
+/** Serialize one assistant message (text + tool calls). */
+function serializeAssistant(message) {
+	const text = flattenText(message.content);
+	const toolCalls = message.content.filter((block) => block.type === "tool-call").map((block) => ({ function: {
+		name: block.name,
+		arguments: parseToolArguments(block.arguments)
+	} }));
+	return {
+		role: "assistant",
+		content: text,
+		...toolCalls.length > 0 ? { tool_calls: toolCalls } : {}
+	};
+}
+/** Resolve a tool-result block's name from the assistant tool calls that precede it. */
+function toolNameOf(callId, namesByCallId) {
+	return namesByCallId.get(callId);
+}
+/**
+* Serialize the conversation. `tool-result` blocks become standalone
+* `{role: 'tool'}` messages; the harness puts each tool result in its own
+* user-role message, so a mixed user message contributes its text first and
+* its tool results as separate wire messages after. Assistant tool calls are
+* indexed first so their results can carry the tool name Ollama needs.
+* @param messages - the harness conversation, in order.
+* @returns the wire messages; order preserved, each tool result expanded into its own entry.
+*/
+function serializeMessages(messages) {
+	const namesByCallId = /* @__PURE__ */ new Map();
+	for (const message of messages) {
+		if (message.role !== "assistant") continue;
+		for (const block of message.content) if (block.type === "tool-call") namesByCallId.set(String(block.id), block.name);
+	}
+	const wire = [];
+	for (const message of messages) {
+		assertTextOnly(message.content);
+		if (message.role === "system") {
+			wire.push({
+				role: "system",
+				content: flattenText(message.content)
+			});
+			continue;
+		}
+		if (message.role === "assistant") {
+			wire.push(serializeAssistant(message));
+			continue;
+		}
+		const toolResults = message.content.filter((block) => block.type === "tool-result");
+		const text = flattenText(message.content);
+		if (text.length > 0 || toolResults.length === 0) wire.push({
+			role: "user",
+			content: text
+		});
+		for (const result of toolResults) {
+			const name = toolNameOf(String(result.toolCallId), namesByCallId);
+			wire.push({
+				role: "tool",
+				content: flattenText(result.content) || "(no output)",
+				...name === void 0 ? {} : { tool_name: name }
+			});
+		}
+	}
+	return wire;
+}
+/**
+* Build the full wire request. Always streaming (`stream: true`); optional
+* fields are omitted rather than sent as null, so Ollama defaults apply.
+* `temperature` resolves request → model mapping → plugin default; `num_predict`
+* is the harness-materialized `maxTokens`.
+* @param options - the harness request (model, history, system, tools, sampling).
+* @param resolved - the resolved plugin config.
+* @returns the `/api/chat` request body.
+*/
+function serializeRequest(options, resolved) {
+	const mapping = resolved.models.find((entry) => entry.name === options.model);
+	const model = mapping?.model ?? options.model;
+	const messages = [];
+	if (options.system !== void 0) messages.push({
+		role: "system",
+		content: options.system
+	});
+	messages.push(...serializeMessages(options.messages));
+	const temperature = options.temperature ?? mapping?.temperature ?? resolved.temperature;
+	const ollamaOptions = {};
+	if (temperature !== void 0) ollamaOptions.temperature = temperature;
+	if (options.maxTokens !== void 0) ollamaOptions.num_predict = options.maxTokens;
+	if (options.stop !== void 0 && options.stop.length > 0) ollamaOptions.stop = options.stop;
+	const tools = options.tools?.map((tool) => ({
+		type: "function",
+		function: tool
+	}));
+	return {
+		model,
+		messages,
+		stream: true,
+		...Object.keys(ollamaOptions).length > 0 ? { options: ollamaOptions } : {},
+		...tools !== void 0 && tools.length > 0 ? { tools } : {}
+	};
+}
+//#endregion
+//#region src/translate.ts
+/**
+* Translate Ollama NDJSON chat chunks into the harness `StreamChunk` protocol.
+* Ollama streams one JSON object per line: `message.content` and
+* `message.thinking` are incremental deltas, while `message.tool_calls`
+* carries the CUMULATIVE arguments object, so tool-call deltas are computed by
+* longest-common-prefix diffing. Usage and the finish reason are deferred to
+* the `done: true` chunk, guaranteeing no chunk follows `finish`.
+* @module dsh-local-ai/translate
+*/
+/**
+* Map the Ollama `done_reason` vocabulary to the harness FinishReason.
+* @param reason - the wire `done_reason` string.
+* @returns the mapped reason; unrecognized values become `{kind: 'error'}`.
+*/
+function mapFinishReason(reason) {
+	switch (reason) {
+		case "stop": return { kind: "stop" };
+		case "tool_calls": return { kind: "tool-calls" };
+		case "length": return { kind: "max-tokens" };
+		default: return {
+			kind: "error",
+			failure: {
+				message: `model stopped: ${reason}`,
+				code: reason.toUpperCase()
+			}
+		};
+	}
+}
+/** Assemble the final ContentBlock for one open block. */
+function closeBlock(block) {
+	switch (block.kind) {
+		case "text": return {
+			type: "text",
+			text: block.text
+		};
+		case "reasoning": return {
+			type: "reasoning",
+			text: block.text
+		};
+		case "tool-call": return {
+			type: "tool-call",
+			id: CallId(block.callId ?? ""),
+			name: block.name ?? "",
+			arguments: block.text
+		};
+	}
+}
+/**
+* Compute the append delta from a cumulative JSON string, so the harness's
+* delta-concatenating assembler reconstructs the full arguments. Ollama grows
+* the arguments object monotonically, so the delta is everything past the
+* longest common prefix with the previously seen string.
+* @param previous - the previously seen cumulative JSON (or `''`).
+* @param next - the new cumulative JSON.
+* @returns the fragment to append.
+*/
+function argumentsDelta(previous, next) {
+	if (next.startsWith(previous)) return next.slice(previous.length);
+	let index = 0;
+	while (index < previous.length && index < next.length && previous[index] === next[index]) index += 1;
+	return next.slice(index);
+}
+/**
+* Consume Ollama NDJSON lines and yield StreamChunks. Text and reasoning deltas
+* stream as they arrive; tool-call deltas are diffed from the cumulative wire
+* arguments; `block-end`, `usage`, and `finish` are deferred to the `done`
+* chunk. A `stop` finish with no opened blocks maps to an `EMPTY_RESPONSE`
+* error finish.
+* @param lines - newline-delimited Ollama chat payloads.
+* @returns deltas as they arrive; `block-end`s, `usage`, and `finish` deferred to `done`.
+*/
+async function* translate(lines) {
+	let nextIndex = 0;
+	let textBlock;
+	let reasoningBlock;
+	const toolBlocks = /* @__PURE__ */ new Map();
+	const toolArguments = /* @__PURE__ */ new Map();
+	const order = [];
+	function open(kind) {
+		const block = {
+			index: nextIndex++,
+			kind,
+			text: ""
+		};
+		order.push(block);
+		return block;
+	}
+	for await (const line of lines) {
+		if (line.length === 0) continue;
+		let chunk;
+		try {
+			chunk = JSON.parse(line);
+		} catch {
+			throw new LlmError(`malformed Ollama NDJSON payload: ${line.slice(0, 120)}`, "MALFORMED_RESPONSE");
+		}
+		if (typeof chunk.error === "string" && chunk.error.length > 0) throw new LlmError(chunk.error, "PROVIDER");
+		const message = chunk.message;
+		if (message !== void 0) {
+			const reasoning = message.thinking;
+			if (typeof reasoning === "string" && reasoning.length > 0) {
+				if (!reasoningBlock) {
+					reasoningBlock = open("reasoning");
+					yield {
+						type: "block-start",
+						index: reasoningBlock.index,
+						blockType: "reasoning"
+					};
+				}
+				reasoningBlock.text += reasoning;
+				yield {
+					type: "reasoning-delta",
+					index: reasoningBlock.index,
+					text: reasoning
+				};
+			}
+			const content = message.content;
+			if (typeof content === "string" && content.length > 0) {
+				if (!textBlock) {
+					textBlock = open("text");
+					yield {
+						type: "block-start",
+						index: textBlock.index,
+						blockType: "text"
+					};
+				}
+				textBlock.text += content;
+				yield {
+					type: "text-delta",
+					index: textBlock.index,
+					text: content
+				};
+			}
+			const toolCalls = message.tool_calls ?? [];
+			for (let callIndex = 0; callIndex < toolCalls.length; callIndex++) {
+				const call = toolCalls[callIndex];
+				let block = toolBlocks.get(callIndex);
+				if (!block) {
+					block = open("tool-call");
+					toolBlocks.set(callIndex, block);
+					toolArguments.set(callIndex, "");
+					yield {
+						type: "block-start",
+						index: block.index,
+						blockType: "tool-call"
+					};
+				}
+				if (call?.function?.name !== void 0 && block.name === void 0) block.name = call.function.name;
+				const cumulative = JSON.stringify(call?.function?.arguments ?? {});
+				const previous = toolArguments.get(callIndex) ?? "";
+				if (cumulative !== previous) {
+					const fragment = argumentsDelta(previous, cumulative);
+					toolArguments.set(callIndex, cumulative);
+					block.text += fragment;
+					yield {
+						type: "tool-call-delta",
+						index: block.index,
+						id: CallId(block.callId ?? ""),
+						...block.name !== void 0 ? { name: block.name } : {},
+						argumentsDelta: fragment
+					};
+				}
+			}
+		}
+		if (chunk.done === true) {
+			for (const block of order) yield {
+				type: "block-end",
+				index: block.index,
+				block: closeBlock(block)
+			};
+			const promptCount = chunk.prompt_eval_count;
+			const evalCount = chunk.eval_count;
+			if (promptCount !== void 0 || evalCount !== void 0) yield {
+				type: "usage",
+				usage: {
+					inputTokens: promptCount ?? 0,
+					outputTokens: evalCount ?? 0
+				}
+			};
+			const reason = mapFinishReason(chunk.done_reason ?? "stop");
+			yield {
+				type: "finish",
+				reason: reason.kind === "stop" && order.length === 0 ? {
+					kind: "error",
+					failure: {
+						message: "model returned a completed response with no content",
+						code: EMPTY_RESPONSE_CODE
+					}
+				} : reason
+			};
+			return;
+		}
+	}
+	throw new LlmError("Ollama NDJSON stream ended without a done chunk", "STREAM_CLOSED");
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.144.0/helpers/esm/usingCtx.js
+function _usingCtx() {
+	var r = "function" == typeof SuppressedError ? SuppressedError : function(r, e) {
+		var n = Error();
+		return n.name = "SuppressedError", n.error = r, n.suppressed = e, n;
+	}, e = {}, n = [];
+	function using(r, e) {
+		if (null != e) {
+			if (Object(e) !== e) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
+			if (r) var o = e[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")];
+			if (void 0 === o && (o = e[Symbol.dispose || Symbol["for"]("Symbol.dispose")], r)) var t = o;
+			if ("function" != typeof o) throw new TypeError("Object is not disposable.");
+			t && (o = function o() {
+				try {
+					t.call(e);
+				} catch (r) {
+					return Promise.reject(r);
+				}
+			}), n.push({
+				v: e,
+				d: o,
+				a: r
+			});
+		} else r && n.push({
+			d: e,
+			a: r
+		});
+		return e;
+	}
+	return {
+		e,
+		u: using.bind(null, !1),
+		a: using.bind(null, !0),
+		d: function d() {
+			var o, t = this.e, s = 0;
+			function next() {
+				for (; o = n.pop();) try {
+					if (!o.a && 1 === s) return s = 0, n.push(o), Promise.resolve().then(next);
+					if (o.d) {
+						var r = o.d.call(o.v);
+						if (o.a) return s |= 2, Promise.resolve(r).then(next, err);
+					} else s |= 1;
+				} catch (r) {
+					return err(r);
+				}
+				if (1 === s) return t !== e ? Promise.reject(t) : Promise.resolve();
+				if (t !== e) throw t;
+			}
+			function err(n) {
+				return t = t !== e ? new r(n, t) : n, next();
+			}
+			return next();
+		}
+	};
+}
+//#endregion
+//#region src/adapter.ts
+/**
+* `OllamaAdapter`: the harness `LlmAdapter` over Ollama's native `/api/chat`
+* streaming endpoint. Transport-only: the registering plugin owns config
+* resolution (one `() => ResolvedConfig` thunk re-read per operation), so a
+* changed base URL, model mapping, or timeout reaches the next request without
+* re-registration, while an in-flight stream keeps the facts it started with.
+* The adapter is text-only (`inputModalities: ['text']`); tool calls and tool
+* results are translated by {@link serializeRequest}.
+* @module dsh-local-ai/adapter
+*/
+/** Idle-timeout abort code stamped onto a stalled stream's timeout reason. */
+const STREAM_IDLE_TIMEOUT_CODE = "LLM_STREAM_IDLE_TIMEOUT";
+/** The single provider route this adapter owns. */
+const OLLAMA_PROVIDER = "ollama";
+/** Reverse a model mapping: Ollama model id → harness-visible name. */
+function harnessNameOf(resolved, ollamaName) {
+	return resolved.models.find((entry) => entry.model === ollamaName)?.name ?? ollamaName;
+}
+/** Advertise one configured or discovered local model as text-only. */
+function modelInfo(provider, id, name) {
+	return {
+		provider,
+		id,
+		name,
+		inputModalities: ["text"]
+	};
+}
+/**
+* The Ollama provider adapter. One instance serves every harness-visible local
+* model name; the harness model name maps to the wire model id through the
+* configured model mapping (identity when unmapped).
+*/
+var OllamaAdapter = class extends LlmAdapter {
+	options;
+	constructor(options) {
+		super();
+		this.options = options;
+	}
+	fetchImpl() {
+		return this.options.fetchImpl ?? ((input, init) => globalThis.fetch(input, init));
+	}
+	providerInfo(provider) {
+		return {
+			id: provider,
+			name: "Ollama (local)"
+		};
+	}
+	listModels(provider) {
+		const resolved = this.options.config();
+		return listModels(resolved.baseURL, this.fetchImpl()).then((models) => models.map((model) => modelInfo(provider, harnessNameOf(resolved, model.name), harnessNameOf(resolved, model.name)))).catch(() => resolved.models.map((entry) => modelInfo(provider, entry.name, entry.name)));
+	}
+	resolveModel(provider, model, _signal) {
+		const resolved = this.options.config();
+		const mapping = resolved.models.find((entry) => entry.name === model);
+		return Promise.resolve({
+			provider,
+			id: model,
+			name: model,
+			inputModalities: ["text"],
+			context: { contextWindow: mapping?.contextWindow ?? resolved.defaultContextWindow },
+			defaultMaxTokens: mapping?.maxTokens ?? resolved.maxTokens
+		});
+	}
+	async *stream(options) {
+		try {
+			var _usingCtx$1 = _usingCtx();
+			const resolved = this.options.config();
+			const consumer = new AbortController();
+			const upstream = options.signal === void 0 ? consumer.signal : AbortSignal.any([options.signal, consumer.signal]);
+			const watchdog = _usingCtx$1.u(idleWatchdog(upstream, resolved.requestTimeoutMs, STREAM_IDLE_TIMEOUT_CODE));
+			const iterator = this.request(options, resolved, watchdog.signal)[Symbol.asyncIterator]();
+			let exhausted = false;
+			try {
+				while (true) {
+					const result = await watchdog.next(iterator);
+					if (result.done) {
+						exhausted = true;
+						return;
+					}
+					yield result.value;
+				}
+			} catch (error) {
+				if (timeoutOf(watchdog.signal, STREAM_IDLE_TIMEOUT_CODE) !== void 0) throw new LlmError(`Ollama stream idle timeout after ${resolved.requestTimeoutMs}ms`, "TIMEOUT", { cause: error });
+				if (options.signal?.aborted) throw new LlmError("Ollama request aborted by caller", "ABORTED", { cause: error });
+				if (error instanceof LlmError) throw error;
+				throw new LlmError(`Ollama API stream from ${sanitizeEndpoint(resolved.baseURL)} failed`, "TRANSPORT", { cause: error });
+			} finally {
+				consumer.abort("Ollama stream consumer stopped");
+				if (!exhausted && iterator.return !== void 0) try {
+					await iterator.return();
+				} catch (_abortedTransportTeardown) {}
+			}
+		} catch (_) {
+			_usingCtx$1.e = _;
+		} finally {
+			_usingCtx$1.d();
+		}
+	}
+	async *request(options, resolved, signal) {
+		const body = serializeRequest(options, resolved);
+		let response;
+		try {
+			response = await postStream(resolved.baseURL, "/api/chat", body, this.fetchImpl(), signal);
+		} catch (error) {
+			if (signal.aborted) throw error;
+			throw new LlmError(`Ollama API request to ${sanitizeEndpoint(resolved.baseURL)} failed`, "TRANSPORT", { cause: error });
+		}
+		if (!response.body) throw new LlmError("Ollama API returned no response body", "EMPTY_RESPONSE");
+		yield* translate(readNdjsonLines(response.body));
+	}
+};
+//#endregion
+//#region src/route.ts
+/**
+* Local-model routing decision and the streaming fallback. The pure decision
+* matches configured rules (task type via `purpose`, case-insensitive
+* keywords, or a blanket `always`) against a request, in list order — first
+* match wins. The streaming helper routes a matched request to the local
+* Ollama adapter and, when the local route fails BEFORE producing any visible
+* content, falls back to the cloud (`next()`) so a down Ollama never bricks a
+* conversation. Once local content has started, it is streamed through — a
+* mid-stream failure cannot be retracted.
+* @module dsh-local-ai/route
+*/
+/**
+* Concatenate the request's model-visible text (system prompt + every text
+* block) for keyword matching.
+* @param options - the request.
+* @returns the joined text.
+*/
+function requestText(options) {
+	const parts = [];
+	if (options.system !== void 0) parts.push(options.system);
+	for (const message of options.messages) for (const block of message.content) if (block.type === "text") parts.push(block.text);
+	return parts.join("\n");
+}
+/** Whether a keyword appears case-insensitively in the text. */
+function matchesKeyword(text, keyword) {
+	return text.toLowerCase().includes(keyword.toLowerCase());
+}
+/** Whether one resolved rule matches a request. */
+function ruleMatches(rule, options) {
+	if (rule.always) return true;
+	if (rule.purpose !== void 0 && options.purpose === rule.purpose) return true;
+	if (rule.keywords.length > 0) {
+		const text = requestText(options);
+		return rule.keywords.some((keyword) => matchesKeyword(text, keyword));
+	}
+	return false;
+}
+/**
+* Decide whether a request should route to a local model. A request already
+* addressed to the `ollama` provider (explicit selection or a prior re-route)
+* never re-routes.
+* @param options - the request.
+* @param resolved - the resolved config.
+* @returns the local model to use, or `undefined` to stay on the cloud route.
+*/
+function decideRoute(options, resolved) {
+	if (options.provider === "ollama") return void 0;
+	for (const rule of resolved.route) if (ruleMatches(rule, options)) return { model: rule.model };
+}
+/**
+* Stream a locally-routed request with automatic cloud fallback. The local
+* stream is produced through `streamLocal` (the full harness stream, so the
+* local route keeps retry and failure normalization). If the local route
+* finishes with an error or aborts before any token delta, `next()` (the
+* cloud) is streamed instead; otherwise the local stream is forwarded.
+* @param streamLocal - produces the local stream for a re-routed request.
+* @param options - the original request.
+* @param decision - the local model to route to.
+* @param next - the cloud stream (the waterfall's `next()`).
+* @returns the effective chunk stream.
+*/
+async function* routeLocal(streamLocal, options, decision, next) {
+	const upstream = streamLocal({
+		...options,
+		provider: OLLAMA_PROVIDER,
+		model: decision.model
+	});
+	let producedContent = false;
+	const pending = [];
+	try {
+		for await (const chunk of upstream) {
+			if (producedContent) {
+				yield chunk;
+				continue;
+			}
+			if (chunk.type === "finish") {
+				if (chunk.reason.kind === "error" || chunk.reason.kind === "aborted") {
+					yield* next();
+					return;
+				}
+				yield chunk;
+				return;
+			}
+			pending.push(chunk);
+			if (isTokenDelta(chunk)) {
+				producedContent = true;
+				for (const buffered of pending) yield buffered;
+				pending.length = 0;
+			}
+		}
+		for (const buffered of pending) yield buffered;
+	} catch (error) {
+		if (!producedContent) {
+			yield* next();
+			return;
+		}
+		for (const buffered of pending) yield buffered;
+		throw error;
+	}
+}
+//#endregion
+//#region src/health.ts
+/** The default probe: `ollama list` reaches the server through the CLI's own channel. */
+const OLLAMA_PROCESS_PROBE = {
+	command: "ollama",
+	args: ["list"]
+};
+/**
+* Check whether the Ollama HTTP API responds to `/api/version` within a
+* deadline. A timeout, transport failure, or non-2xx response is `ok: false`
+* with a sanitized error.
+* @param baseURL - the Ollama base URL.
+* @param fetchImpl - the fetch implementation.
+* @param timeoutMs - deadline in milliseconds.
+* @returns the API health result.
+*/
+async function checkApiHealth(baseURL, fetchImpl, timeoutMs) {
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(/* @__PURE__ */ new Error("timeout")), timeoutMs);
+	try {
+		return {
+			ok: true,
+			version: sanitizeText(await apiVersion(baseURL, fetchImpl, controller.signal), 64)
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			error: sanitizeText(error instanceof Error ? error.message : String(error), 500)
+		};
+	} finally {
+		clearTimeout(timer);
+	}
+}
+/**
+* Check process liveness through the subprocess seam by spawning the probe
+* command in collect mode. Exit code 0 means the CLI (and, for the default
+* `ollama list` probe, the server it talks to) is alive; a missing executable
+* or non-zero exit is `present: false` with a sanitized error.
+* @param subprocess - the real subprocess runtime.
+* @param graceMs - terminate grace for the spawned probe.
+* @param probe - the command to probe with (defaults to `ollama list`).
+* @returns the process health result.
+*/
+async function checkProcessHealth(subprocess, graceMs, probe = OLLAMA_PROCESS_PROBE) {
+	let executable;
+	try {
+		executable = await subprocess.resolveExecutable(probe.command);
+	} catch (error) {
+		return {
+			present: false,
+			error: sanitizeText(`"${probe.command}" not found: ${error instanceof Error ? error.message : String(error)}`, 500)
+		};
+	}
+	const handle = subprocess.spawn({
+		argv: [executable, ...probe.args],
+		cwd: tmpdir(),
+		stdio: {
+			stdin: "ignore",
+			stdout: { maxBytes: 4096 },
+			stderr: { maxBytes: 4096 }
+		},
+		graceMs
+	});
+	const outcome = await handle.done;
+	if (outcome.exitCode === 0) return { present: true };
+	const stderr = handle.collected.stderr?.readFrom(0).text ?? "";
+	return {
+		present: false,
+		error: sanitizeText(stderr.trim().length > 0 ? stderr : `exit code ${String(outcome.exitCode)}`, 500)
+	};
+}
+/**
+* Check both health signals.
+* @param baseURL - the Ollama base URL.
+* @param fetchImpl - the fetch implementation.
+* @param subprocess - the real subprocess runtime.
+* @param requestTimeoutMs - HTTP deadline in milliseconds.
+* @param graceMs - subprocess terminate grace in milliseconds.
+* @returns the combined health result.
+*/
+async function checkHealth(baseURL, fetchImpl, subprocess, requestTimeoutMs, graceMs) {
+	const [api, process] = await Promise.all([checkApiHealth(baseURL, fetchImpl, requestTimeoutMs), checkProcessHealth(subprocess, graceMs)]);
+	return {
+		api,
+		process
+	};
+}
+//#endregion
+//#region src/version.ts
+/**
+* The `dsh-local-ai` plugin version. The release script bumps this string
+* alongside `package.json`; `test/version.spec.ts` trips when the two drift.
+*/
+const VERSION = "0.1.0";
+//#endregion
+//#region src/index.ts
+const name = "local-ai";
+const inject = [
+	"llm",
+	"tools",
+	"subprocess",
+	"commands"
+];
+/** Format a byte count into a compact human-readable string. */
+function formatBytes(bytes) {
+	if (!Number.isFinite(bytes) || bytes < 0) return "0 B";
+	const units = [
+		"B",
+		"KB",
+		"MB",
+		"GB",
+		"TB"
+	];
+	let value = bytes;
+	let unit = 0;
+	while (value >= 1024 && unit < units.length - 1) {
+		value /= 1024;
+		unit += 1;
+	}
+	return `${unit === 0 ? String(Math.round(value)) : value.toFixed(1)} ${units[unit]}`;
+}
+/** Render the `ollama_list` canonical value as model-visible text. */
+function renderList(value) {
+	const list = value;
+	const models = list.models ?? [];
+	const lines = [`${models.length} local model(s), ${formatBytes(list.totalBytes ?? 0)} on disk`];
+	for (const model of models) {
+		const detail = [model.parameterSize, model.quantization].filter((part) => part !== void 0).join(" ");
+		lines.push(`- ${model.name}${detail.length > 0 ? ` (${detail})` : ""} — ${formatBytes(model.size)}${model.running ? " [running]" : ""}`);
+	}
+	if (list.running !== void 0 && list.running.length > 0) lines.push(`running: ${list.running.join(", ")}`);
+	return lines.join("\n");
+}
+/** Render the `ollama_show` canonical value as model-visible text. */
+function renderShow(value) {
+	const show = value;
+	const parts = [
+		[show.parameterSize, show.quantization].filter((part) => part !== void 0).join(" "),
+		show.contextLength !== void 0 ? `context ${show.contextLength}` : void 0,
+		show.family,
+		show.format
+	].filter((part) => part !== void 0 && part.length > 0);
+	return `${show.name}${parts.length > 0 ? ` — ${parts.join(", ")}` : ""}`;
+}
+/** Render a health canonical value as model-visible text. */
+function renderHealth(value) {
+	const health = value;
+	return [`API: ${health.api.ok ? `ok${health.api.version !== void 0 ? ` (v${health.api.version})` : ""}` : "down"}`, `process: ${health.process.present ? "alive" : "not detected"}`].join("\n");
+}
+/** Render a pull/remove canonical value as model-visible text. */
+function renderOperation(value) {
+	const op = value;
+	if (op.removed === true) return `removed ${op.name}`;
+	return `${op.name}: ${op.status ?? "done"}`;
+}
+/**
+* Mount the plugin: resolve config (fail loud), register the Ollama adapter,
+* the `llm/stream` routing waterfall, the five management tools, and the
+* `/ollama` command. Every contribution goes through its registry's effect
+* (register/on), so stop and hot-reload withdraw all of it.
+* @param ctx - the plugin context (host).
+* @param config - raw plugin config.
+*/
+function apply(ctx, config = {}) {
+	const resolved = resolveConfig(config);
+	const logger = ctx.logger("local-ai");
+	const fetchImpl = (input, init) => globalThis.fetch(input, init);
+	const adapter = new OllamaAdapter({
+		config: () => resolved,
+		fetchImpl
+	});
+	ctx.llm.registerAdapter([OLLAMA_PROVIDER], adapter);
+	ctx.on("llm/stream", (options, next) => {
+		const decision = decideRoute(options, resolved);
+		if (decision === void 0) return next();
+		return routeLocal((reRouted) => ctx.llm.stream(reRouted), options, decision, next);
+	});
+	ctx.tools.register(defineTool({
+		name: "ollama_list",
+		description: "List local Ollama models with disk usage and which are currently loaded (running).",
+		parameters: {},
+		output: {
+			schema: { type: "json" },
+			render: (_args, value) => [{
+				type: "text",
+				text: renderList(value)
+			}]
+		},
+		async execute(_args, exec) {
+			const [models, running] = await Promise.all([listModels(resolved.baseURL, fetchImpl, exec.signal), listRunning(resolved.baseURL, fetchImpl, exec.signal).catch(() => [])]);
+			const runningNames = new Set(running.map((model) => model.name));
+			return {
+				models: models.map((model) => ({
+					name: model.name,
+					size: model.size,
+					...model.details?.parameter_size === void 0 ? {} : { parameterSize: model.details.parameter_size },
+					...model.details?.quantization_level === void 0 ? {} : { quantization: model.details.quantization_level },
+					running: runningNames.has(model.name)
+				})),
+				running: running.map((model) => model.name),
+				count: models.length,
+				totalBytes: models.reduce((sum, model) => sum + model.size, 0)
+			};
+		}
+	}));
+	ctx.tools.register(defineTool({
+		name: "ollama_show",
+		description: "Show details for one local Ollama model: parameter size, quantization, and context length.",
+		parameters: { name: {
+			type: "string",
+			required: true,
+			description: "The Ollama model name to inspect."
+		} },
+		output: {
+			schema: { type: "json" },
+			render: (_args, value) => [{
+				type: "text",
+				text: renderShow(value)
+			}]
+		},
+		async execute(args, exec) {
+			const name = args.name;
+			const show = await showModel(resolved.baseURL, name, fetchImpl, exec.signal);
+			return {
+				name,
+				...show.details?.parameter_size === void 0 ? {} : { parameterSize: show.details.parameter_size },
+				...show.details?.quantization_level === void 0 ? {} : { quantization: show.details.quantization_level },
+				...show.details?.family === void 0 ? {} : { family: show.details.family },
+				...show.details?.format === void 0 ? {} : { format: show.details.format },
+				...(() => {
+					const contextLength = contextLengthOf(show);
+					return contextLength === void 0 ? {} : { contextLength };
+				})()
+			};
+		}
+	}));
+	ctx.tools.register(defineTool({
+		name: "ollama_pull",
+		description: "Pull (download) a model into the local Ollama server.",
+		parameters: { name: {
+			type: "string",
+			required: true,
+			description: "The Ollama model name to pull (e.g. llama3.2)."
+		} },
+		output: {
+			schema: { type: "json" },
+			render: (_args, value) => [{
+				type: "text",
+				text: renderOperation(value)
+			}]
+		},
+		async execute(args, exec) {
+			const name = args.name;
+			return {
+				name,
+				status: (await pullModel(resolved.baseURL, name, fetchImpl, exec.signal)).status
+			};
+		}
+	}));
+	ctx.tools.register(defineTool({
+		name: "ollama_remove",
+		description: "Remove (delete) a model from the local Ollama server.",
+		parameters: { name: {
+			type: "string",
+			required: true,
+			description: "The Ollama model name to remove."
+		} },
+		output: {
+			schema: { type: "json" },
+			render: (_args, value) => [{
+				type: "text",
+				text: renderOperation(value)
+			}]
+		},
+		async execute(args, exec) {
+			const name = args.name;
+			await removeModel(resolved.baseURL, name, fetchImpl, exec.signal);
+			return {
+				name,
+				removed: true
+			};
+		}
+	}));
+	ctx.tools.register(defineTool({
+		name: "ollama_health",
+		description: "Check the local Ollama server: whether the process is alive and whether the API responds.",
+		parameters: {},
+		output: {
+			schema: { type: "json" },
+			render: (_args, value) => [{
+				type: "text",
+				text: renderHealth(value)
+			}]
+		},
+		async execute(_args, exec) {
+			return await checkHealth(resolved.baseURL, fetchImpl, ctx.subprocess, resolved.requestTimeoutMs, resolved.graceMs);
+		}
+	}));
+	ctx.commands.register({
+		name: "ollama",
+		description: "One-shot status overview: local models, disk usage, health, and routing suggestions.",
+		async handler() {
+			const health = await checkHealth(resolved.baseURL, fetchImpl, ctx.subprocess, resolved.requestTimeoutMs, resolved.graceMs);
+			const lines = ["Ollama status:"];
+			lines.push(`- API: ${health.api.ok ? `ok${health.api.version !== void 0 ? ` (v${health.api.version})` : ""}` : "down"}`);
+			lines.push(`- process: ${health.process.present ? "alive" : "not detected"}`);
+			let models = [];
+			try {
+				models = await listModels(resolved.baseURL, fetchImpl);
+			} catch {}
+			const totalBytes = models.reduce((sum, model) => sum + model.size, 0);
+			lines.push(`- models: ${models.length} installed (${formatBytes(totalBytes)})`);
+			for (const model of models) lines.push(`  - ${model.name} (${formatBytes(model.size)})`);
+			if (!health.api.ok && !health.process.present) lines.push("suggestion: start the Ollama server (e.g. `ollama serve`)");
+			else if (resolved.route.length === 0) lines.push("suggestion: configure `route` rules to route requests to local models");
+			return {
+				kind: "success",
+				text: lines.join("\n")
+			};
+		}
+	});
+	logger.info(`ollama adapter registered at ${resolved.baseURL} (${resolved.models.length} mapping(s), ${resolved.route.length} route rule(s))`);
+}
+//#endregion
+export { Config, REDACTED, VERSION, apply, formatBytes, inject, name, redactSecrets, renderHealth, renderList, renderOperation, renderShow, resolveConfig, sanitizeEndpoint, sanitizePath, sanitizeText, truncate };