@fased/fased 0.1.57 → 0.1.59

package/dist/agents/copilot-dynamic-headers.js

@@ -34,4 +34,4 @@ function buildCopilotDynamicHeaders(params) {
 }
 
 //#endregion
-export { buildCopilotIdeHeaders };
+export { buildCopilotDynamicHeaders, buildCopilotIdeHeaders, hasCopilotVisionInput };

package/dist/agents/current-model-catalog.js

@@ -11,7 +11,7 @@ import { buildCopilotModelDefinition, buildCopilotProxyModelDefinition, getDefau
 import { CHUTES_BASE_URL, CHUTES_MODEL_CATALOG, buildChutesModelDefinition } from "./chutes-models.js";
 import { DOUBAO_BASE_URL, DOUBAO_CODING_BASE_URL, DOUBAO_CODING_MODEL_CATALOG, DOUBAO_MODEL_CATALOG, buildDoubaoModelDefinition } from "./doubao-models.js";
 import "./huggingface-models.js";
-import { normalizeProviderCatalogRows } from "./model-catalog-normalized.js";
+import { normalizeModelCatalogProviderId, normalizeProviderCatalogRows } from "./model-catalog-normalized.js";
 import { getOpencodeZenStaticFallbackModels } from "./opencode-zen-models.js";
 import "./synthetic-models.js";
 import "./together-models.js";
@@ -945,6 +945,9 @@ function cloneCurrentModelProvider(provider) {
 		}))
 	};
 }
+function listCurrentModelCatalogProviderIds() {
+	return Object.keys(CURRENT_MODEL_PROVIDER_CATALOG).map(normalizeModelCatalogProviderId).filter(Boolean).toSorted((left, right) => left.localeCompare(right));
+}
 function listCurrentModelCatalogRows() {
 	return Object.entries(CURRENT_MODEL_PROVIDER_CATALOG).flatMap(([provider, providerConfig]) => normalizeProviderCatalogRows({
 		provider,
@@ -955,4 +958,4 @@ function listCurrentModelCatalogRows() {
 }
 
 //#endregion
-export { CURRENT_MODEL_PROVIDER_CATALOG, cloneCurrentModelProvider, listCurrentModelCatalogRows };
+export { CURRENT_MODEL_PROVIDER_CATALOG, cloneCurrentModelProvider, listCurrentModelCatalogProviderIds, listCurrentModelCatalogRows };

package/dist/agents/custom-api-registry.js

@@ -0,0 +1,21 @@
+import { getApiProvider, registerApiProvider } from "@mariozechner/pi-ai/compat";
+
+//#region src/agents/custom-api-registry.ts
+const CUSTOM_API_SOURCE_PREFIX = "fased-custom-api:";
+function getCustomApiRegistrySourceId(api) {
+	return `${CUSTOM_API_SOURCE_PREFIX}${api}`;
+}
+function ensureCustomApiRegistered(api, streamFn) {
+	if (getApiProvider(api)) {
+		return false;
+	}
+	registerApiProvider({
+		api,
+		stream: (model, context, options) => streamFn(model, context, options),
+		streamSimple: (model, context, options) => streamFn(model, context, options)
+	}, getCustomApiRegistrySourceId(api));
+	return true;
+}
+
+//#endregion
+export { ensureCustomApiRegistered };

package/dist/agents/google-transport-stream.js

@@ -0,0 +1,543 @@
+import { parseGeminiAuth } from "../infra/gemini-auth.js";
+import { stripSystemPromptCacheBoundary } from "./system-prompt-cache-boundary.js";
+import { buildGuardedModelFetch } from "./provider-transport-fetch.js";
+import { transformTransportMessages } from "./transport-message-transform.js";
+import { createEmptyTransportUsage, createWritableTransportEventStream, failTransportStream, finalizeTransportStream, mergeTransportHeaders, sanitizeTransportPayloadText } from "./transport-stream-shared.js";
+import { normalizeGoogleApiBaseUrl } from "../infra/google-api-base-url.js";
+import { calculateCost, getEnvApiKey } from "@mariozechner/pi-ai/compat";
+
+//#region src/agents/google-transport-stream.ts
+let toolCallCounter = 0;
+function isGemini3ProModel(modelId) {
+	return /gemini-3(?:\.\d+)?-pro/.test(modelId.toLowerCase());
+}
+function isGemini3FlashModel(modelId) {
+	return /gemini-3(?:\.\d+)?-flash/.test(modelId.toLowerCase());
+}
+function requiresToolCallId(modelId) {
+	return modelId.startsWith("claude-") || modelId.startsWith("gpt-oss-");
+}
+function supportsMultimodalFunctionResponse(modelId) {
+	const match = modelId.toLowerCase().match(/^gemini(?:-live)?-(\d+)/);
+	if (!match) {
+		return true;
+	}
+	return Number.parseInt(match[1] ?? "", 10) >= 3;
+}
+function retainThoughtSignature(existing, incoming) {
+	if (typeof incoming === "string" && incoming.length > 0) {
+		return incoming;
+	}
+	return existing;
+}
+function mapToolChoice(choice) {
+	if (!choice) {
+		return undefined;
+	}
+	if (typeof choice === "object" && choice.type === "function") {
+		return {
+			mode: "ANY",
+			allowedFunctionNames: [choice.function.name]
+		};
+	}
+	switch (choice) {
+		case "none": return { mode: "NONE" };
+		case "any":
+		case "required": return { mode: "ANY" };
+		default: return { mode: "AUTO" };
+	}
+}
+function mapStopReasonString(reason) {
+	switch (reason) {
+		case "STOP": return "stop";
+		case "MAX_TOKENS": return "length";
+		default: return "error";
+	}
+}
+function normalizeToolCallId(id) {
+	return id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
+}
+function resolveGoogleModelPath(modelId) {
+	if (modelId.startsWith("models/") || modelId.startsWith("tunedModels/")) {
+		return modelId;
+	}
+	return `models/${modelId}`;
+}
+function buildGoogleRequestUrl(model) {
+	const baseUrl = normalizeGoogleApiBaseUrl(model.baseUrl);
+	return `${baseUrl}/${resolveGoogleModelPath(model.id)}:streamGenerateContent?alt=sse`;
+}
+function resolveThinkingLevel(level, modelId) {
+	if (isGemini3ProModel(modelId)) {
+		switch (level) {
+			case "minimal":
+			case "low": return "LOW";
+			case "medium":
+			case "high":
+			case "xhigh": return "HIGH";
+		}
+	}
+	switch (level) {
+		case "minimal": return "MINIMAL";
+		case "low": return "LOW";
+		case "medium": return "MEDIUM";
+		case "high":
+		case "xhigh": return "HIGH";
+	}
+}
+function getDisabledThinkingConfig(modelId) {
+	if (isGemini3ProModel(modelId)) {
+		return { thinkingLevel: "LOW" };
+	}
+	if (isGemini3FlashModel(modelId)) {
+		return { thinkingLevel: "MINIMAL" };
+	}
+	return { thinkingBudget: 0 };
+}
+function getGoogleThinkingBudget(modelId, effort, customBudgets) {
+	const normalizedEffort = effort === "xhigh" ? "high" : effort;
+	if (customBudgets?.[normalizedEffort] !== undefined) {
+		return customBudgets[normalizedEffort];
+	}
+	if (modelId.includes("2.5-pro")) {
+		return {
+			minimal: 128,
+			low: 2048,
+			medium: 8192,
+			high: 32768
+		}[normalizedEffort];
+	}
+	if (modelId.includes("2.5-flash")) {
+		return {
+			minimal: 128,
+			low: 2048,
+			medium: 8192,
+			high: 24576
+		}[normalizedEffort];
+	}
+	return undefined;
+}
+function resolveGoogleThinkingConfig(model, options) {
+	if (!model.reasoning) {
+		return undefined;
+	}
+	if (options?.thinking) {
+		if (!options.thinking.enabled) {
+			return getDisabledThinkingConfig(model.id);
+		}
+		const config = { includeThoughts: true };
+		if (options.thinking.level) {
+			config.thinkingLevel = options.thinking.level;
+		} else if (typeof options.thinking.budgetTokens === "number") {
+			config.thinkingBudget = options.thinking.budgetTokens;
+		}
+		return config;
+	}
+	if (!options?.reasoning) {
+		return getDisabledThinkingConfig(model.id);
+	}
+	if (isGemini3ProModel(model.id) || isGemini3FlashModel(model.id)) {
+		return {
+			includeThoughts: true,
+			thinkingLevel: resolveThinkingLevel(options.reasoning, model.id)
+		};
+	}
+	const budget = getGoogleThinkingBudget(model.id, options.reasoning, options.thinkingBudgets);
+	return {
+		includeThoughts: true,
+		...typeof budget === "number" ? { thinkingBudget: budget } : {}
+	};
+}
+function convertGoogleMessages(model, context) {
+	const contents = [];
+	const transformedMessages = transformTransportMessages(context.messages, model, (id) => requiresToolCallId(model.id) ? normalizeToolCallId(id) : id);
+	for (const msg of transformedMessages) {
+		if (msg.role === "user") {
+			if (typeof msg.content === "string") {
+				contents.push({
+					role: "user",
+					parts: [{ text: sanitizeTransportPayloadText(msg.content) }]
+				});
+				continue;
+			}
+			const parts = msg.content.map((item) => item.type === "text" ? { text: sanitizeTransportPayloadText(item.text) } : { inlineData: {
+				mimeType: item.mimeType,
+				data: item.data
+			} }).filter((item) => model.input.includes("image") || !("inlineData" in item));
+			if (parts.length > 0) {
+				contents.push({
+					role: "user",
+					parts
+				});
+			}
+			continue;
+		}
+		if (msg.role === "assistant") {
+			const isSameProviderAndModel = msg.provider === model.provider && msg.model === model.id;
+			const parts = [];
+			for (const block of msg.content) {
+				if (block.type === "text") {
+					if (!block.text.trim()) {
+						continue;
+					}
+					parts.push({
+						text: sanitizeTransportPayloadText(block.text),
+						...isSameProviderAndModel && block.textSignature ? { thoughtSignature: block.textSignature } : {}
+					});
+					continue;
+				}
+				if (block.type === "thinking") {
+					if (!block.thinking.trim()) {
+						continue;
+					}
+					if (isSameProviderAndModel) {
+						parts.push({
+							thought: true,
+							text: sanitizeTransportPayloadText(block.thinking),
+							...block.thinkingSignature ? { thoughtSignature: block.thinkingSignature } : {}
+						});
+					} else {
+						parts.push({ text: sanitizeTransportPayloadText(block.thinking) });
+					}
+					continue;
+				}
+				if (block.type === "toolCall") {
+					parts.push({
+						functionCall: {
+							name: block.name,
+							args: block.arguments ?? {},
+							...requiresToolCallId(model.id) ? { id: block.id } : {}
+						},
+						...isSameProviderAndModel && block.thoughtSignature ? { thoughtSignature: block.thoughtSignature } : {}
+					});
+				}
+			}
+			if (parts.length > 0) {
+				contents.push({
+					role: "model",
+					parts
+				});
+			}
+			continue;
+		}
+		if (msg.role === "toolResult") {
+			const textResult = msg.content.filter((item) => item.type === "text").map((item) => item.text).join("\n");
+			const imageContent = model.input.includes("image") ? msg.content.filter((item) => item.type === "image") : [];
+			const responseValue = textResult ? sanitizeTransportPayloadText(textResult) : imageContent.length > 0 ? "(see attached image)" : "";
+			const imageParts = imageContent.map((imageBlock) => ({ inlineData: {
+				mimeType: imageBlock.mimeType,
+				data: imageBlock.data
+			} }));
+			const functionResponse = { functionResponse: {
+				name: msg.toolName,
+				response: msg.isError ? { error: responseValue } : { output: responseValue },
+				...supportsMultimodalFunctionResponse(model.id) && imageParts.length > 0 ? { parts: imageParts } : {},
+				...requiresToolCallId(model.id) ? { id: msg.toolCallId } : {}
+			} };
+			const last = contents[contents.length - 1];
+			if (last?.role === "user" && Array.isArray(last.parts) && last.parts.some((part) => "functionResponse" in part)) {
+				last.parts.push(functionResponse);
+			} else {
+				contents.push({
+					role: "user",
+					parts: [functionResponse]
+				});
+			}
+			if (imageParts.length > 0 && !supportsMultimodalFunctionResponse(model.id)) {
+				contents.push({
+					role: "user",
+					parts: [{ text: "Tool result image:" }, ...imageParts]
+				});
+			}
+		}
+	}
+	return contents;
+}
+function convertGoogleTools(tools) {
+	if (tools.length === 0) {
+		return undefined;
+	}
+	return [{ functionDeclarations: tools.map((tool) => ({
+		name: tool.name,
+		description: tool.description,
+		parametersJsonSchema: tool.parameters
+	})) }];
+}
+function buildGoogleGenerativeAiParams(model, context, options) {
+	const generationConfig = {};
+	if (typeof options?.temperature === "number") {
+		generationConfig.temperature = options.temperature;
+	}
+	if (typeof options?.maxTokens === "number") {
+		generationConfig.maxOutputTokens = options.maxTokens;
+	}
+	const thinkingConfig = resolveGoogleThinkingConfig(model, options);
+	if (thinkingConfig) {
+		generationConfig.thinkingConfig = thinkingConfig;
+	}
+	const params = { contents: convertGoogleMessages(model, context) };
+	if (typeof options?.cachedContent === "string" && options.cachedContent.trim()) {
+		params.cachedContent = options.cachedContent.trim();
+	}
+	if (Object.keys(generationConfig).length > 0) {
+		params.generationConfig = generationConfig;
+	}
+	if (context.systemPrompt) {
+		params.systemInstruction = { parts: [{ text: sanitizeTransportPayloadText(stripSystemPromptCacheBoundary(context.systemPrompt)) }] };
+	}
+	if (context.tools?.length) {
+		params.tools = convertGoogleTools(context.tools);
+		const toolChoice = mapToolChoice(options?.toolChoice);
+		if (toolChoice) {
+			params.toolConfig = { functionCallingConfig: toolChoice };
+		}
+	}
+	return params;
+}
+function buildGoogleHeaders(model, apiKey, optionHeaders) {
+	const authHeaders = apiKey ? parseGeminiAuth(apiKey).headers : undefined;
+	return mergeTransportHeaders({ accept: "text/event-stream" }, authHeaders, model.headers, optionHeaders) ?? { accept: "text/event-stream" };
+}
+async function* parseGoogleSseChunks(response, signal) {
+	if (!response.body) {
+		throw new Error("No response body");
+	}
+	const reader = response.body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	const abortHandler = () => {
+		void reader.cancel().catch(() => undefined);
+	};
+	signal?.addEventListener("abort", abortHandler);
+	try {
+		while (true) {
+			if (signal?.aborted) {
+				throw new Error("Request was aborted");
+			}
+			const { done, value } = await reader.read();
+			if (done) {
+				break;
+			}
+			buffer += decoder.decode(value, { stream: true }).replace(/\r/g, "");
+			let boundary = buffer.indexOf("\n\n");
+			while (boundary >= 0) {
+				const rawEvent = buffer.slice(0, boundary);
+				buffer = buffer.slice(boundary + 2);
+				boundary = buffer.indexOf("\n\n");
+				const data = rawEvent.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trim()).join("\n");
+				if (!data || data === "[DONE]") {
+					continue;
+				}
+				yield JSON.parse(data);
+			}
+		}
+	} finally {
+		signal?.removeEventListener("abort", abortHandler);
+	}
+}
+function updateUsage(output, model, chunk) {
+	const usage = chunk.usageMetadata;
+	if (!usage) {
+		return;
+	}
+	const promptTokens = usage.promptTokenCount || 0;
+	const cacheRead = usage.cachedContentTokenCount || 0;
+	output.usage = {
+		input: Math.max(0, promptTokens - cacheRead),
+		output: (usage.candidatesTokenCount || 0) + (usage.thoughtsTokenCount || 0),
+		cacheRead,
+		cacheWrite: 0,
+		totalTokens: usage.totalTokenCount || 0,
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			total: 0
+		}
+	};
+	calculateCost(model, output.usage);
+}
+function pushTextBlockEnd(stream, output, blockIndex) {
+	const block = output.content[blockIndex];
+	if (!block) {
+		return;
+	}
+	if (block.type === "thinking") {
+		stream.push({
+			type: "thinking_end",
+			contentIndex: blockIndex,
+			content: block.thinking,
+			partial: output
+		});
+		return;
+	}
+	if (block.type === "text") {
+		stream.push({
+			type: "text_end",
+			contentIndex: blockIndex,
+			content: block.text,
+			partial: output
+		});
+	}
+}
+function createGoogleGenerativeAiTransportStreamFn() {
+	return (rawModel, context, rawOptions) => {
+		const model = rawModel;
+		const options = rawOptions;
+		const { eventStream, stream } = createWritableTransportEventStream();
+		void (async () => {
+			const output = {
+				role: "assistant",
+				content: [],
+				api: "google-generative-ai",
+				provider: model.provider,
+				model: model.id,
+				usage: createEmptyTransportUsage(),
+				stopReason: "stop",
+				timestamp: Date.now()
+			};
+			try {
+				const apiKey = options?.apiKey ?? getEnvApiKey(model.provider) ?? undefined;
+				const fetch = buildGuardedModelFetch(model);
+				const params = buildGoogleGenerativeAiParams(model, context, options);
+				await Promise.resolve(options?.onPayload?.(params));
+				const response = await fetch(buildGoogleRequestUrl(model), {
+					method: "POST",
+					headers: buildGoogleHeaders(model, apiKey, options?.headers),
+					body: JSON.stringify(params),
+					signal: options?.signal
+				});
+				if (!response.ok) {
+					const message = await response.text().catch(() => "");
+					throw new Error(`Google Generative AI API error (${response.status}): ${message}`);
+				}
+				stream.push({
+					type: "start",
+					partial: output
+				});
+				let currentBlockIndex = -1;
+				for await (const chunk of parseGoogleSseChunks(response, options?.signal)) {
+					output.responseId ||= chunk.responseId;
+					updateUsage(output, model, chunk);
+					const candidate = chunk.candidates?.[0];
+					if (candidate?.content?.parts) {
+						for (const part of candidate.content.parts) {
+							if (typeof part.text === "string") {
+								const isThinking = part.thought === true;
+								const currentBlock = output.content[currentBlockIndex];
+								if (currentBlockIndex < 0 || !currentBlock || isThinking && currentBlock.type !== "thinking" || !isThinking && currentBlock.type !== "text") {
+									if (currentBlockIndex >= 0) {
+										pushTextBlockEnd(stream, output, currentBlockIndex);
+									}
+									if (isThinking) {
+										output.content.push({
+											type: "thinking",
+											thinking: ""
+										});
+										currentBlockIndex = output.content.length - 1;
+										stream.push({
+											type: "thinking_start",
+											contentIndex: currentBlockIndex,
+											partial: output
+										});
+									} else {
+										output.content.push({
+											type: "text",
+											text: ""
+										});
+										currentBlockIndex = output.content.length - 1;
+										stream.push({
+											type: "text_start",
+											contentIndex: currentBlockIndex,
+											partial: output
+										});
+									}
+								}
+								const activeBlock = output.content[currentBlockIndex];
+								if (activeBlock?.type === "thinking") {
+									activeBlock.thinking += part.text;
+									activeBlock.thinkingSignature = retainThoughtSignature(activeBlock.thinkingSignature, part.thoughtSignature);
+									stream.push({
+										type: "thinking_delta",
+										contentIndex: currentBlockIndex,
+										delta: part.text,
+										partial: output
+									});
+								} else if (activeBlock?.type === "text") {
+									activeBlock.text += part.text;
+									activeBlock.textSignature = retainThoughtSignature(activeBlock.textSignature, part.thoughtSignature);
+									stream.push({
+										type: "text_delta",
+										contentIndex: currentBlockIndex,
+										delta: part.text,
+										partial: output
+									});
+								}
+							}
+							if (part.functionCall) {
+								if (currentBlockIndex >= 0) {
+									pushTextBlockEnd(stream, output, currentBlockIndex);
+									currentBlockIndex = -1;
+								}
+								const providedId = part.functionCall.id;
+								const isDuplicate = output.content.some((block) => block.type === "toolCall" && block.id === providedId);
+								const toolCallId = providedId && !isDuplicate ? providedId : `${part.functionCall.name || "tool"}_${Date.now()}_${++toolCallCounter}`;
+								const toolCall = {
+									type: "toolCall",
+									id: toolCallId,
+									name: part.functionCall.name || "",
+									arguments: part.functionCall.args ?? {}
+								};
+								output.content.push(toolCall);
+								const blockIndex = output.content.length - 1;
+								stream.push({
+									type: "toolcall_start",
+									contentIndex: blockIndex,
+									partial: output
+								});
+								stream.push({
+									type: "toolcall_delta",
+									contentIndex: blockIndex,
+									delta: JSON.stringify(toolCall.arguments),
+									partial: output
+								});
+								stream.push({
+									type: "toolcall_end",
+									contentIndex: blockIndex,
+									toolCall,
+									partial: output
+								});
+							}
+						}
+					}
+					if (typeof candidate?.finishReason === "string") {
+						output.stopReason = mapStopReasonString(candidate.finishReason);
+						if (output.content.some((block) => block.type === "toolCall")) {
+							output.stopReason = "toolUse";
+						}
+					}
+				}
+				if (currentBlockIndex >= 0) {
+					pushTextBlockEnd(stream, output, currentBlockIndex);
+				}
+				finalizeTransportStream({
+					stream,
+					output,
+					signal: options?.signal
+				});
+			} catch (error) {
+				failTransportStream({
+					stream,
+					output,
+					signal: options?.signal,
+					error
+				});
+			}
+		})();
+		return eventStream;
+	};
+}
+
+//#endregion
+export { createGoogleGenerativeAiTransportStreamFn };

package/dist/agents/model-catalog-status.js

@@ -1,4 +1,5 @@
 import { normalizeProviderId } from "./provider-id.js";
+import { listCurrentModelCatalogProviderIds } from "./current-model-catalog.js";
 import { deriveModelMetadata } from "./model-metadata.js";
 import { listProviderExtensionCatalogManifestEntries } from "./provider-extension-catalog-manifest.js";
 
@@ -137,7 +138,11 @@ function buildModelCatalogStatus(params) {
 	})).toSorted((left, right) => left.provider.localeCompare(right.provider));
 	const manifestEntries = listProviderExtensionCatalogManifestEntries();
 	const mappedManifestProviderIds = [...new Set(manifestEntries.flatMap((entry) => entry.status === "mapped" ? entry.fasedProviderIds.map(normalizeProviderId) : []))].filter(Boolean).toSorted((left, right) => left.localeCompare(right));
-	const catalogProviderIds = new Set(providerRows.map((provider) => provider.provider));
+	const catalogProviderIds = new Set([
+		...listCurrentModelCatalogProviderIds(),
+		...providerRows.map((provider) => provider.provider),
+		...Object.keys(params.providerExtensionCatalog?.providers ?? {}).map(normalizeProviderId)
+	]);
 	const deferredProviderIds = manifestEntries.filter((entry) => entry.status === "deferred").map((entry) => normalizeProviderId(entry.upstreamProviderId)).filter(Boolean).toSorted((left, right) => left.localeCompare(right));
 	const providerExtensionEntries = (params.providerExtensionCatalog?.entries ?? []).map((entry) => ({
 		id: entry.id,

package/dist/agents/models-config.js

@@ -114,7 +114,8 @@ async function ensureFasedModelsJson(config, agentDirOverride) {
 			}
 			for (const [key, newEntry] of Object.entries(providers)) {
 				const existing = existingProviders[key];
-				if (existing) {
+				const explicitlyConfigured = Object.hasOwn(explicitProviders, key);
+				if (existing && !explicitlyConfigured) {
 					const preserved = {};
 					if (typeof existing.apiKey === "string" && existing.apiKey) {
 						preserved.apiKey = existing.apiKey;

package/dist/agents/openai-completions-compat.js

@@ -0,0 +1,49 @@
+import { resolveProviderRequestCapabilities } from "./provider-attribution.js";
+
+//#region src/agents/openai-completions-compat.ts
+function isDefaultRouteProvider(provider, ...ids) {
+	return provider !== undefined && ids.includes(provider);
+}
+function resolveOpenAICompletionsCompatDefaults(input) {
+	const { endpointClass, knownProviderFamily, supportsNativeStreamingUsageCompat = false, usesExplicitProxyLikeEndpoint = false } = input;
+	const isDefaultRoute = endpointClass === "default";
+	const usesConfiguredNonOpenAIEndpoint = endpointClass !== "default" && endpointClass !== "openai-public";
+	const isMoonshotLike = knownProviderFamily === "moonshot" || knownProviderFamily === "modelstudio" || endpointClass === "moonshot-native" || endpointClass === "modelstudio-native";
+	const isZai = endpointClass === "zai-native" || isDefaultRoute && isDefaultRouteProvider(input.provider, "zai");
+	const isNonStandard = endpointClass === "chutes-native" || endpointClass === "mistral-public" || endpointClass === "opencode-native" || endpointClass === "xai-native" || isZai || isDefaultRoute && isDefaultRouteProvider(input.provider, "chutes", "opencode", "xai");
+	const isOpenRouterLike = input.provider === "openrouter" || endpointClass === "openrouter";
+	const usesMaxTokens = endpointClass === "chutes-native" || endpointClass === "mistral-public" || knownProviderFamily === "mistral" || isDefaultRoute && isDefaultRouteProvider(input.provider, "chutes");
+	return {
+		supportsStore: !isNonStandard && knownProviderFamily !== "mistral" && !usesExplicitProxyLikeEndpoint,
+		supportsDeveloperRole: !isNonStandard && !isMoonshotLike && !usesConfiguredNonOpenAIEndpoint,
+		supportsReasoningEffort: !isZai && endpointClass !== "xai-native" && !usesExplicitProxyLikeEndpoint,
+		supportsUsageInStreaming: !isNonStandard && (!usesConfiguredNonOpenAIEndpoint || supportsNativeStreamingUsageCompat),
+		maxTokensField: usesMaxTokens ? "max_tokens" : "max_completion_tokens",
+		thinkingFormat: isZai ? "zai" : isOpenRouterLike ? "openrouter" : "openai",
+		supportsStrictMode: !isZai && !usesConfiguredNonOpenAIEndpoint
+	};
+}
+function resolveOpenAICompletionsCompatDefaultsFromCapabilities(input) {
+	return resolveOpenAICompletionsCompatDefaults(input);
+}
+function detectOpenAICompletionsCompat(model) {
+	const capabilities = resolveProviderRequestCapabilities({
+		provider: model.provider,
+		api: "openai-completions",
+		baseUrl: model.baseUrl,
+		capability: "llm",
+		transport: "stream",
+		modelId: model.id,
+		compat: model.compat && typeof model.compat === "object" ? model.compat : undefined
+	});
+	return {
+		capabilities,
+		defaults: resolveOpenAICompletionsCompatDefaultsFromCapabilities({
+			provider: model.provider,
+			...capabilities
+		})
+	};
+}
+
+//#endregion
+export { detectOpenAICompletionsCompat };