@morlay/dsh-llm-openai-compatible 0.0.1 → 0.0.2

package/dist/index.mjs

@@ -0,0 +1,895 @@
+import z from "@deepseek-ai/schemastery";
+import { CONTEXT_WINDOW_EXCEEDED_CODE, EMPTY_RESPONSE_CODE, LlmAdapter, LlmError, ProviderRequestId, QUOTA_EXCEEDED_CODE, ReasoningEffortId, RetryPolicySchema, ToolCallId, assertUsableApiKey, attributionHeaders, contentHasImage, isContextWindowExceededError, isQuotaExceededError, offloadRequestImagesWithPolicy, resolveRetryPolicy, textOnlyImageText } from "@deepseek-ai/dsh-llm";
+import { credentialRef } from "@deepseek-ai/dsh-credentials";
+import { launchEnvironmentOf } from "@deepseek-ai/dsh-launch-environment";
+import { deepEqualJson } from "@deepseek-ai/dsh-util-values";
+import { MAX_TIMER_DELAY_MS, deadline, idleWatchdog, timeoutOf } from "@deepseek-ai/dsh-timeout";
+import { getOrCreateAnonymousUserId } from "@deepseek-ai/dsh-anonymous-user-id";
+import { APICallError } from "@ai-sdk/provider";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { AttachmentError } from "@deepseek-ai/dsh-attachment";
+import { Buffer } from "node:buffer";
+//#region src/serialize.ts
+const TOOL_RESULT_IMAGE_TEXT = "Attached image(s) from tool result:";
+function resolveReasoningWire(model, effort) {
+	if (effort === void 0) return void 0;
+	const declaration = model?.reasoningEfforts;
+	if (declaration === void 0 || declaration === false) {
+		const subject = model === void 0 ? "unlisted model" : `model "${model.id}"`;
+		throw new LlmError(`OpenAI-compatible ${subject} declares no reasoning efforts, so "${effort}" cannot be selected`, "UNSUPPORTED_REASONING_EFFORT");
+	}
+	const wire = declaration[effort];
+	if (wire === void 0) throw new LlmError(`OpenAI-compatible model "${model.id}" does not support reasoning effort "${effort}"`, "UNSUPPORTED_REASONING_EFFORT");
+	if (wire === null) return void 0;
+	return wire;
+}
+function flattenText(blocks) {
+	return blocks.filter((block) => block.type === "text").map((block) => block.text).join("");
+}
+function assertTextOnly(blocks) {
+	if (contentHasImage(blocks)) throw new LlmError("The OpenAI-compatible chat-completions adapter does not support image content in this message.", "UNSUPPORTED_CONTENT");
+}
+function assertSupportedImageRoles(messages) {
+	for (const message of messages) if (message.role !== "user" && contentHasImage(message.content)) throw new LlmError(`The OpenAI-compatible chat-completions adapter cannot represent image content in a ${message.role} message.`, "UNSUPPORTED_CONTENT");
+}
+async function imagePart(block, attachments, signal) {
+	try {
+		const stored = await attachments.readImage(block.attachment, signal);
+		return {
+			type: "file",
+			mediaType: stored.ref.mediaType,
+			data: {
+				type: "url",
+				url: new URL(`data:${stored.ref.mediaType};base64,${Buffer.from(stored.data).toString("base64")}`)
+			}
+		};
+	} catch (error) {
+		if (error instanceof AttachmentError) throw new LlmError(error.message, error.code, { cause: error });
+		throw error;
+	}
+}
+function assistantParts(message, toolNames) {
+	const parts = [];
+	for (const block of message.content) switch (block.type) {
+		case "text":
+			if (block.text.length > 0) parts.push({
+				type: "text",
+				text: block.text
+			});
+			break;
+		case "reasoning":
+			if (block.text.length > 0) parts.push({
+				type: "reasoning",
+				text: block.text
+			});
+			break;
+		case "tool-call": {
+			let input;
+			try {
+				input = JSON.parse(block.arguments);
+			} catch {
+				throw new LlmError(`assistant tool call "${block.id}" carries malformed JSON arguments`, "MALFORMED_RESPONSE");
+			}
+			parts.push({
+				type: "tool-call",
+				toolCallId: block.id,
+				toolName: block.name,
+				input
+			});
+			toolNames.set(block.id, block.name);
+			break;
+		}
+	}
+	return parts;
+}
+async function userParts(blocks, resolveImage, signal) {
+	const parts = [];
+	for (const block of blocks) switch (block.type) {
+		case "text":
+			if (block.text.length > 0) parts.push({
+				type: "text",
+				text: block.text
+			});
+			break;
+		case "image":
+			if (resolveImage === void 0) throw new LlmError("The OpenAI-compatible chat-completions adapter does not support image content in this message.", "UNSUPPORTED_CONTENT");
+			parts.push(await resolveImage(block, signal));
+			break;
+		case "tool-result": parts.push(...await userParts(block.content, resolveImage, signal));
+	}
+	return parts;
+}
+async function serializePrompt(messages, resolveImage, signal) {
+	if (resolveImage === void 0) for (const message of messages) assertTextOnly(message.content);
+	else assertSupportedImageRoles(messages);
+	const prompt = [];
+	const toolNames = /* @__PURE__ */ new Map();
+	let pendingToolImages = [];
+	const flushToolImages = () => {
+		if (pendingToolImages.length === 0) return;
+		prompt.push({
+			role: "user",
+			content: [{
+				type: "text",
+				text: TOOL_RESULT_IMAGE_TEXT
+			}, ...pendingToolImages]
+		});
+		pendingToolImages = [];
+	};
+	for (const message of messages) {
+		if (message.role === "system") {
+			flushToolImages();
+			prompt.push({
+				role: "system",
+				content: flattenText(message.content)
+			});
+			continue;
+		}
+		if (message.role === "assistant") {
+			flushToolImages();
+			const parts = assistantParts(message, toolNames);
+			if (parts.length > 0) prompt.push({
+				role: "assistant",
+				content: parts
+			});
+			continue;
+		}
+		const regular = message.content.filter((block) => block.type !== "tool-result");
+		const toolResults = message.content.filter((block) => block.type === "tool-result");
+		const content = await userParts(regular, resolveImage, signal);
+		if (content.length > 0 || toolResults.length === 0) {
+			flushToolImages();
+			prompt.push({
+				role: "user",
+				content
+			});
+		}
+		for (const result of toolResults) {
+			const images = [];
+			if (resolveImage !== void 0) {
+				for (const block of result.content) if (block.type === "image") images.push(await resolveImage(block, signal));
+			}
+			prompt.push({
+				role: "tool",
+				content: [{
+					type: "tool-result",
+					toolCallId: result.toolCallId,
+					toolName: toolNames.get(result.toolCallId) ?? "",
+					output: {
+						type: "text",
+						value: flattenText(result.content) || (images.length > 0 ? "(see attached image)" : "(no output)")
+					}
+				}]
+			});
+			pendingToolImages.push(...images);
+		}
+	}
+	flushToolImages();
+	return prompt;
+}
+function serializeTools(options) {
+	const tools = options.tools?.map((tool) => ({
+		type: "function",
+		name: tool.name,
+		description: tool.description,
+		inputSchema: tool.parameters
+	}));
+	return tools !== void 0 && tools.length > 0 ? tools : void 0;
+}
+function callOptionsWithPrompt(options, profile, model, prompt) {
+	const tools = serializeTools(options);
+	const temperature = options.temperature ?? profile.temperature;
+	const maxOutputTokens = options.maxTokens ?? model?.maxTokens ?? profile.defaultMaxTokens;
+	const reasoningEffort = resolveReasoningWire(model, options.reasoningEffort === void 0 ? profile.reasoning : options.reasoningEffort);
+	const providerOptions = { "openai-compatible": {
+		...reasoningEffort === void 0 ? {} : { reasoningEffort },
+		...profile.topK === void 0 ? {} : { top_k: profile.topK }
+	} };
+	return {
+		prompt,
+		...temperature !== void 0 ? { temperature } : {},
+		...profile.topP !== void 0 ? { topP: profile.topP } : {},
+		...profile.presencePenalty !== void 0 ? { presencePenalty: profile.presencePenalty } : {},
+		...profile.frequencyPenalty !== void 0 ? { frequencyPenalty: profile.frequencyPenalty } : {},
+		...profile.seed !== void 0 ? { seed: profile.seed } : {},
+		...maxOutputTokens !== void 0 ? { maxOutputTokens } : {},
+		...options.stop !== void 0 ? { stopSequences: options.stop } : {},
+		...tools !== void 0 ? { tools } : {},
+		...Object.keys(providerOptions["openai-compatible"] ?? {}).length > 0 ? { providerOptions } : {}
+	};
+}
+async function serializeCallOptions(options, profile, model) {
+	const system = options.system === void 0 ? [] : [{
+		role: "system",
+		content: options.system
+	}];
+	const prompt = await serializePrompt(options.messages, void 0);
+	return callOptionsWithPrompt(options, profile, model, [...system, ...prompt]);
+}
+async function serializeCallOptionsWithImages(options, profile, model, images) {
+	const requestMessages = offloadRequestImagesWithPolicy(options.messages, {
+		representation: "raw",
+		maxBytes: images.maxRequestImageBytes,
+		placeholder: (ref) => textOnlyImageText(ref)
+	});
+	const resolveImage = (block, signal) => imagePart(block, images.attachments, signal);
+	const system = options.system === void 0 ? [] : [{
+		role: "system",
+		content: options.system
+	}];
+	const prompt = await serializePrompt(requestMessages, resolveImage, images.signal);
+	return callOptionsWithPrompt(options, profile, model, [...system, ...prompt]);
+}
+//#endregion
+//#region src/translate.ts
+function mapFinishReason(reason) {
+	switch (reason.unified) {
+		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.raw ?? reason.unified}`,
+				code: (reason.raw ?? reason.unified).toUpperCase()
+			}
+		};
+	}
+}
+function mapUsage(usage) {
+	const cacheRead = usage.inputTokens.cacheRead;
+	const reasoning = usage.outputTokens.reasoning;
+	return {
+		inputTokens: usage.inputTokens.noCache ?? usage.inputTokens.total ?? 0,
+		outputTokens: usage.outputTokens.total ?? 0,
+		...cacheRead !== void 0 && cacheRead > 0 ? { cacheReadTokens: cacheRead } : {},
+		...reasoning !== void 0 && reasoning > 0 ? { reasoningTokens: reasoning } : {}
+	};
+}
+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: ToolCallId(block.callId ?? ""),
+			name: block.name ?? "",
+			arguments: block.text
+		};
+	}
+}
+async function* translate(stream) {
+	let nextIndex = 0;
+	const textBlocks = /* @__PURE__ */ new Map();
+	const reasoningBlocks = /* @__PURE__ */ new Map();
+	const toolBlocks = /* @__PURE__ */ new Map();
+	const toolQueue = [];
+	const order = [];
+	let pendingUsage;
+	let pendingFinish;
+	const open = (kind) => {
+		const block = {
+			index: nextIndex++,
+			kind,
+			text: ""
+		};
+		order.push(block);
+		return block;
+	};
+	for await (const part of stream) switch (part.type) {
+		case "stream-start":
+		case "response-metadata":
+		case "raw": break;
+		case "text-start": {
+			const block = open("text");
+			textBlocks.set(part.id, block);
+			yield {
+				type: "block-start",
+				index: block.index,
+				blockType: "text"
+			};
+			break;
+		}
+		case "text-delta": {
+			const block = textBlocks.get(part.id);
+			if (block === void 0) break;
+			block.text += part.delta;
+			yield {
+				type: "text-delta",
+				index: block.index,
+				text: part.delta
+			};
+			break;
+		}
+		case "text-end": break;
+		case "reasoning-start": {
+			const block = open("reasoning");
+			reasoningBlocks.set(part.id, block);
+			yield {
+				type: "block-start",
+				index: block.index,
+				blockType: "reasoning"
+			};
+			break;
+		}
+		case "reasoning-delta": {
+			const block = reasoningBlocks.get(part.id);
+			if (block === void 0) break;
+			block.text += part.delta;
+			yield {
+				type: "reasoning-delta",
+				index: block.index,
+				text: part.delta
+			};
+			break;
+		}
+		case "reasoning-end": break;
+		case "tool-input-start": {
+			const block = open("tool-call");
+			if (part.toolName !== void 0) block.name = part.toolName;
+			toolBlocks.set(part.id, block);
+			toolQueue.push(block);
+			yield {
+				type: "block-start",
+				index: block.index,
+				blockType: "tool-call"
+			};
+			break;
+		}
+		case "tool-input-delta": {
+			const block = toolBlocks.get(part.id);
+			if (block === void 0) break;
+			block.text += part.delta;
+			yield {
+				type: "tool-call-delta",
+				index: block.index,
+				id: ToolCallId(block.callId ?? part.id),
+				...block.name !== void 0 ? { name: block.name } : {},
+				argumentsDelta: part.delta
+			};
+			break;
+		}
+		case "tool-input-end": break;
+		case "tool-call":
+			applyToolCall(part, toolQueue);
+			break;
+		case "tool-result":
+		case "tool-approval-request":
+		case "custom":
+		case "file":
+		case "reasoning-file":
+		case "source": break;
+		case "finish":
+			pendingUsage = mapUsage(part.usage);
+			pendingFinish = mapFinishReason(part.finishReason);
+			for (const block of order) yield {
+				type: "block-end",
+				index: block.index,
+				block: closeBlock(block)
+			};
+			if (pendingUsage !== void 0) yield {
+				type: "usage",
+				usage: pendingUsage
+			};
+			const reason = pendingFinish ?? { kind: "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;
+		case "error": {
+			const error = part.error;
+			const cause = error instanceof Error ? error : void 0;
+			const message = cause?.message ?? (typeof error === "string" ? error : "provider stream error");
+			throw new LlmError(`OpenAI-compatible stream failed: ${message}`, "TRANSPORT", { cause });
+		}
+	}
+	throw new LlmError("AI SDK stream ended without a finish part", "STREAM_CLOSED");
+}
+function applyToolCall(part, toolQueue) {
+	const block = toolQueue.shift();
+	if (block === void 0) return;
+	block.callId = part.toolCallId;
+	block.name = part.toolName;
+	block.text = part.input;
+}
+//#endregion
+//#region src/adapter.ts
+const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 3e5;
+const DEFAULT_CONTEXT_WINDOW = 262144;
+const DEFAULT_MAX_TOKENS = 32768;
+const DEFAULT_MAX_REQUEST_IMAGE_BYTES = 20971520;
+const STREAM_IDLE_TIMEOUT_CODE = "LLM_STREAM_IDLE_TIMEOUT";
+const REQUEST_TIMEOUT_CODE = "LLM_REQUEST_TIMEOUT";
+const PROVIDER_OPTIONS_KEY = "openai-compatible";
+function convertUsage(usage) {
+	if (usage == null) return {
+		inputTokens: {
+			total: 0,
+			noCache: 0,
+			cacheRead: void 0,
+			cacheWrite: void 0
+		},
+		outputTokens: {
+			total: 0,
+			text: void 0,
+			reasoning: void 0
+		}
+	};
+	const promptTokens = usage.prompt_tokens ?? 0;
+	const completionTokens = usage.completion_tokens ?? 0;
+	const cacheRead = usage.prompt_tokens_details?.cached_tokens ?? usage.prompt_cache_hit_tokens ?? 0;
+	const reasoningTokens = usage.completion_tokens_details?.reasoning_tokens ?? 0;
+	return {
+		inputTokens: {
+			total: promptTokens,
+			noCache: Math.max(0, promptTokens - cacheRead),
+			cacheRead,
+			cacheWrite: void 0
+		},
+		outputTokens: {
+			total: completionTokens,
+			text: Math.max(0, completionTokens - reasoningTokens),
+			reasoning: reasoningTokens
+		}
+	};
+}
+function modelInfo(profile, model) {
+	return {
+		provider: profile.provider,
+		id: model.id,
+		name: model.name ?? model.id,
+		...model.description === void 0 ? {} : { description: model.description },
+		inputModalities: [...model.inputModalities]
+	};
+}
+function reasoningInfo(model, defaultEffort) {
+	const declaration = model?.reasoningEfforts;
+	if (declaration === void 0 || declaration === false) return {};
+	return { reasoning: {
+		efforts: Object.entries(declaration).map(([id]) => ({
+			id: ReasoningEffortId(id),
+			name: `${id.charAt(0).toUpperCase()}${id.slice(1)}`
+		})),
+		...defaultEffort !== void 0 && declaration[defaultEffort] !== void 0 ? { defaultEffort: ReasoningEffortId(defaultEffort) } : {}
+	} };
+}
+function httpErrorCode(status, error) {
+	if (status === 401 || status === 403) return "AUTH";
+	if (status === 413) return "INVALID_REQUEST";
+	const detail = [
+		error?.code,
+		error?.type,
+		error?.message
+	].filter(Boolean).join(" ");
+	if (isQuotaExceededError(detail)) return QUOTA_EXCEEDED_CODE;
+	if (status === 429) return "RATE_LIMIT";
+	if (status === 400) {
+		if (isContextWindowExceededError(detail)) return CONTEXT_WINDOW_EXCEEDED_CODE;
+		return "INVALID_REQUEST";
+	}
+	if (status >= 500) return "SERVER";
+	return `HTTP_${status}`;
+}
+function providerErrorBody(error) {
+	if (error.responseBody === void 0) return void 0;
+	try {
+		return JSON.parse(error.responseBody).error;
+	} catch {
+		return;
+	}
+}
+function requestId(headers) {
+	if (headers === void 0) return void 0;
+	const value = headers["x-request-id"] ?? headers["x-openai-compatible-request-id"];
+	return value === void 0 || value.length === 0 ? void 0 : ProviderRequestId(value);
+}
+var OpenAICompatibleAdapter = class extends LlmAdapter {
+	config;
+	sdkProviders = /* @__PURE__ */ new Map();
+	constructor(config) {
+		super();
+		this.config = config;
+	}
+	profileOf(provider) {
+		const profile = this.config.profiles().get(provider);
+		if (profile === void 0) throw new LlmError(`OpenAI-compatible adapter does not own provider "${provider}"`, "NO_ADAPTER");
+		return profile;
+	}
+	modelOf(profile, model) {
+		return profile.models.find((entry) => entry.id === model);
+	}
+	sdkModel(profile, modelId) {
+		let byModel = this.sdkProviders.get(profile);
+		if (byModel === void 0) {
+			byModel = /* @__PURE__ */ new Map();
+			this.sdkProviders.set(profile, byModel);
+		}
+		let model = byModel.get(modelId);
+		if (model === void 0) {
+			model = createOpenAICompatible({
+				name: PROVIDER_OPTIONS_KEY,
+				baseURL: profile.baseURL,
+				headers: {
+					...profile.headers,
+					...attributionHeaders()
+				},
+				includeUsage: true,
+				convertUsage
+			}).chatModel(modelId);
+			byModel.set(modelId, model);
+		}
+		return model;
+	}
+	providerInfo(provider) {
+		return {
+			id: provider,
+			name: this.config.profiles().get(provider)?.displayName ?? provider
+		};
+	}
+	providerRetryPolicy(provider) {
+		return this.config.profiles().get(provider)?.retryPolicy;
+	}
+	listModels(provider) {
+		const profile = this.profileOf(provider);
+		return Promise.resolve(profile.models.map((model) => modelInfo(profile, model)));
+	}
+	resolveModel(provider, model, _signal) {
+		const profile = this.profileOf(provider);
+		const configured = this.modelOf(profile, model);
+		const contextWindow = configured?.contextWindow ?? profile.defaultContextWindow;
+		const maxTokens = configured?.maxTokens ?? profile.defaultMaxTokens;
+		return Promise.resolve({
+			...configured === void 0 ? {
+				provider,
+				id: model,
+				name: model,
+				inputModalities: ["text"]
+			} : modelInfo(profile, configured),
+			context: { contextWindow },
+			...maxTokens !== void 0 ? { defaultMaxTokens: maxTokens } : {},
+			...reasoningInfo(configured, profile.reasoning)
+		});
+	}
+	async *stream(options) {
+		const profile = this.profileOf(options.provider);
+		const model = this.modelOf(profile, options.model);
+		const hasImages = options.messages.some((message) => contentHasImage(message.content));
+		let attachments;
+		if (hasImages) {
+			if (model?.inputModalities.includes("image") !== true) throw new LlmError(`OpenAI-compatible model "${options.model}" does not accept image input.`, "UNSUPPORTED_CONTENT");
+			attachments = this.config.resolveAttachments?.();
+			if (attachments === void 0) throw new LlmError("OpenAI-compatible image conversion requires the durable attachment service.", "UNSUPPORTED_CONTENT");
+		}
+		const apiKey = await this.config.resolveApiKey(options.provider, profile);
+		const userId = this.config.resolveUserId();
+		const consumer = new AbortController();
+		const upstream = options.signal === void 0 ? consumer.signal : AbortSignal.any([options.signal, consumer.signal]);
+		const overall = profile.timeoutMs === void 0 ? void 0 : deadline(upstream, profile.timeoutMs, REQUEST_TIMEOUT_CODE);
+		const watchdog = idleWatchdog(overall?.signal ?? upstream, profile.streamIdleTimeoutMs, STREAM_IDLE_TIMEOUT_CODE);
+		try {
+			const callOptions = attachments === void 0 ? await serializeCallOptions(options, profile, model) : await serializeCallOptionsWithImages(options, profile, model, {
+				attachments,
+				maxRequestImageBytes: profile.maxRequestImageBytes,
+				signal: watchdog.signal
+			});
+			const sdkModel = this.sdkModel(profile, options.model);
+			let result;
+			try {
+				result = await sdkModel.doStream({
+					...callOptions,
+					abortSignal: watchdog.signal,
+					headers: {
+						...apiKey === void 0 ? {} : { authorization: `Bearer ${apiKey}` },
+						"x-openai-compatible-harness-user-id": String(userId),
+						...options.sessionId !== void 0 ? { "x-openai-compatible-harness-session-id": String(options.sessionId) } : {},
+						...options.purpose === "compaction" ? { "x-openai-compatible-harness-compact": "1" } : {}
+					}
+				});
+			} catch (error) {
+				throw this.normalizeTransportError(error, profile);
+			}
+			const iterator = translate(result.stream)[Symbol.asyncIterator]();
+			let exhausted = false;
+			try {
+				while (true) {
+					const next = await watchdog.next(iterator);
+					if (next.done) {
+						exhausted = true;
+						return;
+					}
+					yield next.value;
+				}
+			} catch (error) {
+				if (timeoutOf(watchdog.signal, "LLM_STREAM_IDLE_TIMEOUT") !== void 0) throw new LlmError(`OpenAI-compatible stream idle timeout after ${profile.streamIdleTimeoutMs}ms`, "TIMEOUT", { cause: error });
+				if (profile.timeoutMs !== void 0 && timeoutOf(watchdog.signal, "LLM_REQUEST_TIMEOUT") !== void 0) throw new LlmError(`OpenAI-compatible request timeout after ${profile.timeoutMs}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 this.normalizeTransportError(error, profile);
+			} finally {
+				consumer.abort("OpenAI-compatible stream consumer stopped");
+				if (!exhausted) try {
+					await iterator.return(void 0);
+				} catch {}
+			}
+		} finally {
+			watchdog[Symbol.dispose]();
+			overall?.[Symbol.dispose]();
+		}
+	}
+	normalizeTransportError(error, profile) {
+		if (error instanceof LlmError) return error;
+		if (APICallError.isInstance(error)) {
+			const providerError = providerErrorBody(error);
+			const message = typeof providerError?.message === "string" ? providerError.message : error.message;
+			const id = requestId(error.responseHeaders);
+			return new LlmError(message, httpErrorCode(error.statusCode ?? 0, providerError), {
+				...error.statusCode === void 0 ? {} : { status: error.statusCode },
+				...id === void 0 ? {} : { requestId: id },
+				cause: error
+			});
+		}
+		if (error instanceof Error) return new LlmError(`OpenAI-compatible API request to ${profile.baseURL} failed`, "TRANSPORT", { cause: error });
+		return new LlmError(`OpenAI-compatible API request to ${profile.baseURL} failed`, "TRANSPORT");
+	}
+};
+//#endregion
+//#region src/index.ts
+const name = "llm-openai-compatible";
+const inject = ["llm"];
+const NS = "llm-openai-compatible";
+const REASONING_LEVELS = [
+	"off",
+	"low",
+	"high",
+	"max"
+];
+const MODEL_MODALITIES = ["text", "image"];
+const modelSchema = z.object({
+	id: z.string().required(),
+	name: z.string(),
+	description: z.string(),
+	contextWindow: z.number().step(1).min(1),
+	maxTokens: z.number().step(1).min(1),
+	inputModalities: z.array(z.union(MODEL_MODALITIES)).min(1).default(["text"]),
+	reasoningEfforts: z.union([z.const(false), z.dict(z.union([z.string(), z.const(null)]))])
+});
+const providerSchema = z.object({
+	apiKeyEnv: z.string().role("credential-ref"),
+	displayName: z.string(),
+	baseURL: z.string().required(),
+	headers: z.dict(z.string()),
+	temperature: z.number().min(0).max(2),
+	topP: z.number().min(0).max(1),
+	topK: z.number().step(1).min(1),
+	presencePenalty: z.number().min(-2).max(2),
+	frequencyPenalty: z.number().min(-2).max(2),
+	seed: z.number().step(1).min(1),
+	reasoning: z.union(REASONING_LEVELS),
+	models: z.array(modelSchema),
+	defaultContextWindow: z.number().step(1).min(1).default(DEFAULT_CONTEXT_WINDOW),
+	defaultMaxTokens: z.number().step(1).min(1).default(DEFAULT_MAX_TOKENS),
+	maxRequestImageBytes: z.number().step(1).min(1).default(DEFAULT_MAX_REQUEST_IMAGE_BYTES),
+	streamIdleTimeoutMs: z.number().min(Number.MIN_VALUE).max(MAX_TIMER_DELAY_MS).default(DEFAULT_STREAM_IDLE_TIMEOUT_MS),
+	timeoutMs: z.number().min(Number.MIN_VALUE).max(MAX_TIMER_DELAY_MS),
+	retryPolicy: RetryPolicySchema
+});
+const Config = z.object({ providers: z.dict(providerSchema).default({}) });
+function isReasoningEffort(value) {
+	return REASONING_LEVELS.includes(value);
+}
+function resolveReasoningEfforts(provider, modelId, value) {
+	if (value === void 0) return {};
+	if (value === false) return { reasoningEfforts: false };
+	const declaration = {};
+	for (const [effort, wire] of Object.entries(value)) {
+		if (!isReasoningEffort(effort)) throw new Error(`llm-openai-compatible: provider "${provider}" model "${modelId}" declares unknown reasoning effort "${effort}"`);
+		if (effort === "off") {
+			if (wire !== null) throw new Error(`llm-openai-compatible: provider "${provider}" model "${modelId}" reasoning effort "off" must leave an empty wire spelling (null) to omit reasoning_effort`);
+			declaration.off = null;
+			continue;
+		}
+		if (wire === null || wire.length === 0) throw new Error(`llm-openai-compatible: provider "${provider}" model "${modelId}" reasoning effort "${effort}" needs a non-empty wire spelling`);
+		declaration[effort] = wire;
+	}
+	return { reasoningEfforts: declaration };
+}
+function resolveModels(provider, models) {
+	if (models === void 0) return [];
+	const seen = /* @__PURE__ */ new Set();
+	return models.map((model) => {
+		if (model.id.length === 0) throw new Error(`llm-openai-compatible: provider "${provider}" catalog model ids must be non-empty`);
+		if (model.name !== void 0 && model.name.length === 0) throw new Error(`llm-openai-compatible: provider "${provider}" catalog model "${model.id}" has an empty name`);
+		if (model.contextWindow !== void 0 && (!Number.isInteger(model.contextWindow) || model.contextWindow <= 0)) throw new Error(`llm-openai-compatible: provider "${provider}" catalog model "${model.id}" contextWindow must be a positive integer`);
+		if (model.maxTokens !== void 0 && (!Number.isInteger(model.maxTokens) || model.maxTokens <= 0)) throw new Error(`llm-openai-compatible: provider "${provider}" catalog model "${model.id}" maxTokens must be a positive integer`);
+		const inputModalities = model.inputModalities ?? ["text"];
+		if (inputModalities.length === 0) throw new Error(`llm-openai-compatible: provider "${provider}" catalog model "${model.id}" inputModalities must not be empty`);
+		if (inputModalities.some((modality) => !MODEL_MODALITIES.includes(modality))) throw new Error(`llm-openai-compatible: provider "${provider}" catalog model "${model.id}" inputModalities must contain only "text" and "image"`);
+		if (new Set(inputModalities).size !== inputModalities.length) throw new Error(`llm-openai-compatible: provider "${provider}" catalog model "${model.id}" inputModalities must not contain duplicates`);
+		if (seen.has(model.id)) throw new Error(`llm-openai-compatible: provider "${provider}" has duplicate catalog model "${model.id}"`);
+		seen.add(model.id);
+		return {
+			id: model.id,
+			...model.name === void 0 ? {} : { name: model.name },
+			...model.description === void 0 ? {} : { description: model.description },
+			...model.contextWindow === void 0 ? {} : { contextWindow: model.contextWindow },
+			...model.maxTokens === void 0 ? {} : { maxTokens: model.maxTokens },
+			inputModalities: [...inputModalities],
+			...resolveReasoningEfforts(provider, model.id, model.reasoningEfforts)
+		};
+	});
+}
+function bounded(value, lo, hi) {
+	if (value === void 0) return void 0;
+	if (!Number.isFinite(value) || value < lo || value > hi) return void 0;
+	return value;
+}
+function resolveAdapterOptions(provider, source) {
+	if (provider.length === 0) throw new Error("llm-openai-compatible: provider names must be non-empty");
+	if (source.baseURL === void 0 || source.baseURL.length === 0) throw new Error(`llm-openai-compatible: provider "${provider}" requires a non-empty baseURL`);
+	if (source.displayName !== void 0 && source.displayName.length === 0) throw new Error(`llm-openai-compatible: provider "${provider}" has an empty displayName`);
+	const streamIdleTimeoutMs = source.streamIdleTimeoutMs ?? 3e5;
+	if (!Number.isFinite(streamIdleTimeoutMs) || streamIdleTimeoutMs <= 0 || streamIdleTimeoutMs > MAX_TIMER_DELAY_MS) throw new Error(`llm-openai-compatible: provider "${provider}" streamIdleTimeoutMs must be a positive finite number no greater than ${MAX_TIMER_DELAY_MS}`);
+	const maxRequestImageBytes = source.maxRequestImageBytes ?? 20971520;
+	if (!Number.isSafeInteger(maxRequestImageBytes) || maxRequestImageBytes <= 0) throw new Error(`llm-openai-compatible: provider "${provider}" maxRequestImageBytes must be a positive safe integer`);
+	const defaultContextWindow = source.defaultContextWindow ?? 262144;
+	if (!Number.isInteger(defaultContextWindow) || defaultContextWindow <= 0) throw new Error(`llm-openai-compatible: provider "${provider}" defaultContextWindow must be a positive integer`);
+	const defaultMaxTokens = source.defaultMaxTokens ?? 32768;
+	if (!Number.isSafeInteger(defaultMaxTokens) || defaultMaxTokens <= 0) throw new Error(`llm-openai-compatible: provider "${provider}" defaultMaxTokens must be a positive safe integer`);
+	const timeoutMs = bounded(source.timeoutMs, Number.MIN_VALUE, MAX_TIMER_DELAY_MS);
+	if (source.timeoutMs !== void 0 && timeoutMs === void 0) throw new Error(`llm-openai-compatible: provider "${provider}" timeoutMs must be a positive finite number no greater than ${MAX_TIMER_DELAY_MS}`);
+	if (bounded(source.temperature, 0, 2) === void 0 && source.temperature !== void 0) throw new Error(`llm-openai-compatible: provider "${provider}" temperature must be a finite number within 0..2`);
+	if (bounded(source.topP, 0, 1) === void 0 && source.topP !== void 0) throw new Error(`llm-openai-compatible: provider "${provider}" topP must be a finite number within 0..1`);
+	if (source.topK !== void 0 && (!Number.isInteger(source.topK) || source.topK <= 0)) throw new Error(`llm-openai-compatible: provider "${provider}" topK must be a positive integer`);
+	if (bounded(source.presencePenalty, -2, 2) === void 0 && source.presencePenalty !== void 0) throw new Error(`llm-openai-compatible: provider "${provider}" presencePenalty must be a finite number within -2..2`);
+	if (bounded(source.frequencyPenalty, -2, 2) === void 0 && source.frequencyPenalty !== void 0) throw new Error(`llm-openai-compatible: provider "${provider}" frequencyPenalty must be a finite number within -2..2`);
+	if (source.seed !== void 0 && (!Number.isInteger(source.seed) || source.seed <= 0)) throw new Error(`llm-openai-compatible: provider "${provider}" seed must be a positive integer`);
+	if (source.reasoning !== void 0 && !isReasoningEffort(source.reasoning)) throw new Error(`llm-openai-compatible: provider "${provider}" reasoning must be one of ${REASONING_LEVELS.join(", ")}`);
+	return {
+		provider,
+		displayName: source.displayName ?? provider,
+		...source.apiKeyEnv === void 0 ? {} : { apiKeyEnv: credentialRef(source.apiKeyEnv) },
+		baseURL: source.baseURL,
+		...source.headers === void 0 ? {} : { headers: { ...source.headers } },
+		...source.temperature === void 0 ? {} : { temperature: source.temperature },
+		...source.topP === void 0 ? {} : { topP: source.topP },
+		...source.topK === void 0 ? {} : { topK: source.topK },
+		...source.presencePenalty === void 0 ? {} : { presencePenalty: source.presencePenalty },
+		...source.frequencyPenalty === void 0 ? {} : { frequencyPenalty: source.frequencyPenalty },
+		...source.seed === void 0 ? {} : { seed: source.seed },
+		...source.reasoning === void 0 ? {} : { reasoning: source.reasoning },
+		models: resolveModels(provider, source.models),
+		defaultContextWindow,
+		defaultMaxTokens,
+		maxRequestImageBytes,
+		streamIdleTimeoutMs,
+		...timeoutMs === void 0 ? {} : { timeoutMs },
+		retryPolicy: resolveRetryPolicy(source.retryPolicy, `llm-openai-compatible: provider "${provider}" retryPolicy`)
+	};
+}
+function resolveProfiles(providers) {
+	if (Array.isArray(providers)) throw new Error("llm-openai-compatible: providers is now a dict keyed by provider route, not an array of profiles");
+	const resolved = /* @__PURE__ */ new Map();
+	for (const [provider, source] of Object.entries(providers ?? {})) resolved.set(provider, resolveAdapterOptions(provider, source));
+	return resolved;
+}
+function assertServiceable(config) {
+	resolveProfiles(config.providers);
+}
+function registrationFacts(profiles) {
+	return [...profiles.entries()].map(([provider, profile]) => ({
+		provider,
+		displayName: profile.displayName,
+		retryPolicy: profile.retryPolicy
+	})).sort((left, right) => left.provider.localeCompare(right.provider));
+}
+function directoryEntries(profiles) {
+	const entries = /* @__PURE__ */ new Map();
+	for (const [provider, profile] of profiles) entries.set(provider, {
+		provider,
+		displayName: profile.displayName,
+		settingsNs: NS,
+		settingsPath: ["providers", provider],
+		declared: true
+	});
+	return [...entries.values()];
+}
+function apply(ctx, config) {
+	let current = () => config;
+	let lastRaw;
+	let memoized;
+	const profiles = () => {
+		const raw = current();
+		if (raw === lastRaw && memoized !== void 0) return memoized;
+		const next = resolveProfiles(raw.providers);
+		lastRaw = raw;
+		memoized = next;
+		return next;
+	};
+	profiles();
+	const resolveApiKey = async (provider, profile) => {
+		const ref = profile.apiKeyEnv;
+		if (ref === void 0) return void 0;
+		const credentials = ctx.get("credentials");
+		if (credentials !== void 0) {
+			const hit = await credentials.resolve(ref);
+			if (hit !== void 0) return assertUsableApiKey(hit.value, "llm-openai-compatible", ref);
+		} else {
+			const ambient = launchEnvironmentOf(ctx).get(ref);
+			if (ambient !== void 0 && ambient.value.length > 0) return assertUsableApiKey(ambient.value, "llm-openai-compatible", ref);
+		}
+		throw new LlmError(`llm-openai-compatible: no credential for provider route "${provider}"; its profile resolves ${ref}, which is not set — store ${ref} through the credentials service (the web Models page writes it), or export ${ref} in the launching environment`, "MISSING_CREDENTIAL");
+	};
+	let userId;
+	const resolveUserId = () => userId ??= getOrCreateAnonymousUserId();
+	const adapter = new OpenAICompatibleAdapter({
+		profiles,
+		resolveApiKey,
+		resolveUserId,
+		resolveAttachments: () => ctx.get("attachments")
+	});
+	let directory;
+	let directoryFacts;
+	const ensureDirectory = () => {
+		const entries = directoryEntries(profiles());
+		if (deepEqualJson(entries, directoryFacts)) return;
+		if (directory === void 0) directory = ctx.llm.registerConfigurableProviders(entries);
+		else directory.replace(entries);
+		directoryFacts = entries;
+	};
+	ensureDirectory();
+	let registration;
+	let registeredFacts;
+	const ensureRegistrationFacts = () => {
+		const facts = registrationFacts(profiles());
+		if (deepEqualJson(facts, registeredFacts)) return;
+		const routes = [...profiles().keys()];
+		if (registration === void 0) {
+			if (routes.length === 0) {
+				registeredFacts = facts;
+				return;
+			}
+			registration = ctx.llm.registerAdapter(routes, adapter);
+		} else registration.replace(routes);
+		registeredFacts = facts;
+	};
+	ensureRegistrationFacts();
+	ctx.inject(["settings"], (settingsCtx) => {
+		settingsCtx.settings.installSection(ctx, NS, Config, config, {
+			validate: assertServiceable,
+			setSource: (source) => {
+				current = source;
+			},
+			onChange: () => {
+				try {
+					ensureRegistrationFacts();
+				} catch (error) {
+					ctx.logger.error("llm-openai-compatible: keeping the previously registered routes after a refused update");
+					ctx.logger.error(error);
+				}
+				try {
+					ensureDirectory();
+				} catch (error) {
+					ctx.logger.error("llm-openai-compatible: keeping the previous configurable-provider directory after a refused update");
+					ctx.logger.error(error);
+				}
+			}
+		});
+	});
+}
+//#endregion
+export { Config, DEFAULT_CONTEXT_WINDOW, DEFAULT_MAX_REQUEST_IMAGE_BYTES, DEFAULT_MAX_TOKENS, DEFAULT_STREAM_IDLE_TIMEOUT_MS, MODEL_MODALITIES, NS, OpenAICompatibleAdapter, REASONING_LEVELS, apply, assertServiceable, inject, name, resolveAdapterOptions, resolveProfiles };
+
+//# sourceMappingURL=index.mjs.map