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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 morlay
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -12,15 +12,6 @@ DeepSeek Harness 的 **OpenAI 兼容 LLM 适配器**插件。与内置 `llm-pi-a
 harness 消息 → AI SDK prompt 转换、采样默认合并、stream part → `StreamChunk`
 翻译、错误归一化与凭据策略。
 
-## 安装
-
-```sh
-dsh plugin --profile web add "@morlay/dsh-llm-openai-compatible"
-```
-
-插件默认休眠（空 `providers`）：不声明任何 provider 路由，直到你在
-`settings.yaml` 中配置。
-
 ## 配置
 
 `providers` 是 dict：**key 就是 provider 路由键**（选择器与

package/cordis.patch.yml

@@ -6,7 +6,7 @@
           ollama:
             apiKeyEnv: OLLAMA_API_KEY
             baseURL: https://ollama.com/v1
-            displayName: Ollama Gateway
+            displayName: Ollama Cloud
             temperature: 1 # 0..2
             topP: 0.95
             reasoning: high
@@ -14,11 +14,11 @@
             defaultMaxTokens: 65535
             models:
               - id: deepseek-v4-flash:0731
-                name: "DeepSeek V4 Flash: 0731"
+                name: "DeepSeek V4 Flash @ Ollama Cloud"
                 contextWindow: 1000000
                 maxTokens: 65535
                 inputModalities: [text]
                 reasoningEfforts:
-                  off: # off 空值 = 不发送 reasoning_effort
+                  off:
                   high: high
                   max: max

package/dist/adapter-CYd_pegB.d.mts

@@ -0,0 +1,62 @@
+import { GenerateOptions, LlmAdapter, LlmModelInfo, LlmProviderInfo, LlmResolvedModelInfo, ModelModality, ResolvedRetryPolicy, StreamChunk } from "@deepseek-ai/dsh-llm";
+import { CredentialRef } from "@deepseek-ai/dsh-credentials";
+import { LanguageModelV4Usage } from "@ai-sdk/provider";
+import { AttachmentStore } from "@deepseek-ai/dsh-attachment";
+//#region src/adapter.d.ts
+declare const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 300000;
+declare const DEFAULT_CONTEXT_WINDOW = 262144;
+declare const DEFAULT_MAX_TOKENS = 32768;
+declare const DEFAULT_MAX_REQUEST_IMAGE_BYTES: number;
+type ReasoningEffort = "off" | "low" | "high" | "max";
+interface ResolvedModelProfile {
+  id: string;
+  name?: string;
+  description?: string;
+  contextWindow?: number;
+  maxTokens?: number;
+  inputModalities: readonly ModelModality[];
+  reasoningEfforts?: false | Partial<Record<ReasoningEffort, string | null>>;
+}
+interface ResolvedProviderProfile {
+  provider: string;
+  displayName: string;
+  apiKeyEnv?: CredentialRef;
+  baseURL: string;
+  headers?: Readonly<Record<string, string>>;
+  temperature?: number;
+  topP?: number;
+  topK?: number;
+  presencePenalty?: number;
+  frequencyPenalty?: number;
+  seed?: number;
+  reasoning?: ReasoningEffort;
+  models: readonly ResolvedModelProfile[];
+  defaultContextWindow: number;
+  defaultMaxTokens: number;
+  maxRequestImageBytes: number;
+  streamIdleTimeoutMs: number;
+  timeoutMs?: number;
+  retryPolicy: ResolvedRetryPolicy;
+}
+interface OpenAICompatibleAdapterOptions {
+  profiles: () => ReadonlyMap<string, ResolvedProviderProfile>;
+  resolveApiKey: (provider: string, profile: ResolvedProviderProfile) => Promise<string | undefined>;
+  resolveUserId: () => string;
+  resolveAttachments?: () => AttachmentStore | undefined;
+}
+declare class OpenAICompatibleAdapter extends LlmAdapter {
+  private readonly config;
+  private readonly sdkProviders;
+  constructor(config: OpenAICompatibleAdapterOptions);
+  private profileOf;
+  private modelOf;
+  private sdkModel;
+  providerInfo(provider: string): LlmProviderInfo;
+  providerRetryPolicy(provider: string): ResolvedRetryPolicy | undefined;
+  listModels(provider: string): Promise<readonly LlmModelInfo[]>;
+  resolveModel(provider: string, model: string, _signal?: AbortSignal): Promise<LlmResolvedModelInfo>;
+  stream(options: GenerateOptions): AsyncGenerator<StreamChunk>;
+  private normalizeTransportError;
+}
+//#endregion
+export { OpenAICompatibleAdapter as a, ResolvedModelProfile as c, DEFAULT_STREAM_IDLE_TIMEOUT_MS as i, ResolvedProviderProfile as l, DEFAULT_MAX_REQUEST_IMAGE_BYTES as n, OpenAICompatibleAdapterOptions as o, DEFAULT_MAX_TOKENS as r, ReasoningEffort as s, DEFAULT_CONTEXT_WINDOW as t };

package/dist/index.d.mts

@@ -0,0 +1,49 @@
+import { a as OpenAICompatibleAdapter, c as ResolvedModelProfile, i as DEFAULT_STREAM_IDLE_TIMEOUT_MS, l as ResolvedProviderProfile, n as DEFAULT_MAX_REQUEST_IMAGE_BYTES, o as OpenAICompatibleAdapterOptions, r as DEFAULT_MAX_TOKENS, s as ReasoningEffort, t as DEFAULT_CONTEXT_WINDOW } from "./adapter-CYd_pegB.mjs";
+import z from "@deepseek-ai/schemastery";
+import { ModelModality, RetryPolicyConfig } from "@deepseek-ai/dsh-llm";
+import { Context } from "@deepseek-ai/cordis";
+//#region src/index.d.ts
+declare const name = "llm-openai-compatible";
+declare const inject: string[];
+declare const NS = "llm-openai-compatible";
+declare const REASONING_LEVELS: readonly ["off", "low", "high", "max"];
+declare const MODEL_MODALITIES: readonly ["text", "image"];
+interface ModelProfileSource {
+  id: string;
+  name?: string;
+  description?: string;
+  contextWindow?: number;
+  maxTokens?: number;
+  inputModalities?: ModelModality[];
+  reasoningEfforts?: false | Partial<Record<ReasoningEffort, string | null>>;
+}
+interface ProviderProfileSource {
+  apiKeyEnv?: string;
+  displayName?: string;
+  baseURL: string;
+  headers?: Record<string, string>;
+  temperature?: number;
+  topP?: number;
+  topK?: number;
+  presencePenalty?: number;
+  frequencyPenalty?: number;
+  seed?: number;
+  reasoning?: ReasoningEffort;
+  models?: ModelProfileSource[];
+  defaultContextWindow?: number;
+  defaultMaxTokens?: number;
+  maxRequestImageBytes?: number;
+  streamIdleTimeoutMs?: number;
+  timeoutMs?: number;
+  retryPolicy?: RetryPolicyConfig;
+}
+interface Config {
+  providers?: Record<string, ProviderProfileSource>;
+}
+declare const Config: z<Config>;
+declare function resolveAdapterOptions(provider: string, source: ProviderProfileSource): ResolvedProviderProfile;
+declare function resolveProfiles(providers: Readonly<Record<string, ProviderProfileSource>> | undefined): Map<string, ResolvedProviderProfile>;
+declare function assertServiceable(config: Config): void;
+declare function apply(ctx: Context, config: Config): void;
+//#endregion
+export { Config, DEFAULT_CONTEXT_WINDOW, DEFAULT_MAX_REQUEST_IMAGE_BYTES, DEFAULT_MAX_TOKENS, DEFAULT_STREAM_IDLE_TIMEOUT_MS, MODEL_MODALITIES, ModelProfileSource, NS, OpenAICompatibleAdapter, type OpenAICompatibleAdapterOptions, ProviderProfileSource, REASONING_LEVELS, type ReasoningEffort, type ResolvedModelProfile, type ResolvedProviderProfile, apply, assertServiceable, inject, name, resolveAdapterOptions, resolveProfiles };

package/{lib → dist}/index.mjs

@@ -1,23 +1,263 @@
-import { DEFAULT_CONTEXT_WINDOW, DEFAULT_MAX_REQUEST_IMAGE_BYTES, DEFAULT_MAX_TOKENS, DEFAULT_STREAM_IDLE_TIMEOUT_MS, OpenAICompatibleAdapter } from "./adapter.mjs";
+import { a as serializeCallOptions, o as serializeCallOptionsWithImages, r as translate } from "./translate-BzOJ1xx-.mjs";
 import z from "@deepseek-ai/schemastery";
-import { LlmError, RetryPolicySchema, assertUsableApiKey, resolveRetryPolicy } from "@deepseek-ai/dsh-llm";
+import { CONTEXT_WINDOW_EXCEEDED_CODE, LlmAdapter, LlmError, ProviderRequestId, QUOTA_EXCEEDED_CODE, ReasoningEffortId, RetryPolicySchema, assertUsableApiKey, attributionHeaders, contentHasImage, isContextWindowExceededError, isQuotaExceededError, resolveRetryPolicy } from "@deepseek-ai/dsh-llm";
 import { credentialRef } from "@deepseek-ai/dsh-credentials";
 import { launchEnvironmentOf } from "@deepseek-ai/dsh-launch-environment";
-import { deepEqualJson, installSettingsSection, settingsNamespace } from "@deepseek-ai/dsh-settings";
-import { MAX_TIMER_DELAY_MS } from "@deepseek-ai/dsh-timeout";
+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";
+//#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 = settingsNamespace("llm-openai-compatible");
-/** Selectable reasoning levels a profile or model may declare. */
+const NS = "llm-openai-compatible";
 const REASONING_LEVELS = [
 	"off",
 	"low",
 	"high",
 	"max"
 ];
-/** Accepted model input modalities. */
 const MODEL_MODALITIES = ["text", "image"];
 const modelSchema = z.object({
 	id: z.string().required(),
@@ -48,12 +288,10 @@ const providerSchema = z.object({
 	timeoutMs: z.number().min(Number.MIN_VALUE).max(MAX_TIMER_DELAY_MS),
 	retryPolicy: RetryPolicySchema
 });
-/** Runtime schema for {@link Config}. */
 const Config = z.object({ providers: z.dict(providerSchema).default({}) });
 function isReasoningEffort(value) {
 	return REASONING_LEVELS.includes(value);
 }
-/** Validate one model's declared reasoning efforts into detached form. */
 function resolveReasoningEfforts(provider, modelId, value) {
 	if (value === void 0) return {};
 	if (value === false) return { reasoningEfforts: false };
@@ -70,7 +308,6 @@ function resolveReasoningEfforts(provider, modelId, value) {
 	}
 	return { reasoningEfforts: declaration };
 }
-/** Validate and detach one provider route's model catalog. */
 function resolveModels(provider, models) {
 	if (models === void 0) return [];
 	const seen = /* @__PURE__ */ new Set();
@@ -96,21 +333,11 @@ function resolveModels(provider, models) {
 		};
 	});
 }
-/** A bounded finite number within `[lo, hi]`, or undefined. */
 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;
 }
-/**
-* The one explicit resolve step from a raw profile to validated connection
-* facts. Programmatic construction may bypass Schemastery normalization, so
-* every default and bound is re-judged here — for the composition entry at
-* load (fail loud) and for each settings snapshot at its first use.
-* @param provider - the route key owning this profile.
-* @param source - raw profile from config or a resolved settings snapshot.
-* @returns validated connection facts plus the credential reference.
-*/
 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`);
@@ -154,31 +381,15 @@ function resolveAdapterOptions(provider, source) {
 		retryPolicy: resolveRetryPolicy(source.retryPolicy, `llm-openai-compatible: provider "${provider}" retryPolicy`)
 	};
 }
-/**
-* Validate profiles and return a detached route-keyed map suitable for
-* per-request reads. This is the one explicit resolve step, so an omitted dict
-* resolves to the empty (dormant) route set here rather than through a hidden
-* fallback.
-* @param providers - configured provider profiles keyed by route.
-* @returns validated profiles in configuration order.
-*/
 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;
 }
-/**
-* Reject a section this adapter could not serve. Registered as the settings
-* namespace's validator, so an unserviceable profile is refused where it is
-* written instead of being stored and then quietly disabling every route in
-* the namespace.
-* @param config - the resolved section to check.
-*/
 function assertServiceable(config) {
 	resolveProfiles(config.providers);
 }
-/** The registry captures these per route; a change here must re-register. */
 function registrationFacts(profiles) {
 	return [...profiles.entries()].map(([provider, profile]) => ({
 		provider,
@@ -186,13 +397,6 @@ function registrationFacts(profiles) {
 		retryPolicy: profile.retryPolicy
 	})).sort((left, right) => left.provider.localeCompare(right.provider));
 }
-/**
-* The configurable-provider directory: every route the current profiles
-* declare. A hand-declared route has no catalog entry, so without this it
-* would have no settings address and configuration surfaces could neither
-* show nor edit it. The profile half is unconditional, which keeps a route
-* already stored against a withheld provider editable and deletable.
-*/
 function directoryEntries(profiles) {
 	const entries = /* @__PURE__ */ new Map();
 	for (const [provider, profile] of profiles) entries.set(provider, {
@@ -204,12 +408,10 @@ function directoryEntries(profiles) {
 	});
 	return [...entries.values()];
 }
-/** Register one generic OpenAI-compatible adapter for all configured provider routes. */
 function apply(ctx, config) {
 	let current = () => config;
 	let lastRaw;
 	let memoized;
-	/** The resolved profiles for the current configuration, memoized by raw identity. */
 	const profiles = () => {
 		const raw = current();
 		if (raw === lastRaw && memoized !== void 0) return memoized;
@@ -266,28 +468,28 @@ function apply(ctx, config) {
 		registeredFacts = facts;
 	};
 	ensureRegistrationFacts();
-	installSettingsSection(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);
+	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

package/dist/invariant.d.mts

@@ -0,0 +1,7 @@
+import { Context } from "@deepseek-ai/cordis";
+//#region src/invariant.d.ts
+declare const name = "llm-openai-compatible-invariant";
+declare const inject: string[];
+declare const apply: (ctx: Context) => Promise<() => void>;
+//#endregion
+export { apply, inject, name };

package/dist/invariant.mjs

@@ -0,0 +1,8 @@
+//#region src/invariant.ts
+const PACKAGE_NAME = "@morlay/dsh-llm-openai-compatible";
+const name = "llm-openai-compatible-invariant";
+const inject = ["invariants"];
+const install = () => {};
+const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//#endregion
+export { apply, inject, name };