@valni/cli-darwin-x64 0.0.0-stage → 0.1.3

package/runtime/extensions/switchboard-local/extensions/local/nativeStream.ts

@@ -0,0 +1,602 @@
+import {
+	type Api,
+	type AssistantMessage,
+	type AssistantMessageEventStream,
+	createAssistantMessageEventStream,
+	type Context,
+	type ImageContent,
+	type Message,
+	type Model,
+	parseStreamingJson,
+	type SimpleStreamOptions,
+	type StopReason,
+	type TextContent,
+	type ThinkingContent,
+	type Tool,
+	type ToolCall,
+	type ToolResultMessage,
+} from "@earendil-works/pi-ai";
+import { messages as sdkMessages, native } from "@valni/switchboard";
+
+const SSE_DATA_PREFIX = "data:";
+const COMPLETIONS_PATH = "chat/completions";
+const NON_VISION_USER_IMAGE_PLACEHOLDER = "(image omitted: model does not support images)";
+const NON_VISION_TOOL_IMAGE_PLACEHOLDER = "(tool image omitted: model does not support images)";
+const NO_TOOL_OUTPUT_PLACEHOLDER = "(no tool output)";
+const IMAGE_ONLY_PLACEHOLDER = "(see attached image)";
+const TOOL_IMAGE_PREAMBLE = "Attached image(s) from tool result:";
+
+type KnownApi = "openai-completions";
+type WireObject = Record<string, unknown>;
+type StreamingToolCall = ToolCall & { partialJson?: string };
+
+type StreamingBlock = (TextContent | ThinkingContent | StreamingToolCall) & { index?: number };
+
+interface StreamState {
+	output: AssistantMessage;
+	stream: AssistantMessageEventStream;
+	sawTerminalEvent: boolean;
+}
+
+interface StreamState {
+	output: AssistantMessage;
+	stream: AssistantMessageEventStream;
+	sawTerminalEvent: boolean;
+}
+
+interface OpenAIChatStreamScratch {
+	textIndex: number | null;
+	thinkingIndex: number | null;
+	toolCallsByStreamIndex: Map<number, number>;
+	sawFinishReason: boolean;
+}
+
+export function sanitizeText(text: string): string {
+	return text.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "�");
+}
+
+function replaceImagesWithPlaceholder(content: (TextContent | ImageContent)[], placeholder: string): TextContent[] {
+	const result: TextContent[] = [];
+	let previousWasPlaceholder = false;
+	for (const block of content) {
+		if (block.type === "image") {
+			if (!previousWasPlaceholder) {
+				result.push({ type: "text", text: placeholder });
+			}
+			previousWasPlaceholder = true;
+			continue;
+		}
+		result.push(block);
+		previousWasPlaceholder = block.text === placeholder;
+	}
+	return result;
+}
+
+function downgradeUnsupportedImages(model: Model<KnownApi>, messages: Message[]): Message[] {
+	if (model.input.includes("image")) {
+		return messages;
+	}
+	return messages.map((message) => {
+		if (message.role === "user" && Array.isArray(message.content)) {
+			return {
+				...message,
+				content: replaceImagesWithPlaceholder(message.content, NON_VISION_USER_IMAGE_PLACEHOLDER),
+			};
+		}
+		if (message.role === "toolResult") {
+			return {
+				...message,
+				content: replaceImagesWithPlaceholder(message.content, NON_VISION_TOOL_IMAGE_PLACEHOLDER),
+			};
+		}
+		return message;
+	});
+}
+
+function normalizeToolCallId(api: KnownApi, id: string): string {
+	if (api === "openai-completions") {
+		const callId = id.includes("|") ? id.split("|")[0] : id;
+		return callId.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 40);
+	}
+	const callId = id.includes("|") ? id.split("|")[0] : id;
+	return callId.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
+}
+
+export function normalizeContextMessages(model: Model<KnownApi>, contextMessages: Message[]): Message[] {
+	const toolCallIdMap = new Map<string, string>();
+	const withContent = contextMessages.map((message) =>
+		message.content == null ? ({ ...message, content: [] } as Message) : message,
+	);
+	const imageAware = downgradeUnsupportedImages(model, withContent);
+
+	const transformed: Message[] = [];
+	for (const message of imageAware) {
+		if (message.role === "user") {
+			transformed.push(message);
+			continue;
+		}
+		if (message.role === "toolResult") {
+			const mappedId = toolCallIdMap.get(message.toolCallId);
+			transformed.push(mappedId && mappedId !== message.toolCallId ? { ...message, toolCallId: mappedId } : message);
+			continue;
+		}
+		const assistantMessage = message as AssistantMessage;
+		if (assistantMessage.stopReason === "error" || assistantMessage.stopReason === "aborted") {
+			continue;
+		}
+		const isSameModel =
+			assistantMessage.provider === model.provider &&
+			assistantMessage.api === model.api &&
+			assistantMessage.model === model.id;
+		const content = assistantMessage.content.flatMap((block): (TextContent | ThinkingContent | ToolCall)[] => {
+			if (block.type === "thinking") {
+				if (block.redacted) {
+					return isSameModel ? [block] : [];
+				}
+				if (isSameModel && block.thinkingSignature) return [block];
+				if (!block.thinking || block.thinking.trim() === "") return [];
+				if (isSameModel) return [block];
+				return [{ type: "text" as const, text: block.thinking }];
+			}
+			if (block.type === "toolCall") {
+				let toolCall: ToolCall = block;
+				if (!isSameModel && toolCall.thoughtSignature) {
+					const { thoughtSignature: _thoughtSignature, ...rest } = toolCall;
+					toolCall = rest;
+				}
+				const normalizedId = normalizeToolCallId(model.api, toolCall.id);
+				if (normalizedId !== toolCall.id) {
+					toolCallIdMap.set(toolCall.id, normalizedId);
+					toolCall = { ...toolCall, id: normalizedId };
+				}
+				return [toolCall];
+			}
+			return [block];
+		});
+		transformed.push({ ...assistantMessage, content });
+	}
+
+	const result: Message[] = [];
+	let pendingToolCalls: ToolCall[] = [];
+	let seenToolResultIds = new Set<string>();
+	const flushSyntheticToolResults = (): void => {
+		for (const toolCall of pendingToolCalls) {
+			if (seenToolResultIds.has(toolCall.id)) continue;
+			result.push({
+				role: "toolResult",
+				toolCallId: toolCall.id,
+				toolName: toolCall.name,
+				content: [{ type: "text", text: "No result provided" }],
+				isError: true,
+				timestamp: Date.now(),
+			} as ToolResultMessage);
+		}
+		pendingToolCalls = [];
+		seenToolResultIds = new Set();
+	};
+
+	for (const message of transformed) {
+		if (message.role === "assistant") {
+			flushSyntheticToolResults();
+			const toolCalls = message.content.filter((block): block is ToolCall => block.type === "toolCall");
+			if (toolCalls.length > 0) {
+				pendingToolCalls = toolCalls;
+				seenToolResultIds = new Set();
+			}
+			result.push(message);
+		} else if (message.role === "toolResult") {
+			seenToolResultIds.add(message.toolCallId);
+			result.push(message);
+		} else {
+			flushSyntheticToolResults();
+			result.push(message);
+		}
+	}
+	flushSyntheticToolResults();
+
+	return result;
+}
+
+function resolveMaxTokens(model: Model<KnownApi>, options: SimpleStreamOptions | undefined): number {
+	const requested = options?.maxTokens ?? model.maxTokens;
+	return Math.min(Math.max(1, requested), model.maxTokens);
+}
+
+function toolInputSchema(tool: Tool): Record<string, unknown> {
+	const schema = tool.parameters as { properties?: unknown; required?: string[] };
+	return {
+		type: "object",
+		properties: schema.properties ?? {},
+		required: schema.required ?? [],
+	};
+}
+
+class JsonSchemaTool extends sdkMessages.Tool {
+	private readonly schema: Record<string, unknown>;
+
+	constructor(tool: Tool) {
+		super(tool.name, tool.description, new sdkMessages.ToolParameters({}));
+		this.schema = tool.parameters as unknown as Record<string, unknown>;
+	}
+
+	override toWire(): Record<string, unknown> {
+		return {
+			type: "function",
+			function: {
+				name: this.name,
+				description: this.description,
+				parameters: this.schema,
+			},
+		};
+	}
+}
+
+function chatUserParts(content: (TextContent | ImageContent)[]): sdkMessages.Part[] {
+	const parts: sdkMessages.Part[] = [];
+	for (const item of content) {
+		if (item.type === "text") {
+			if (item.text.trim().length === 0) continue;
+			parts.push(new sdkMessages.TextPart(sanitizeText(item.text)));
+		} else {
+			parts.push(new sdkMessages.ImagePart(new sdkMessages.ImageData(item.mimeType, item.data)));
+		}
+	}
+	return parts;
+}
+
+function buildOpenAIChatRequest(
+	model: Model<KnownApi>,
+	context: Context,
+	options: SimpleStreamOptions | undefined,
+): native.OpenAIChatRequest {
+	const normalized = normalizeContextMessages(model, context.messages);
+	const requestMessages: sdkMessages.Message[] = [];
+
+	if (context.systemPrompt) {
+		requestMessages.push(sdkMessages.Message.system(sanitizeText(context.systemPrompt)));
+	}
+
+	for (let index = 0; index < normalized.length; index++) {
+		const message = normalized[index];
+		if (message.role === "user") {
+			if (typeof message.content === "string") {
+				requestMessages.push(sdkMessages.Message.user(sanitizeText(message.content)));
+			} else {
+				const parts = chatUserParts(message.content);
+				if (parts.length === 0) continue;
+				requestMessages.push(sdkMessages.Message.userParts(parts));
+			}
+		} else if (message.role === "assistant") {
+			const text = message.content
+				.filter((block): block is TextContent => block.type === "text")
+				.map((block) => sanitizeText(block.text))
+				.join("");
+			const toolCalls = message.content
+				.filter((block): block is ToolCall => block.type === "toolCall")
+				.map(
+					(block) =>
+						new sdkMessages.ToolCall(
+							block.id,
+							new sdkMessages.ToolCallFunction(block.name, JSON.stringify(block.arguments ?? {})),
+						),
+				);
+			if (text.length === 0 && toolCalls.length === 0) continue;
+			requestMessages.push(
+				new sdkMessages.Message(sdkMessages.Role.ASSISTANT, text, {
+					toolCalls: toolCalls.length > 0 ? toolCalls : null,
+				}),
+			);
+		} else {
+			const imageParts: sdkMessages.Part[] = [];
+			while (index < normalized.length && normalized[index].role === "toolResult") {
+				const toolResult = normalized[index] as ToolResultMessage;
+				const text = toolResult.content
+					.filter((block): block is TextContent => block.type === "text")
+					.map((block) => block.text)
+					.join("\n");
+				const images = toolResult.content.filter((block): block is ImageContent => block.type === "image");
+				const output =
+					text.length > 0 ? text : images.length > 0 ? IMAGE_ONLY_PLACEHOLDER : NO_TOOL_OUTPUT_PLACEHOLDER;
+				requestMessages.push(sdkMessages.Message.tool(toolResult.toolCallId, sanitizeText(output)));
+				if (model.input.includes("image")) {
+					for (const image of images) {
+						imageParts.push(new sdkMessages.ImagePart(new sdkMessages.ImageData(image.mimeType, image.data)));
+					}
+				}
+				index++;
+			}
+			index--;
+			if (imageParts.length > 0) {
+				requestMessages.push(
+					sdkMessages.Message.userParts([new sdkMessages.TextPart(TOOL_IMAGE_PREAMBLE), ...imageParts]),
+				);
+			}
+		}
+	}
+
+	const reasoningLevel = model.reasoning ? options?.reasoning : undefined;
+	return new native.OpenAIChatRequest({
+		model: model.id,
+		messages: requestMessages,
+		max_tokens: resolveMaxTokens(model, options),
+		temperature: options?.temperature ?? null,
+		tools: context.tools && context.tools.length > 0 ? context.tools.map((tool) => new JsonSchemaTool(tool)) : null,
+		reasoning_effort: reasoningLevel ?? null,
+	});
+}
+
+function emptyUsage(): AssistantMessage["usage"] {
+	return {
+		input: 0,
+		output: 0,
+		cacheRead: 0,
+		cacheWrite: 0,
+		totalTokens: 0,
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+	};
+}
+
+function readInteger(fields: WireObject | null | undefined, key: string): number | null {
+	const value = fields?.[key];
+	return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+
+function finalizeUsageTotals(output: AssistantMessage): void {
+	output.usage.totalTokens =
+		output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
+}
+
+function applyOpenAIUsage(output: AssistantMessage, usage: native.OpenAIUsage): void {
+	const cacheRead = readInteger(usage.prompt_tokens_details, "cached_tokens") ?? 0;
+	const cacheWrite = readInteger(usage.prompt_tokens_details, "cache_write_tokens") ?? 0;
+	output.usage.input = Math.max(0, usage.prompt_tokens - cacheRead - cacheWrite);
+	output.usage.output = usage.completion_tokens;
+	output.usage.cacheRead = cacheRead;
+	output.usage.cacheWrite = cacheWrite;
+	const reasoning = readInteger(usage.completion_tokens_details, "reasoning_tokens");
+	if (reasoning !== null) output.usage.reasoning = reasoning;
+	finalizeUsageTotals(output);
+}
+
+function mapOpenAIFinishReason(reason: string): { stopReason: StopReason; errorMessage?: string } {
+	switch (reason) {
+		case "stop":
+		case "end":
+			return { stopReason: "stop" };
+		case "length":
+			return { stopReason: "length" };
+		case "tool_calls":
+		case "function_call":
+			return { stopReason: "toolUse" };
+		default:
+			return { stopReason: "error", errorMessage: `Provider finish_reason: ${reason}` };
+	}
+}
+
+async function* sseLines(body: ReadableStream<Uint8Array>): AsyncGenerator<string, void, void> {
+	const decoder = new TextDecoder();
+	let buffered = "";
+	for await (const chunk of body) {
+		buffered += decoder.decode(chunk, { stream: true });
+		const lines = buffered.split(/\r\n|\r|\n/);
+		buffered = lines.pop() ?? "";
+		yield* lines;
+	}
+	buffered += decoder.decode();
+	if (buffered.length > 0) {
+		yield buffered;
+	}
+}
+
+function ssePayload(line: string): string | null {
+	if (!line.startsWith(SSE_DATA_PREFIX)) return null;
+	const payload = line.slice(SSE_DATA_PREFIX.length).trim();
+	if (payload.length === 0 || payload === native.DONE_SENTINEL) return null;
+	return payload;
+}
+
+function pushBlockStart(state: StreamState, block: StreamingBlock): number {
+	state.output.content.push(block);
+	const contentIndex = state.output.content.length - 1;
+	if (block.type === "text") {
+		state.stream.push({ type: "text_start", contentIndex, partial: state.output });
+	} else if (block.type === "thinking") {
+		state.stream.push({ type: "thinking_start", contentIndex, partial: state.output });
+	} else {
+		state.stream.push({ type: "toolcall_start", contentIndex, partial: state.output });
+	}
+	return contentIndex;
+}
+
+function pushBlockEnd(state: StreamState, block: StreamingBlock, contentIndex: number): void {
+	if (block.type === "text") {
+		state.stream.push({ type: "text_end", contentIndex, content: block.text, partial: state.output });
+	} else if (block.type === "thinking") {
+		state.stream.push({ type: "thinking_end", contentIndex, content: block.thinking, partial: state.output });
+	} else {
+		block.arguments = parseStreamingJson(block.partialJson);
+		delete block.partialJson;
+		delete block.index;
+		state.stream.push({ type: "toolcall_end", contentIndex, toolCall: block, partial: state.output });
+	}
+}
+
+function handleOpenAIChatChunk(
+	state: StreamState,
+	scratch: OpenAIChatStreamScratch,
+	chunk: native.OpenAIChatChunk,
+): void {
+	const { output, stream } = state;
+	const blocks = output.content as StreamingBlock[];
+
+	output.responseId ||= chunk.id;
+	if (chunk.model.length > 0 && chunk.model !== output.model) {
+		output.responseModel ||= chunk.model;
+	}
+	if (chunk.usage) {
+		applyOpenAIUsage(output, chunk.usage);
+	}
+
+	const choice = chunk.choices[0];
+	if (!choice) return;
+
+	if (choice.finish_reason) {
+		const mapped = mapOpenAIFinishReason(choice.finish_reason);
+		output.stopReason = mapped.stopReason;
+		if (mapped.errorMessage) output.errorMessage = mapped.errorMessage;
+		scratch.sawFinishReason = true;
+	}
+
+	const delta = choice.delta;
+	const content = delta.content;
+	if (typeof content === "string" && content.length > 0) {
+		if (scratch.textIndex === null) {
+			scratch.textIndex = pushBlockStart(state, { type: "text", text: "" });
+		}
+		const block = blocks[scratch.textIndex] as TextContent;
+		block.text += content;
+		stream.push({ type: "text_delta", contentIndex: scratch.textIndex, delta: content, partial: output });
+	}
+
+	for (const field of ["reasoning_content", "reasoning", "reasoning_text"]) {
+		const reasoningDelta = delta[field];
+		if (typeof reasoningDelta === "string" && reasoningDelta.length > 0) {
+			if (scratch.thinkingIndex === null) {
+				scratch.thinkingIndex = pushBlockStart(state, { type: "thinking", thinking: "" });
+			}
+			const block = blocks[scratch.thinkingIndex] as ThinkingContent;
+			block.thinking += reasoningDelta;
+			stream.push({
+				type: "thinking_delta",
+				contentIndex: scratch.thinkingIndex,
+				delta: reasoningDelta,
+				partial: output,
+			});
+			break;
+		}
+	}
+
+	const toolCalls = delta.tool_calls;
+	if (Array.isArray(toolCalls)) {
+		for (const rawToolCall of toolCalls) {
+			if (rawToolCall === null || typeof rawToolCall !== "object") continue;
+			const toolCallWire = rawToolCall as WireObject;
+			const streamIndex = typeof toolCallWire.index === "number" ? toolCallWire.index : 0;
+			let contentIndex = scratch.toolCallsByStreamIndex.get(streamIndex);
+			if (contentIndex === undefined) {
+				contentIndex = pushBlockStart(state, {
+					type: "toolCall",
+					id: typeof toolCallWire.id === "string" ? toolCallWire.id : "",
+					name: "",
+					arguments: {},
+					partialJson: "",
+				});
+				scratch.toolCallsByStreamIndex.set(streamIndex, contentIndex);
+			}
+			const block = blocks[contentIndex] as StreamingToolCall;
+			if (!block.id && typeof toolCallWire.id === "string") {
+				block.id = toolCallWire.id;
+			}
+			const functionWire = (toolCallWire.function ?? null) as WireObject | null;
+			if (functionWire) {
+				if (!block.name && typeof functionWire.name === "string") {
+					block.name = functionWire.name;
+				}
+				let deltaText = "";
+				if (typeof functionWire.arguments === "string" && functionWire.arguments.length > 0) {
+					deltaText = functionWire.arguments;
+					block.partialJson = (block.partialJson ?? "") + deltaText;
+					block.arguments = parseStreamingJson(block.partialJson);
+				}
+				stream.push({ type: "toolcall_delta", contentIndex, delta: deltaText, partial: output });
+			}
+		}
+	}
+}
+
+function completionsUrl(baseUrl: string): string {
+	return `${baseUrl.replace(/\/+$/u, "")}/${COMPLETIONS_PATH}`;
+}
+
+export function streamLocalModel(
+	model: Model<Api>,
+	context: Context,
+	options?: SimpleStreamOptions,
+): AssistantMessageEventStream {
+	const stream = createAssistantMessageEventStream();
+
+	(async () => {
+		const output: AssistantMessage = {
+			role: "assistant",
+			content: [],
+			api: model.api,
+			provider: model.provider,
+			model: model.id,
+			usage: emptyUsage(),
+			stopReason: "stop",
+			timestamp: Date.now(),
+		};
+		const state: StreamState = { output, stream, sawTerminalEvent: false };
+
+		try {
+			const request = buildOpenAIChatRequest(model as Model<KnownApi>, context, options).streaming();
+			const headers: Record<string, string> = { "content-type": "application/json", ...model.headers };
+			if (options?.apiKey) headers.authorization = `Bearer ${options.apiKey}`;
+
+			const response = await fetch(completionsUrl(model.baseUrl), {
+				method: "POST",
+				headers,
+				body: JSON.stringify(request.toWire()),
+				signal: options?.signal,
+			});
+			if (!response.ok) {
+				const detail = (await response.text().catch(() => "")).trim().slice(0, 500);
+				throw new Error(`${model.baseUrl} returned HTTP ${response.status}${detail ? `: ${detail}` : ""}`);
+			}
+			if (response.body === null) throw new Error(`${model.baseUrl} returned no response body`);
+
+			stream.push({ type: "start", partial: output });
+
+			const scratch: OpenAIChatStreamScratch = {
+				textIndex: null,
+				thinkingIndex: null,
+				toolCallsByStreamIndex: new Map(),
+				sawFinishReason: false,
+			};
+
+			for await (const line of sseLines(response.body)) {
+				const payload = ssePayload(line);
+				if (payload === null) continue;
+				const chunk = native.OpenAIChatChunk.fromWire(JSON.parse(payload));
+				if (chunk === null) continue;
+				handleOpenAIChatChunk(state, scratch, chunk);
+				if (scratch.sawFinishReason) state.sawTerminalEvent = true;
+			}
+
+			const blocks = output.content as StreamingBlock[];
+			for (let contentIndex = 0; contentIndex < blocks.length; contentIndex++) {
+				pushBlockEnd(state, blocks[contentIndex], contentIndex);
+			}
+
+			if (options?.signal?.aborted) throw new Error("Request was aborted");
+			if (output.stopReason === "aborted" || output.stopReason === "error") {
+				throw new Error(output.errorMessage || "An unknown error occurred");
+			}
+			if (!state.sawTerminalEvent) throw new Error("The stream ended before a terminal event");
+
+			stream.push({ type: "done", reason: output.stopReason, message: output });
+			stream.end();
+		} catch (error) {
+			for (const block of output.content) {
+				delete (block as { index?: number }).index;
+				delete (block as { partialJson?: string }).partialJson;
+			}
+			output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+			output.errorMessage = error instanceof Error ? error.message : String(error);
+			stream.push({ type: "error", reason: output.stopReason, error: output });
+			stream.end();
+		}
+	})();
+
+	return stream;
+}

package/runtime/extensions/switchboard-local/extensions/local/paths.ts

@@ -0,0 +1,44 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export const MANAGED_DIR_NAME = ".switchboard-local";
+
+export function managedDir(): string {
+	return join(homedir(), MANAGED_DIR_NAME);
+}
+
+export function stateFile(): string {
+	return join(managedDir(), "state.json");
+}
+
+export function mlxVenvDir(): string {
+	return join(managedDir(), "mlx-venv");
+}
+
+export function mlxVenvBin(executable: string): string {
+	return join(mlxVenvDir(), "bin", executable);
+}
+
+export function llamaDir(): string {
+	return join(managedDir(), "llama");
+}
+
+export function llamaBinDir(): string {
+	return join(llamaDir(), "bin");
+}
+
+export function llamaModelsDir(): string {
+	return join(llamaDir(), "models");
+}
+
+export function huggingFaceCacheDir(): string {
+	const explicit = process.env.HF_HOME?.trim();
+	if (explicit) return join(explicit, "hub");
+	const xdg = process.env.XDG_CACHE_HOME?.trim();
+	if (xdg) return join(xdg, "huggingface", "hub");
+	return join(homedir(), ".cache", "huggingface", "hub");
+}
+
+export function repoCacheDir(repoId: string): string {
+	return join(huggingFaceCacheDir(), `models--${repoId.replace(/\//gu, "--")}`);
+}

package/runtime/extensions/switchboard-local/extensions/local/provider.ts

@@ -0,0 +1,57 @@
+import type { LocalModelInfo } from "./engine.ts";
+
+export const PROVIDER_ID = "switchboard-local";
+export const PROVIDER_NAME = "Switchboard Local";
+
+const MAX_TOKENS_CEILING = 16_384;
+const FREE = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 } as const;
+
+export interface LocalModelConfig {
+	id: string;
+	name: string;
+	api: "openai-completions";
+	baseUrl: string;
+	reasoning: boolean;
+	input: ("text" | "image")[];
+	cost: typeof FREE;
+	contextWindow: number;
+	maxTokens: number;
+	compat: {
+		supportsStore: false;
+		supportsDeveloperRole: false;
+		supportsReasoningEffort: false;
+		supportsUsageInStreaming: true;
+		supportsStrictMode: false;
+		maxTokensField: "max_tokens";
+	};
+}
+
+export function displayName(repoId: string): string {
+	return `${repoId.split("/").at(-1) ?? repoId} (local)`;
+}
+
+export function toModelConfig(model: LocalModelInfo): LocalModelConfig {
+	return {
+		id: model.id,
+		name: displayName(model.id),
+		api: "openai-completions",
+		baseUrl: model.baseUrl,
+		reasoning: false,
+		input: model.vision === true ? ["text", "image"] : ["text"],
+		cost: FREE,
+		contextWindow: model.contextWindow,
+		maxTokens: Math.min(MAX_TOKENS_CEILING, model.contextWindow),
+		compat: {
+			supportsStore: false,
+			supportsDeveloperRole: false,
+			supportsReasoningEffort: false,
+			supportsUsageInStreaming: true,
+			supportsStrictMode: false,
+			maxTokensField: "max_tokens",
+		},
+	};
+}
+
+export function toModelConfigs(models: readonly LocalModelInfo[]): LocalModelConfig[] {
+	return models.map(toModelConfig);
+}