dsh-local-ai 0.1.4 → 0.2.0

package/lib/index.js

@@ -31,8 +31,23 @@ const Config = z.object({
 		maxTokens: z.number(),
 		temperature: z.number()
 	})).default([]),
+	backends: z.array(z.object({
+		name: z.string().required(),
+		baseURL: z.string().required(),
+		apiKey: z.string(),
+		models: z.array(z.object({
+			name: z.string().required(),
+			model: z.string(),
+			contextWindow: z.number(),
+			maxTokens: z.number(),
+			temperature: z.number()
+		})).default([]),
+		maxTokens: z.number(),
+		temperature: z.number()
+	})).default([]),
 	route: z.array(z.object({
 		model: z.string().required(),
+		provider: z.string(),
 		purpose: z.union(["compaction", "session-title"]),
 		keywords: z.array(z.string()).default([]),
 		always: z.boolean().default(false)
@@ -86,30 +101,33 @@ function resolveConfig(config = {}) {
 	const temperature = config.temperature;
 	if (temperature !== void 0) assertFiniteRange("temperature", temperature, 0, 2);
 	const vision = config.vision ?? true;
-	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);
+	const models = resolveMappings(config.models, "models");
+	const backends = (config.backends ?? []).map((backend, index) => {
+		if (typeof backend.name !== "string" || backend.name.trim().length === 0) throw new TypeError(`backends[${index}].name must be a non-empty string`);
+		const name = backend.name.trim();
+		if (name === "ollama") throw new TypeError(`backends[${index}].name must not be the reserved provider id ${JSON.stringify(DEFAULT_PROVIDER)}`);
+		if (typeof backend.baseURL !== "string" || backend.baseURL.trim().length === 0) throw new TypeError(`backends[${index}].baseURL must be a non-empty string`);
+		const backendBaseURL = normalizeBaseUrl(`backends[${index}].baseURL`, backend.baseURL);
+		const backendMaxTokens = backend.maxTokens ?? maxTokens;
+		assertPositiveInt(`backends[${index}].maxTokens`, backendMaxTokens);
+		const backendTemperature = backend.temperature;
+		if (backendTemperature !== void 0) assertFiniteRange(`backends[${index}].temperature`, backendTemperature, 0, 2);
 		return {
 			name,
-			model,
-			...contextWindow === void 0 ? {} : { contextWindow },
-			...modelMaxTokens === void 0 ? {} : { maxTokens: modelMaxTokens },
-			...modelTemperature === void 0 ? {} : { temperature: modelTemperature }
+			providerId: openaiProviderId(name),
+			baseURL: backendBaseURL,
+			apiKey: backend.apiKey ?? "",
+			defaultContextWindow,
+			maxTokens: backendMaxTokens,
+			...backendTemperature === void 0 ? {} : { temperature: backendTemperature },
+			requestTimeoutMs,
+			models: resolveMappings(backend.models, `backends[${index}].models`)
 		};
 	});
 	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 provider = (rule.provider ?? "ollama").trim();
+		if (provider.length === 0) throw new TypeError(`route[${index}].provider 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;
@@ -117,6 +135,7 @@ function resolveConfig(config = {}) {
 		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(),
+			provider,
 			...rule.purpose === void 0 ? {} : { purpose: rule.purpose },
 			keywords,
 			always: rule.always ?? false
@@ -131,9 +150,49 @@ function resolveConfig(config = {}) {
 		...temperature === void 0 ? {} : { temperature },
 		vision,
 		models,
+		backends,
 		route
 	};
 }
+/** The provider id routing rules target when `provider` is omitted. */
+const DEFAULT_PROVIDER = "ollama";
+/** Prefix for OpenAI-compatible backend provider ids. */
+const OPENAI_PROVIDER_PREFIX = "openai:";
+/** Build the harness provider id for one OpenAI-compatible backend. */
+function openaiProviderId(name) {
+	return `${OPENAI_PROVIDER_PREFIX}${name}`;
+}
+/**
+* Validate and normalize one model-mapping list (top-level or per-backend).
+* Duplicate harness-visible names throw; the wire id defaults to the name.
+* @param mappings - the raw mappings.
+* @param label - the config path prefix for error messages.
+* @returns the resolved mappings.
+*/
+function resolveMappings(mappings, label) {
+	const seenNames = /* @__PURE__ */ new Set();
+	return (mappings ?? []).map((mapping, index) => {
+		if (typeof mapping.name !== "string" || mapping.name.trim().length === 0) throw new TypeError(`${label}[${index}].name must be a non-empty string`);
+		const name = mapping.name.trim();
+		if (seenNames.has(name)) throw new TypeError(`${label}[${index}]: duplicate model name ${JSON.stringify(name)}`);
+		seenNames.add(name);
+		const model = (mapping.model ?? name).trim();
+		if (model.length === 0) throw new TypeError(`${label}[${index}].model must be a non-empty string`);
+		const contextWindow = mapping.contextWindow;
+		if (contextWindow !== void 0) assertPositiveInt(`${label}[${index}].contextWindow`, contextWindow);
+		const modelMaxTokens = mapping.maxTokens;
+		if (modelMaxTokens !== void 0) assertPositiveInt(`${label}[${index}].maxTokens`, modelMaxTokens);
+		const modelTemperature = mapping.temperature;
+		if (modelTemperature !== void 0) assertFiniteRange(`${label}[${index}].temperature`, modelTemperature, 0, 2);
+		return {
+			name,
+			model,
+			...contextWindow === void 0 ? {} : { contextWindow },
+			...modelMaxTokens === void 0 ? {} : { maxTokens: modelMaxTokens },
+			...modelTemperature === void 0 ? {} : { temperature: modelTemperature }
+		};
+	});
+}
 //#endregion
 //#region src/sanitize.ts
 /**
@@ -261,7 +320,7 @@ function httpErrorCode(status) {
 	return `HTTP_${status}`;
 }
 /** Throw a normalized LlmError from a non-2xx response, using the body's `error`. */
-async function throwHttpError(response, context) {
+async function throwHttpError$1(response, context) {
 	let message = `Ollama API error (HTTP ${response.status}) from ${sanitizeEndpoint(context)}`;
 	try {
 		const body = await response.json();
@@ -279,7 +338,7 @@ async function requestJson(baseURL, path, fetchImpl, signal) {
 		},
 		...signal === void 0 ? {} : { signal }
 	});
-	if (!response.ok) await throwHttpError(response, endpointUrl(baseURL, path));
+	if (!response.ok) await throwHttpError$1(response, endpointUrl(baseURL, path));
 	return response.json();
 }
 /** Send a POST request and parse the JSON response. */
@@ -294,7 +353,7 @@ async function postJson(baseURL, path, body, fetchImpl, signal) {
 		body: JSON.stringify(body),
 		...signal === void 0 ? {} : { signal }
 	});
-	if (!response.ok) await throwHttpError(response, endpointUrl(baseURL, path));
+	if (!response.ok) await throwHttpError$1(response, endpointUrl(baseURL, path));
 	return response.json();
 }
 /** Send a DELETE request and parse the JSON response. */
@@ -309,7 +368,7 @@ async function deleteJson(baseURL, path, body, fetchImpl, signal) {
 		body: JSON.stringify(body),
 		...signal === void 0 ? {} : { signal }
 	});
-	if (!response.ok) await throwHttpError(response, endpointUrl(baseURL, path));
+	if (!response.ok) await throwHttpError$1(response, endpointUrl(baseURL, path));
 	return response.json();
 }
 /**
@@ -327,11 +386,11 @@ async function postStream(baseURL, path, body, fetchImpl, signal) {
 		body: JSON.stringify(body),
 		...signal === void 0 ? {} : { signal }
 	});
-	if (!response.ok) await throwHttpError(response, endpointUrl(baseURL, path));
+	if (!response.ok) await throwHttpError$1(response, endpointUrl(baseURL, path));
 	return response;
 }
 /** List installed models from `/api/tags`. */
-async function listModels(baseURL, fetchImpl, signal) {
+async function listModels$1(baseURL, fetchImpl, signal) {
 	return (await requestJson(baseURL, "/api/tags", fetchImpl, signal)).models ?? [];
 }
 /** List currently-loaded (running) models from `/api/ps`. */
@@ -427,7 +486,7 @@ function contextLengthOf(show) {
 * @module dsh-local-ai/serialize
 */
 /** Join the text blocks of a message (used for user/tool-result content). */
-function flattenText(blocks) {
+function flattenText$1(blocks) {
 	return blocks.filter((block) => block.type === "text").map((block) => block.text).join("");
 }
 /**
@@ -436,7 +495,7 @@ function flattenText(blocks) {
 * image (non-user roles, nested tool results, or a text-only route without
 * payloads) still fails loud instead of silently dropping the image.
 */
-function assertImagesSupported(message, imagesByRef) {
+function assertImagesSupported$1(message, imagesByRef) {
 	for (const block of message.content) if (block.type === "tool-result" && contentHasImage(block.content)) throw new LlmError("The Ollama adapter does not support tool-result image content.", "UNSUPPORTED_CONTENT");
 	const hasTopLevelImage = message.content.some((block) => block.type === "image");
 	if (message.role !== "user" && hasTopLevelImage) throw new LlmError(`The Ollama adapter does not support image content on ${message.role} messages.`, "UNSUPPORTED_CONTENT");
@@ -472,8 +531,8 @@ function parseToolArguments(raw) {
 	}
 }
 /** Serialize one assistant message (text + tool calls). */
-function serializeAssistant(message) {
-	const text = flattenText(message.content);
+function serializeAssistant$1(message) {
+	const text = flattenText$1(message.content);
 	const toolCalls = message.content.filter((block) => block.type === "tool-call").map((block) => ({ function: {
 		name: block.name,
 		arguments: parseToolArguments(block.arguments)
@@ -497,7 +556,7 @@ function toolNameOf(callId, namesByCallId) {
 * @param messages - the harness conversation, in order.
 * @returns the wire messages; order preserved, each tool result expanded into its own entry.
 */
-function serializeMessages(messages, imagesByRef) {
+function serializeMessages$1(messages, imagesByRef) {
 	const namesByCallId = /* @__PURE__ */ new Map();
 	for (const message of messages) {
 		if (message.role !== "assistant") continue;
@@ -505,21 +564,21 @@ function serializeMessages(messages, imagesByRef) {
 	}
 	const wire = [];
 	for (const message of messages) {
-		assertImagesSupported(message, imagesByRef);
+		assertImagesSupported$1(message, imagesByRef);
 		const images = imagesOf(message, imagesByRef);
 		if (message.role === "system") {
 			wire.push({
 				role: "system",
-				content: flattenText(message.content)
+				content: flattenText$1(message.content)
 			});
 			continue;
 		}
 		if (message.role === "assistant") {
-			wire.push(serializeAssistant(message));
+			wire.push(serializeAssistant$1(message));
 			continue;
 		}
 		const toolResults = message.content.filter((block) => block.type === "tool-result");
-		const text = flattenText(message.content);
+		const text = flattenText$1(message.content);
 		if (text.length > 0 || toolResults.length === 0 || images.length > 0) wire.push({
 			role: "user",
 			content: text,
@@ -529,7 +588,7 @@ function serializeMessages(messages, imagesByRef) {
 			const name = toolNameOf(String(result.toolCallId), namesByCallId);
 			wire.push({
 				role: "tool",
-				content: flattenText(result.content) || "(no output)",
+				content: flattenText$1(result.content) || "(no output)",
 				...name === void 0 ? {} : { tool_name: name }
 			});
 		}
@@ -545,7 +604,7 @@ function serializeMessages(messages, imagesByRef) {
 * @param resolved - the resolved plugin config.
 * @returns the `/api/chat` request body.
 */
-function serializeRequest(options, resolved, imagesByRef) {
+function serializeRequest$1(options, resolved, imagesByRef) {
 	const mapping = resolved.models.find((entry) => entry.name === options.model);
 	const model = mapping?.model ?? options.model;
 	const messages = [];
@@ -553,7 +612,7 @@ function serializeRequest(options, resolved, imagesByRef) {
 		role: "system",
 		content: options.system
 	});
-	messages.push(...serializeMessages(options.messages, imagesByRef));
+	messages.push(...serializeMessages$1(options.messages, imagesByRef));
 	const temperature = options.temperature ?? mapping?.temperature ?? resolved.temperature;
 	const ollamaOptions = {};
 	if (temperature !== void 0) ollamaOptions.temperature = temperature;
@@ -602,7 +661,7 @@ function mapFinishReason(reason) {
 	}
 }
 /** Assemble the final ContentBlock for one open block. */
-function closeBlock(block) {
+function closeBlock$1(block) {
 	switch (block.kind) {
 		case "text": return {
 			type: "text",
@@ -629,7 +688,7 @@ function closeBlock(block) {
 * @param block - the freshly opened tool-call block.
 * @returns the minted id.
 */
-function mintCallId(block) {
+function mintCallId$1(block) {
 	return `ollama-${Date.now().toString(36)}-${block.index}-${Math.random().toString(36).slice(2, 8)}`;
 }
 /**
@@ -753,7 +812,7 @@ async function* translate(lines) {
 				let block = toolBlocks.get(callIndex);
 				if (!block) {
 					block = open("tool-call");
-					block.callId = mintCallId(block);
+					block.callId = mintCallId$1(block);
 					toolBlocks.set(callIndex, block);
 					toolArguments.set(callIndex, "");
 					yield {
@@ -768,7 +827,7 @@ async function* translate(lines) {
 				if (cumulative !== previous) {
 					if (!isMonotonicExtension(previous, cumulative)) {
 						block = open("tool-call");
-						block.callId = mintCallId(block);
+						block.callId = mintCallId$1(block);
 						if (call?.function?.name !== void 0) block.name = call.function.name;
 						toolBlocks.set(callIndex, block);
 						toolArguments.set(callIndex, "");
@@ -795,7 +854,7 @@ async function* translate(lines) {
 			for (const block of order) yield {
 				type: "block-end",
 				index: block.index,
-				block: closeBlock(block)
+				block: closeBlock$1(block)
 			};
 			const promptCount = chunk.prompt_eval_count;
 			const evalCount = chunk.eval_count;
@@ -892,7 +951,7 @@ function _usingCtx() {
 * @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";
+const STREAM_IDLE_TIMEOUT_CODE$1 = "LLM_STREAM_IDLE_TIMEOUT";
 /**
 * Deterministic request-image policy: aspect-preserving projection at ≤ 4 MP
 * and a 10 MiB encoded-byte cap per image (a protocol default, not a tunable —
@@ -948,7 +1007,7 @@ var OllamaAdapter = class extends LlmAdapter {
 	}
 	async listModels(provider) {
 		const resolved = this.options.config();
-		const models = await listModels(resolved.baseURL, this.fetchImpl()).catch(() => []);
+		const models = await listModels$1(resolved.baseURL, this.fetchImpl()).catch(() => []);
 		const list = models.length > 0 ? models : resolved.models.map((entry) => ({
 			name: entry.model,
 			model: entry.model,
@@ -973,11 +1032,11 @@ var OllamaAdapter = class extends LlmAdapter {
 	}
 	async *stream(options) {
 		try {
-			var _usingCtx$1 = _usingCtx();
+			var _usingCtx$2 = _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 watchdog = _usingCtx$2.u(idleWatchdog(upstream, resolved.requestTimeoutMs, STREAM_IDLE_TIMEOUT_CODE$1));
 			const iterator = this.request(options, resolved, watchdog.signal)[Symbol.asyncIterator]();
 			let exhausted = false;
 			try {
@@ -990,7 +1049,7 @@ var OllamaAdapter = class extends LlmAdapter {
 					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 (timeoutOf(watchdog.signal, STREAM_IDLE_TIMEOUT_CODE$1) !== 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 });
@@ -1001,13 +1060,13 @@ var OllamaAdapter = class extends LlmAdapter {
 				} catch (_abortedTransportTeardown) {}
 			}
 		} catch (_) {
-			_usingCtx$1.e = _;
+			_usingCtx$2.e = _;
 		} finally {
-			_usingCtx$1.d();
+			_usingCtx$2.d();
 		}
 	}
 	async *request(options, resolved, signal) {
-		const body = serializeRequest(options, resolved, await this.prepareImages(options, resolved, signal));
+		const body = serializeRequest$1(options, resolved, await this.prepareImages(options, resolved, signal));
 		let response;
 		try {
 			response = await postStream(resolved.baseURL, "/api/chat", body, this.fetchImpl(), signal);
@@ -1041,16 +1100,518 @@ var OllamaAdapter = class extends LlmAdapter {
 	}
 };
 //#endregion
+//#region src/openai.ts
+/**
+* OpenAI-compatible HTTP client (zero runtime dependencies — plain `fetch`).
+* Serves the OpenAI wire protocol spoken by LM Studio, vLLM, and llama.cpp
+* `--server`: model listing via `GET /v1/models` and streaming chat via
+* `POST /v1/chat/completions` (SSE). The base URL already carries the `/v1`
+* prefix (e.g. `http://127.0.0.1:1234/v1` for LM Studio). Every request
+* carries the harness attribution headers, an optional bearer key, 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/openai
+*/
+/** Build the request headers, adding a bearer key only when one is configured. */
+function requestHeaders(apiKey, accept) {
+	const headers = {
+		"content-type": "application/json",
+		accept,
+		...attributionHeaders()
+	};
+	if (apiKey.length > 0) headers.authorization = `Bearer ${apiKey}`;
+	return headers;
+}
+/** Throw a normalized LlmError from a non-2xx response, reading the OpenAI error body. */
+async function throwHttpError(response, baseURL) {
+	let message = `OpenAI-compatible API error (HTTP ${response.status}) from ${sanitizeEndpoint(baseURL)}`;
+	try {
+		const body = await response.json();
+		if (typeof body.error === "string" && body.error.length > 0) message = body.error;
+		else if (body.error !== null && typeof body.error === "object") {
+			const detail = body.error.message;
+			if (typeof detail === "string" && detail.length > 0) message = detail;
+		}
+	} catch {}
+	const code = response.status === 404 ? "NOT_FOUND" : response.status === 400 ? "INVALID_REQUEST" : response.status === 401 || response.status === 403 ? `HTTP_${response.status}` : response.status >= 500 ? "SERVER" : `HTTP_${response.status}`;
+	throw new LlmError(message, code, { status: response.status });
+}
+/** List installed models from `GET /v1/models`. */
+async function listModels(baseURL, apiKey, fetchImpl, signal) {
+	const response = await fetchImpl(`${baseURL}/models`, {
+		method: "GET",
+		headers: requestHeaders(apiKey, "application/json"),
+		...signal === void 0 ? {} : { signal }
+	});
+	if (!response.ok) await throwHttpError(response, baseURL);
+	return (await response.json()).data ?? [];
+}
+/** Send a streaming `POST /v1/chat/completions` and return the raw 2xx response. */
+async function postChatCompletions(baseURL, apiKey, body, fetchImpl, signal) {
+	const response = await fetchImpl(`${baseURL}/chat/completions`, {
+		method: "POST",
+		headers: requestHeaders(apiKey, "text/event-stream"),
+		body: JSON.stringify(body),
+		...signal === void 0 ? {} : { signal }
+	});
+	if (!response.ok) await throwHttpError(response, baseURL);
+	return response;
+}
+/**
+* Decode a `ReadableStream<Uint8Array>` into SSE `data:` payload lines. Blank
+* lines and non-`data:` comments are skipped; the `data:` prefix is stripped;
+* the final line is yielded even without a trailing newline. The `[DONE]`
+* sentinel is yielded verbatim so the translator can close the stream.
+* @param body - the response body stream.
+* @returns `data:` payload strings in delivery order (including `[DONE]`).
+*/
+async function* readSseLines(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");
+				if (!line.startsWith("data:")) continue;
+				yield line.slice(5).trimStart();
+			}
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	buffer += decoder.decode();
+	if (buffer.startsWith("data:")) yield buffer.slice(5).trimStart();
+}
+//#endregion
+//#region src/openai-serialize.ts
+/**
+* Serialize harness messages and requests into the OpenAI `/v1/chat/completions`
+* wire vocabulary (spoken by LM Studio, vLLM, and llama.cpp). User text is
+* joined; assistant text becomes `content` (or `null` when the message carries
+* tool calls) and tool calls become `tool_calls` with their raw JSON argument
+* string; tool results become separate `{role: 'tool'}` messages keyed by
+* `tool_call_id`. Image content is rejected loudly — the OpenAI-compatible
+* adapter is text-only (multimodal backends are out of scope for this route).
+* Unknown declaration-merged block types retain the documented extension
+* fallback (ignored for content, retained as text where text is expected).
+* @module dsh-local-ai/openai-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 image content the OpenAI-compatible wire cannot carry. */
+function assertImagesSupported(message) {
+	for (const block of message.content) if (block.type === "image" || block.type === "tool-result" && contentHasImage(block.content)) throw new LlmError("The OpenAI-compatible adapter does not support image content for this backend.", "UNSUPPORTED_CONTENT");
+}
+/** 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) => ({
+		id: String(block.id),
+		type: "function",
+		function: {
+			name: block.name,
+			arguments: block.arguments
+		}
+	}));
+	return {
+		role: "assistant",
+		content: toolCalls.length > 0 ? text.length > 0 ? text : null : text,
+		...toolCalls.length > 0 ? { tool_calls: toolCalls } : {}
+	};
+}
+/**
+* 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).
+* @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 wire = [];
+	for (const message of messages) {
+		assertImagesSupported(message);
+		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) wire.push({
+			role: "tool",
+			tool_call_id: String(result.toolCallId),
+			content: flattenText(result.content) || "(no output)"
+		});
+	}
+	return wire;
+}
+/**
+* Build the full wire request. Always streaming (`stream: true`); optional
+* fields are omitted rather than sent as null, so the backend defaults apply.
+* `temperature` resolves request → model mapping → backend default; `max_tokens`
+* is the harness-materialized `maxTokens`.
+* @param options - the harness request (model, history, system, tools, sampling).
+* @param backend - the resolved OpenAI-compatible backend.
+* @returns the `/v1/chat/completions` request body.
+*/
+function serializeRequest(options, backend) {
+	const mapping = backend.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 ?? backend.temperature;
+	const tools = options.tools?.map((tool) => ({
+		type: "function",
+		function: tool
+	}));
+	return {
+		model,
+		messages,
+		stream: true,
+		...temperature === void 0 ? {} : { temperature },
+		...options.maxTokens === void 0 ? {} : { max_tokens: options.maxTokens },
+		...options.stop !== void 0 && options.stop.length > 0 ? { stop: options.stop } : {},
+		...tools !== void 0 && tools.length > 0 ? { tools } : {}
+	};
+}
+//#endregion
+//#region src/openai-translate.ts
+/**
+* Translate OpenAI-compatible SSE chat chunks into the harness `StreamChunk`
+* protocol. Each `data:` payload carries `choices[].delta` (incremental
+* `content`, `reasoning_content`, and `tool_calls` whose `function.arguments`
+* fragments append directly) plus an eventual `finish_reason` and `usage`.
+* The `[DONE]` sentinel closes the stream; `block-end`, `usage`, and `finish`
+* are deferred until the end, guaranteeing no chunk follows `finish`.
+* @module dsh-local-ai/openai-translate
+*/
+/**
+* Map the OpenAI `finish_reason` vocabulary to the harness FinishReason.
+* @param reason - the wire `finish_reason` string.
+* @returns the mapped reason; unrecognized values become `{kind: 'error'}`.
+*/
+function mapOpenAIFinishReason(reason) {
+	switch (reason) {
+		case "stop": return { kind: "stop" };
+		case "tool_calls":
+		case "function_call": return { kind: "tool-calls" };
+		case "length": return { kind: "max-tokens" };
+		case "content_filter": return {
+			kind: "error",
+			failure: {
+				message: "model stopped: content filter",
+				code: "CONTENT_FILTER"
+			}
+		};
+		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
+		};
+	}
+}
+/**
+* Mint a session-unique tool-call id for a tool-call block that streamed no
+* wire id. Without it the emitted chunks and the persisted tool result carry an
+* empty CallId, and the session fails validation on resume.
+* @param block - the freshly opened tool-call block.
+* @returns the minted id.
+*/
+function mintCallId(block) {
+	return `openai-${Date.now().toString(36)}-${block.index}-${Math.random().toString(36).slice(2, 8)}`;
+}
+/**
+* Consume OpenAI SSE `data:` payload lines and yield StreamChunks. Text and
+* reasoning deltas stream as they arrive; tool-call argument fragments append
+* directly; `block-end`, `usage`, and `finish` are deferred to the `[DONE]`
+* sentinel. A `stop` finish with no opened blocks maps to an `EMPTY_RESPONSE`
+* error finish.
+* @param lines - `data:` payload strings (already prefix-stripped, including `[DONE]`).
+* @returns deltas as they arrive; `block-end`s, `usage`, and `finish` deferred to the end.
+*/
+async function* translateOpenAIStream(lines) {
+	let nextIndex = 0;
+	let textBlock;
+	let reasoningBlock;
+	const toolBlocks = /* @__PURE__ */ new Map();
+	const order = [];
+	let finishReason = null;
+	let usage;
+	function open(kind) {
+		const block = {
+			index: nextIndex++,
+			kind,
+			text: ""
+		};
+		order.push(block);
+		return block;
+	}
+	for await (const data of lines) {
+		if (data === "[DONE]") break;
+		if (data.length === 0) continue;
+		let chunk;
+		try {
+			chunk = JSON.parse(data);
+		} catch {
+			throw new LlmError(`malformed OpenAI SSE payload: ${data.slice(0, 120)}`, "MALFORMED_RESPONSE");
+		}
+		const errorMessage = chunk.error?.message;
+		if (typeof errorMessage === "string" && errorMessage.length > 0) throw new LlmError(errorMessage, "PROVIDER");
+		for (const choice of chunk.choices ?? []) {
+			const delta = choice.delta ?? {};
+			const reasoning = delta.reasoning_content;
+			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 = delta.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
+				};
+			}
+			for (const call of delta.tool_calls ?? []) {
+				const index = call.index ?? 0;
+				let block = toolBlocks.get(index);
+				if (!block) {
+					block = open("tool-call");
+					block.callId = typeof call.id === "string" && call.id.length > 0 ? call.id : mintCallId(block);
+					toolBlocks.set(index, block);
+					yield {
+						type: "block-start",
+						index: block.index,
+						blockType: "tool-call"
+					};
+				} else if (block.callId === void 0 && typeof call.id === "string" && call.id.length > 0) block.callId = call.id;
+				if (block.name === void 0 && typeof call.function?.name === "string" && call.function.name.length > 0) block.name = call.function.name;
+				const fragment = typeof call.function?.arguments === "string" ? call.function.arguments : "";
+				if (fragment.length > 0) {
+					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 (typeof choice.finish_reason === "string" && choice.finish_reason.length > 0) finishReason = choice.finish_reason;
+		}
+		if (chunk.usage !== void 0) usage = {
+			inputTokens: chunk.usage.prompt_tokens ?? 0,
+			outputTokens: chunk.usage.completion_tokens ?? 0
+		};
+	}
+	for (const block of order) yield {
+		type: "block-end",
+		index: block.index,
+		block: closeBlock(block)
+	};
+	if (usage !== void 0) yield {
+		type: "usage",
+		usage
+	};
+	const reason = mapOpenAIFinishReason(finishReason ?? "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
+	};
+}
+//#endregion
+//#region src/openai-adapter.ts
+/**
+* `OpenAICompatibleAdapter`: the harness `LlmAdapter` over an OpenAI-compatible
+* `/v1/chat/completions` streaming endpoint — the common protocol spoken by
+* LM Studio, vLLM, and llama.cpp `--server`. One instance serves one backend;
+* the provider id and wire base URL are resolved per operation through a
+* `() => ResolvedOpenAIBackend` thunk, so a changed URL/model mapping reaches
+* the next request without re-registration. Text-only route: image content
+* fails loud with `UNSUPPORTED_CONTENT` (multimodal backends are out of scope).
+* @module dsh-local-ai/openai-adapter
+*/
+/** Idle-timeout abort code stamped onto a stalled stream's timeout reason. */
+const STREAM_IDLE_TIMEOUT_CODE = "LLM_STREAM_IDLE_TIMEOUT";
+/**
+* The OpenAI-compatible provider adapter. One instance serves one backend
+* (LM Studio / vLLM / llama.cpp); the harness model name maps to the wire model
+* id through the backend's model mapping (identity when unmapped).
+*/
+var OpenAICompatibleAdapter = 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: `OpenAI-compatible (${this.options.config().name})`
+		};
+	}
+	async listModels(provider) {
+		const backend = this.options.config();
+		const models = await listModels(backend.baseURL, backend.apiKey, this.fetchImpl()).catch(() => []);
+		return (models.length > 0 ? models.map((model) => model.id) : backend.models.map((entry) => entry.model)).map((id) => {
+			const name = backend.models.find((entry) => entry.model === id)?.name ?? id;
+			return {
+				provider,
+				id: name,
+				name,
+				inputModalities: ["text"]
+			};
+		});
+	}
+	async resolveModel(provider, model, _signal) {
+		const backend = this.options.config();
+		const mapping = backend.models.find((entry) => entry.name === model);
+		return {
+			provider,
+			id: model,
+			name: model,
+			inputModalities: ["text"],
+			context: { contextWindow: mapping?.contextWindow ?? backend.defaultContextWindow },
+			defaultMaxTokens: mapping?.maxTokens ?? backend.maxTokens
+		};
+	}
+	async *stream(options) {
+		try {
+			var _usingCtx$1 = _usingCtx();
+			const backend = 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, backend.requestTimeoutMs, STREAM_IDLE_TIMEOUT_CODE));
+			const iterator = this.request(options, backend, 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(`OpenAI-compatible stream idle timeout after ${backend.requestTimeoutMs}ms`, "TIMEOUT", { cause: error });
+				if (options.signal?.aborted) throw new LlmError("OpenAI-compatible request aborted by caller", "ABORTED", { cause: error });
+				if (error instanceof LlmError) throw error;
+				throw new LlmError(`OpenAI-compatible API stream from ${sanitizeEndpoint(backend.baseURL)} failed`, "TRANSPORT", { cause: error });
+			} finally {
+				consumer.abort("OpenAI-compatible 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, backend, signal) {
+		const body = serializeRequest(options, backend);
+		let response;
+		try {
+			response = await postChatCompletions(backend.baseURL, backend.apiKey, body, this.fetchImpl(), signal);
+		} catch (error) {
+			if (signal.aborted) throw error;
+			if (error instanceof LlmError) throw error;
+			throw new LlmError(`OpenAI-compatible API request to ${sanitizeEndpoint(backend.baseURL)} failed`, "TRANSPORT", { cause: error });
+		}
+		if (!response.body) throw new LlmError("OpenAI-compatible API returned no response body", "EMPTY_RESPONSE");
+		yield* translateOpenAIStream(readSseLines(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.
+* provider adapter (Ollama or an OpenAI-compatible backend) and, when the
+* local route fails BEFORE producing any visible content, falls back to the
+* cloud (`next()`) so a down local server 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
 */
 /**
@@ -1080,16 +1641,31 @@ function ruleMatches(rule, options) {
 	return false;
 }
 /**
+* Whether a provider id is one of this plugin's local providers. Explicit
+* selection of a local provider (or a prior re-route) must never re-route.
+* @param provider - the request's provider id, or `undefined` for the cloud default.
+* @param resolved - the resolved config.
+* @returns true when the request is already addressed to a local provider.
+*/
+function isLocalProvider(provider, resolved) {
+	if (provider === void 0) return false;
+	if (provider === "ollama") return true;
+	return resolved.backends.some((backend) => backend.providerId === provider);
+}
+/**
 * 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.
+* addressed to a local 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.
+* @returns the local provider + 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 };
+	if (isLocalProvider(options.provider, resolved)) return void 0;
+	for (const rule of resolved.route) if (ruleMatches(rule, options)) return {
+		provider: rule.provider,
+		model: rule.model
+	};
 }
 /**
 * Stream a locally-routed request with automatic cloud fallback. The local
@@ -1106,7 +1682,7 @@ function decideRoute(options, resolved) {
 async function* routeLocal(streamLocal, options, decision, next) {
 	const upstream = streamLocal({
 		...options,
-		provider: OLLAMA_PROVIDER,
+		provider: decision.provider ?? "ollama",
 		model: decision.model
 	});
 	let producedContent = false;
@@ -1235,7 +1811,7 @@ async function checkHealth(baseURL, fetchImpl, subprocess, requestTimeoutMs, gra
 * 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.4";
+const VERSION = "0.2.0";
 //#endregion
 //#region src/index.ts
 const name = "local-ai";
@@ -1315,6 +1891,10 @@ function apply(ctx, config = {}) {
 		resolveAttachments: () => ctx.get("attachments")
 	});
 	ctx.llm.registerAdapter([OLLAMA_PROVIDER], adapter);
+	for (const backend of resolved.backends) ctx.llm.registerAdapter([backend.providerId], new OpenAICompatibleAdapter({
+		config: () => backend,
+		fetchImpl
+	}));
 	ctx.on("llm/stream", (options, next) => {
 		const decision = decideRoute(options, resolved);
 		if (decision === void 0) return next();
@@ -1332,7 +1912,7 @@ function apply(ctx, config = {}) {
 			}]
 		},
 		async execute(_args, exec) {
-			const [models, running] = await Promise.all([listModels(resolved.baseURL, fetchImpl, exec.signal), listRunning(resolved.baseURL, fetchImpl, exec.signal).catch(() => [])]);
+			const [models, running] = await Promise.all([listModels$1(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) => ({
@@ -1451,7 +2031,7 @@ function apply(ctx, config = {}) {
 			lines.push(`- process: ${health.process.present ? "alive" : "not detected"}`);
 			let models = [];
 			try {
-				models = await listModels(resolved.baseURL, fetchImpl);
+				models = await listModels$1(resolved.baseURL, fetchImpl);
 			} catch {}
 			const totalBytes = models.reduce((sum, model) => sum + model.size, 0);
 			lines.push(`- models: ${models.length} installed (${formatBytes(totalBytes)})`);
@@ -1464,7 +2044,7 @@ function apply(ctx, config = {}) {
 			};
 		}
 	});
-	logger.info(`ollama adapter registered at ${resolved.baseURL} (${resolved.models.length} mapping(s), ${resolved.route.length} route rule(s))`);
+	logger.info(`ollama adapter registered at ${resolved.baseURL} (${resolved.models.length} mapping(s), ${resolved.route.length} route rule(s)); ${resolved.backends.length} OpenAI-compatible backend(s): ${resolved.backends.map((backend) => backend.providerId).join(", ") || "none"}`);
 }
 //#endregion
-export { Config, REDACTED, VERSION, apply, formatBytes, inject, name, redactSecrets, renderHealth, renderList, renderOperation, renderShow, resolveConfig, sanitizeEndpoint, sanitizePath, sanitizeText, truncate };
+export { Config, DEFAULT_PROVIDER, OPENAI_PROVIDER_PREFIX, OpenAICompatibleAdapter, REDACTED, VERSION, apply, formatBytes, inject, name, openaiProviderId, redactSecrets, renderHealth, renderList, renderOperation, renderShow, resolveConfig, sanitizeEndpoint, sanitizePath, sanitizeText, truncate };