@oh-my-pi/pi-catalog 16.1.22 → 16.2.0

package/src/provider-models/descriptor-types.ts

@@ -55,7 +55,7 @@ export function allowsUnauthenticatedCatalogDiscovery(descriptor: CatalogProvide
  * - Every entry is a member of `KnownProvider`.
  * - `createModelManagerOptions` present (and not `specialModelManager`) ⇒
  *   appears in `PROVIDER_DESCRIPTORS` for runtime model discovery.
- * - `catalogDiscovery` present ⇒ participates in `generate-models.ts`.
+ * - \`catalogDiscovery\` present ⇒ participates in \`generate-models.ts\`.
  */
 export interface ProviderCatalogEntry {
 	readonly id: string;

package/src/provider-models/descriptors.ts

@@ -14,6 +14,7 @@ import {
 	anthropicModelManagerOptions,
 	cerebrasModelManagerOptions,
 	cloudflareAiGatewayModelManagerOptions,
+	coreWeaveModelManagerOptions,
 	deepseekModelManagerOptions,
 	firepassModelManagerOptions,
 	fireworksModelManagerOptions,
@@ -49,7 +50,12 @@ import {
 	zenmuxModelManagerOptions,
 	zhipuCodingPlanModelManagerOptions,
 } from "./openai-compat";
-import { cursorModelManagerOptions, devinModelManagerOptions, zaiModelManagerOptions } from "./special";
+import {
+	cursorModelManagerOptions,
+	devinModelManagerOptions,
+	gitLabDuoWorkflowModelManagerOptions,
+	zaiModelManagerOptions,
+} from "./special";
 
 export const CATALOG_PROVIDERS = [
 	{
@@ -141,6 +147,13 @@ export const CATALOG_PROVIDERS = [
 		defaultModel: "duo-chat-opus-4-6",
 		envVars: ["GITLAB_TOKEN"],
 	},
+	{
+		id: "gitlab-duo-agent",
+		defaultModel: "claude_sonnet_4_6_vertex",
+		envVars: ["GITLAB_TOKEN"],
+		createModelManagerOptions: (config: ModelManagerConfig) => gitLabDuoWorkflowModelManagerOptions(config),
+		dynamicModelsAuthoritative: true,
+	},
 	{
 		id: "google",
 		defaultModel: "gemini-3.1-pro-preview",
@@ -375,6 +388,13 @@ export const CATALOG_PROVIDERS = [
 			oauthProvider: "wafer-serverless",
 		},
 	},
+	{
+		id: "coreweave",
+		defaultModel: "openai/gpt-oss-120b",
+		envVars: ["COREWEAVE_API_KEY", "WANDB_API_KEY"],
+		createModelManagerOptions: (config: ModelManagerConfig) => coreWeaveModelManagerOptions(config),
+		catalogDiscovery: { label: "CoreWeave Serverless Inference" },
+	},
 	{
 		id: "xai",
 		defaultModel: "grok-4-fast-non-reasoning",

package/src/provider-models/openai-compat.ts

@@ -8,8 +8,9 @@ import { FIREWORKS_FAST_SUFFIX, toFireworksPublicModelId } from "../fireworks-mo
 import { isGlmVisionModelId, isGrokReasoningEffortCapable, isReasoningGlmModelId } from "../identity/family";
 import type { ModelManagerOptions } from "../model-manager";
 import { getBundledModels } from "../models";
-import type { Api, FetchImpl, Model, ModelSpec, Provider, ThinkingConfig } from "../types";
+import type { Api, FetchImpl, Model, ModelSpec, OpenAICompat, Provider, ThinkingConfig } from "../types";
 import { isAnthropicOAuthToken, isRecord, toBoolean, toNumber, toPositiveNumber } from "../utils";
+import { coreWeaveProjectHeaders } from "../wire/coreweave";
 import {
 	COPILOT_API_HEADERS,
 	getGitHubCopilotBaseUrl,
@@ -470,7 +471,19 @@ function isLikelyNanoGptTextModelId(id: string): boolean {
 	return !NANO_GPT_NON_TEXT_MODEL_TOKENS.some(token => normalized.includes(token));
 }
 
-type SimpleProviderConfig = { apiKey?: string; baseUrl?: string; fetch?: FetchImpl };
+type SimpleProviderDiscoveryHeaders = Record<string, string> | (() => Record<string, string> | undefined);
+type SimpleProviderConfig = {
+	apiKey?: string;
+	baseUrl?: string;
+	fetch?: FetchImpl;
+	headers?: SimpleProviderDiscoveryHeaders;
+};
+
+function resolveSimpleProviderHeaders(
+	headers: SimpleProviderDiscoveryHeaders | undefined,
+): Record<string, string> | undefined {
+	return typeof headers === "function" ? headers() : headers;
+}
 
 export function createSimpleOpenAICompletionsOptions(
 	providerId: Parameters<typeof getBundledModels>[0],
@@ -489,6 +502,7 @@ export function createSimpleOpenAICompletionsOptions(
 					provider: providerId,
 					baseUrl,
 					apiKey,
+					headers: resolveSimpleProviderHeaders(config?.headers),
 					mapModel: (entry, defaults) => {
 						const reference = references.get(defaults.id);
 						return mapWithBundledReference(entry, defaults, reference);
@@ -516,6 +530,7 @@ function createSimpleOpenAIResponsesOptions(
 					provider: providerId,
 					baseUrl,
 					apiKey,
+					headers: resolveSimpleProviderHeaders(config?.headers),
 					mapModel: (entry, defaults) => {
 						const reference = references.get(defaults.id);
 						return mapWithBundledReference(entry, defaults, reference);
@@ -1051,7 +1066,7 @@ function applyXAIOAuthCuration(dynamic: readonly ModelSpec<"openai-responses">[]
  * Single source of truth for the curated to Model fan-in, consumed by both
  * - {@link xaiOAuthModelManagerOptions} (runtime static seed handed to the model
  *   manager so the picker is populated on a fresh login), and
- * - `packages/ai/scripts/generate-models.ts` (bundles the same entries into
+ * - \`packages/catalog/scripts/generate-models.ts\` (bundles the same entries into
  *   `models.json`, so the synchronous `ModelRegistry.#loadModels()` boot path
  *   sees `xai-oauth` without waiting for a refresh — fixes the boot-time
  *   default-model reset when `modelRoles.default = "xai-oauth/<id>"`).
@@ -1100,7 +1115,7 @@ export function xaiOAuthModelManagerOptions(
 	// Static seed handed to the runtime model manager so the picker populates on
 	// a fresh login even before `fetchDynamicModels` fires (it is gated on
 	// `config.apiKey` at construction time, and OAuth tokens resolve later via
-	// AuthStorage). `generate-models.ts` calls the same builder so `models.json`
+	// AuthStorage). \`generate-models.ts\` calls the same builder so \`models.json\`
 	// carries these entries too — making the synchronous `#loadModels()` boot
 	// path honor `modelRoles.default = "xai-oauth/<id>"` without `await refresh()`.
 	const staticModels = buildXaiOAuthStaticSeed(resolvedBaseUrl);
@@ -2480,6 +2495,25 @@ export function togetherModelManagerOptions(
 	return createSimpleOpenAICompletionsOptions("together", "https://api.together.xyz/v1", config);
 }
 
+// ---------------------------------------------------------------------------
+// 15.5 CoreWeave Serverless Inference
+// ---------------------------------------------------------------------------
+
+export interface CoreWeaveModelManagerConfig {
+	apiKey?: string;
+	baseUrl?: string;
+	fetch?: FetchImpl;
+}
+
+export function coreWeaveModelManagerOptions(
+	config?: CoreWeaveModelManagerConfig,
+): ModelManagerOptions<"openai-completions"> {
+	return createSimpleOpenAICompletionsOptions("coreweave", "https://api.inference.wandb.ai/v1", {
+		...config,
+		headers: () => coreWeaveProjectHeaders(Bun.env),
+	});
+}
+
 // ---------------------------------------------------------------------------
 // 16. Moonshot
 // ---------------------------------------------------------------------------
@@ -2783,6 +2817,231 @@ export interface LiteLLMModelManagerConfig {
 	fetch?: FetchImpl;
 }
 
+export interface FetchLiteLLMRichModelsOptions<TApi extends Api> {
+	api: TApi;
+	provider: Provider;
+	baseUrl: string;
+	apiKey?: string;
+	headers?: Record<string, string>;
+	fetch?: FetchImpl;
+	signal?: AbortSignal;
+	referenceResolver?: (modelId: string) => ModelSpec<TApi> | undefined;
+}
+
+type LiteLLMRichModelEntry = Record<string, unknown>;
+
+const LITELLM_RICH_ENDPOINTS = ["/model_group/info", "/v2/model/info", "/model/info", "/v1/model/info"] as const;
+export const OPENAI_COMPAT_DISCOVERY_DEFAULT_CONTEXT_WINDOW = 128_000;
+export const OPENAI_COMPAT_DISCOVERY_DEFAULT_MAX_TOKENS = 32_768;
+const UNKNOWN_PROXY_COST = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 } as const;
+
+export function normalizeLiteLLMManagementBaseUrl(baseUrl: string): string {
+	const trimmed = baseUrl.trim().replace(/\/+$/g, "");
+	if (!trimmed) {
+		return "";
+	}
+	try {
+		const parsed = new URL(trimmed);
+		const path = parsed.pathname.replace(/\/+$/g, "");
+		parsed.pathname = path.endsWith("/v1") ? path.slice(0, -3) || "/" : path || "/";
+		const normalized = `${parsed.protocol}//${parsed.host}${parsed.pathname}`;
+		return normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
+	} catch {
+		return trimmed.replace(/\/v1$/, "");
+	}
+}
+
+function normalizeLiteLLMRuntimeBaseUrl(baseUrl: string): string {
+	const trimmed = baseUrl.trim();
+	return trimmed.endsWith("/") ? trimmed.slice(0, -1) : trimmed;
+}
+
+function toNonEmptyString(value: unknown): string | undefined {
+	if (typeof value !== "string") {
+		return undefined;
+	}
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : undefined;
+}
+
+function extractLiteLLMRichEntries(payload: unknown): LiteLLMRichModelEntry[] | null {
+	if (Array.isArray(payload)) {
+		return payload.flatMap(entry => (isRecord(entry) ? [entry] : []));
+	}
+	if (!isRecord(payload)) {
+		return null;
+	}
+	for (const candidate of [payload.data, payload.models, payload.result, payload.items]) {
+		if (candidate === undefined) {
+			continue;
+		}
+		const entries = extractLiteLLMRichEntries(candidate);
+		if (entries !== null) {
+			return entries;
+		}
+	}
+	return null;
+}
+
+function getLiteLLMModelInfo(entry: LiteLLMRichModelEntry): LiteLLMRichModelEntry | undefined {
+	return isRecord(entry.model_info) ? entry.model_info : undefined;
+}
+
+function getLiteLLMParams(entry: LiteLLMRichModelEntry): LiteLLMRichModelEntry | undefined {
+	return isRecord(entry.litellm_params) ? entry.litellm_params : undefined;
+}
+
+function getLiteLLMMetadataValue(entry: LiteLLMRichModelEntry, key: string): unknown {
+	return entry[key] ?? getLiteLLMModelInfo(entry)?.[key];
+}
+
+function getLiteLLMRichModelId(entry: LiteLLMRichModelEntry): string | undefined {
+	return (
+		toNonEmptyString(entry.model_group) ??
+		toNonEmptyString(entry.model_name) ??
+		toNonEmptyString(entry.id) ??
+		toNonEmptyString(getLiteLLMParams(entry)?.model)
+	);
+}
+
+function getSupportedOpenAIParams(entry: LiteLLMRichModelEntry): string[] | undefined {
+	const value = getLiteLLMMetadataValue(entry, "supported_openai_params");
+	if (!Array.isArray(value)) {
+		return undefined;
+	}
+	return value.flatMap(item => (typeof item === "string" ? [item] : []));
+}
+
+function mapLiteLLMRichEntry<TApi extends Api>(
+	entry: LiteLLMRichModelEntry,
+	options: FetchLiteLLMRichModelsOptions<TApi>,
+	runtimeBaseUrl: string,
+): ModelSpec<TApi> | null {
+	const id = getLiteLLMRichModelId(entry);
+	if (!id) {
+		return null;
+	}
+	const reference = options.referenceResolver?.(id);
+	const modelName = toNonEmptyString(entry.model_name);
+	const contextWindow = toPositiveNumber(
+		getLiteLLMMetadataValue(entry, "max_input_tokens"),
+		reference?.contextWindow ?? OPENAI_COMPAT_DISCOVERY_DEFAULT_CONTEXT_WINDOW,
+	);
+	const maxTokens = toPositiveNumber(
+		getLiteLLMMetadataValue(entry, "max_output_tokens"),
+		reference?.maxTokens ?? Math.min(contextWindow, OPENAI_COMPAT_DISCOVERY_DEFAULT_MAX_TOKENS),
+	);
+	const supportsVision = getLiteLLMMetadataValue(entry, "supports_vision");
+	const supportsReasoning = getLiteLLMMetadataValue(entry, "supports_reasoning");
+	const supportedOpenAIParams = getSupportedOpenAIParams(entry);
+	const supportsFunctionCalling = getLiteLLMMetadataValue(entry, "supports_function_calling");
+	const supportsTools =
+		supportsFunctionCalling === true
+			? true
+			: supportsFunctionCalling === false
+				? false
+				: supportedOpenAIParams !== undefined
+					? supportedOpenAIParams.some(param =>
+							["tools", "tool_choice", "functions", "function_call"].includes(param),
+						)
+					: reference?.supportsTools;
+	const compat: OpenAICompat = {
+		...(reference?.compat ?? {}),
+		supportsStore: false,
+		supportsDeveloperRole: false,
+		...(supportedOpenAIParams !== undefined
+			? { supportsReasoningEffort: supportedOpenAIParams.includes("reasoning_effort") }
+			: {}),
+	};
+	return {
+		id,
+		name: modelName && modelName !== id ? modelName : (reference?.name ?? id),
+		api: options.api,
+		provider: options.provider,
+		baseUrl: runtimeBaseUrl,
+		contextWindow,
+		maxTokens,
+		input:
+			supportsVision === true
+				? ["text", "image"]
+				: supportsVision === false
+					? ["text"]
+					: (reference?.input ?? ["text"]),
+		reasoning: typeof supportsReasoning === "boolean" ? supportsReasoning : (reference?.reasoning ?? false),
+		thinking: reference?.thinking,
+		cost: reference?.cost ?? UNKNOWN_PROXY_COST,
+		...(supportsTools !== undefined ? { supportsTools } : {}),
+		compat: compat as ModelSpec<TApi>["compat"],
+	};
+}
+
+async function fetchLiteLLMRichEndpoint<TApi extends Api>(
+	endpoint: string,
+	options: FetchLiteLLMRichModelsOptions<TApi>,
+	managementBaseUrl: string,
+	runtimeBaseUrl: string,
+): Promise<ModelSpec<TApi>[] | null> {
+	const fetchImpl = options.fetch ?? globalThis.fetch;
+	const requestHeaders: Record<string, string> = {
+		Accept: "application/json",
+		...options.headers,
+	};
+	if (options.apiKey) {
+		requestHeaders.Authorization = `Bearer ${options.apiKey}`;
+	}
+	let response: Response;
+	try {
+		response = await fetchImpl(`${managementBaseUrl}${endpoint}`, {
+			method: "GET",
+			headers: requestHeaders,
+			signal: options.signal,
+		});
+	} catch {
+		return null;
+	}
+	if (!response.ok) {
+		return null;
+	}
+	let payload: unknown;
+	try {
+		payload = await response.json();
+	} catch {
+		return null;
+	}
+	const entries = extractLiteLLMRichEntries(payload);
+	if (!entries || entries.length === 0) {
+		return null;
+	}
+	const deduped = new Map<string, ModelSpec<TApi>>();
+	for (const entry of entries) {
+		const model = mapLiteLLMRichEntry(entry, options, runtimeBaseUrl);
+		if (model) {
+			deduped.set(model.id, model);
+		}
+	}
+	if (deduped.size === 0) {
+		return null;
+	}
+	return Array.from(deduped.values()).sort((left, right) => left.id.localeCompare(right.id));
+}
+
+export async function fetchLiteLLMRichModels<TApi extends Api>(
+	options: FetchLiteLLMRichModelsOptions<TApi>,
+): Promise<ModelSpec<TApi>[] | null> {
+	const managementBaseUrl = normalizeLiteLLMManagementBaseUrl(options.baseUrl);
+	const runtimeBaseUrl = normalizeLiteLLMRuntimeBaseUrl(options.baseUrl);
+	if (!managementBaseUrl || !runtimeBaseUrl) {
+		return null;
+	}
+	for (const endpoint of LITELLM_RICH_ENDPOINTS) {
+		const models = await fetchLiteLLMRichEndpoint(endpoint, options, managementBaseUrl, runtimeBaseUrl);
+		if (models) {
+			return models;
+		}
+	}
+	return null;
+}
+
 export function litellmModelManagerOptions(
 	config?: LiteLLMModelManagerConfig,
 ): ModelManagerOptions<"openai-completions"> {
@@ -2790,21 +3049,32 @@ export function litellmModelManagerOptions(
 	const baseUrl = config?.baseUrl ?? Bun.env.LITELLM_BASE_URL ?? "http://localhost:4000/v1";
 	return {
 		providerId: "litellm",
-		cacheProviderId: `litellm:${Bun.hash(baseUrl).toString(36)}`,
-		// litellm is a local-only proxy whose /v1/models returns bare ids with no
-		// metadata, and it is never bundled in models.json (that would leak the
-		// machine's localhost catalog). It proxies known upstream models, so we
-		// enrich discovered ids against models.dev — the same reference source the
-		// gateway providers (fireworks et al.) use — instead of a bundled map.
+		cacheProviderId: `litellm:rich-v1:${Bun.hash(baseUrl).toString(36)}`,
+		// litellm is a local-only proxy and is never bundled in models.json (that
+		// would leak the machine's localhost catalog). Prefer the proxy's richer
+		// management metadata, then fall back to /v1/models and enrich bare ids
+		// against models.dev like the gateway providers (fireworks et al.) do.
 		fetchDynamicModels: async () => {
 			const modelsDevReferences = await loadModelsDevReferences<"openai-completions">(config?.fetch);
+			const resolveReference = (id: string) => modelsDevReferences.get(id);
+			const richModels = await fetchLiteLLMRichModels({
+				api: "openai-completions",
+				provider: "litellm",
+				baseUrl,
+				apiKey,
+				fetch: config?.fetch,
+				referenceResolver: resolveReference,
+				signal: AbortSignal.timeout(10_000),
+			});
+			if (richModels && richModels.length > 0) {
+				return richModels;
+			}
 			return fetchOpenAICompatibleModels({
 				api: "openai-completions",
 				provider: "litellm",
 				baseUrl,
 				apiKey,
-				mapModel: (entry, defaults) =>
-					mapWithBundledReference(entry, defaults, modelsDevReferences.get(defaults.id)),
+				mapModel: (entry, defaults) => mapWithBundledReference(entry, defaults, resolveReference(defaults.id)),
 				fetch: config?.fetch,
 			});
 		},
@@ -3653,6 +3923,19 @@ const MODELS_DEV_PROVIDER_DESCRIPTORS_CORE: readonly ModelsDevProviderDescriptor
 	openAiCompletionsDescriptor("cerebras", "cerebras", "https://api.cerebras.ai/v1"),
 	// --- Together ---
 	openAiCompletionsDescriptor("togetherai", "together", "https://api.together.xyz/v1"),
+	// --- CoreWeave Serverless Inference ---
+	openAiCompletionsDescriptor("wandb", "coreweave", "https://api.inference.wandb.ai/v1", {
+		transformModel: model => {
+			if (!model.id.startsWith("openai/gpt-oss-")) {
+				return model;
+			}
+			return {
+				...model,
+				reasoning: true,
+				thinking: { mode: "effort", efforts: [Effort.Low, Effort.Medium, Effort.High] },
+			};
+		},
+	}),
 	// --- NVIDIA ---
 	openAiCompletionsDescriptor("nvidia", "nvidia", "https://integrate.api.nvidia.com/v1", {
 		defaultContextWindow: 131072,

package/src/provider-models/special.ts

@@ -1,7 +1,9 @@
 import { once } from "@oh-my-pi/pi-utils";
 import { fetchCodexModels } from "../discovery/codex";
 import type { DevinModelDiscoveryOptions } from "../discovery/devin";
+import { buildGitLabDuoWorkflowFallbackModel, fetchGitLabDuoWorkflowModels } from "../discovery/gitlab-duo-workflow";
 import type { ModelManagerOptions } from "../model-manager";
+import type { FetchImpl } from "../types";
 
 // ---------------------------------------------------------------------------
 // OpenAI Codex
@@ -58,6 +60,68 @@ export function cursorModelManagerOptions(config: CursorModelManagerConfig = {})
 const cursorDiscovery = once(() => import("../discovery/cursor"));
 
 // ---------------------------------------------------------------------------
+// GitLab Duo Workflow
+// ---------------------------------------------------------------------------
+
+export interface GitLabDuoWorkflowModelManagerConfig {
+	apiKey?: string;
+	baseUrl?: string;
+	fetch?: FetchImpl;
+	namespaceId?: string;
+	projectId?: string;
+	cwd?: string;
+}
+
+export function gitLabDuoWorkflowModelManagerOptions(
+	config: GitLabDuoWorkflowModelManagerConfig = {},
+): ModelManagerOptions<"gitlab-duo-agent"> {
+	const apiKey = config.apiKey;
+	return {
+		providerId: "gitlab-duo-agent",
+		// GitLab Duo discovery is credential- and namespace-specific
+		// (`aiChatAvailableModels(rootNamespaceId:)` also surfaces namespace-pinned
+		// models), so the default provider-id cache namespace would let a second
+		// account/namespace load the first one's authoritative model list at startup
+		// and skip refetching. Partition the cache by a non-reversible fingerprint of
+		// the exact inputs `fetchGitLabDuoWorkflowModels` resolves the namespace from
+		// (credential + base URL + namespace/project config + the same env vars + the
+		// effective workspace cwd whose git remote drives auto-discovery). Built-in
+		// discovery only passes apiKey/baseUrl/fetch, so the cwd/env terms — not the
+		// empty config fields — are what actually separate workspace A from B here.
+		// Falls back to the bare provider id when no credential is present.
+		...(apiKey ? { cacheProviderId: gitLabDuoWorkflowModelCacheProviderId(apiKey, config) } : undefined),
+		dynamicModelsAuthoritative: true,
+		staticModels: [
+			buildGitLabDuoWorkflowFallbackModel("claude_sonnet_4_6_vertex", "Claude Sonnet 4.6 - Vertex", config.baseUrl),
+		],
+		...(apiKey
+			? {
+					fetchDynamicModels: async () =>
+						fetchGitLabDuoWorkflowModels({
+							apiKey,
+							baseUrl: config.baseUrl,
+							fetch: config.fetch,
+							namespaceId: config.namespaceId,
+							projectId: config.projectId,
+							cwd: config.cwd,
+						}),
+				}
+			: undefined),
+	};
+}
+
+function gitLabDuoWorkflowModelCacheProviderId(apiKey: string, config: GitLabDuoWorkflowModelManagerConfig): string {
+	// Mirror the exact inputs `discoverGitLabDuoWorkflowNamespace` keys off: explicit
+	// namespace/project config OR the same env vars, then the git remote at the
+	// effective cwd. Built-in discovery leaves the config fields empty, so the env +
+	// resolved cwd terms are what actually distinguish two workspaces sharing a token.
+	const namespaceId = config.namespaceId ?? Bun.env.GITLAB_DUO_NAMESPACE_ID ?? "";
+	const projectId = config.projectId ?? Bun.env.GITLAB_DUO_PROJECT_ID ?? Bun.env.GITLAB_DUO_PROJECT_PATH ?? "";
+	const cwd = config.cwd ?? process.cwd();
+	const scope = [config.baseUrl ?? "", namespaceId, projectId, cwd].join("\u0000");
+	return `gitlab-duo-agent:${Bun.hash(`${apiKey}\u0000${scope}`).toString(36)}`;
+}
+
 // Devin (Codeium Cascade)
 // ---------------------------------------------------------------------------
 
@@ -84,7 +148,6 @@ export function devinModelManagerOptions(config: DevinModelManagerConfig = {}):
 }
 
 const devinDiscovery = once(() => import("../discovery/devin"));
-
 // ---------------------------------------------------------------------------
 // Zai
 // ---------------------------------------------------------------------------

package/src/types.ts

@@ -15,6 +15,7 @@ export type KnownApi =
 	| "google-vertex"
 	| "ollama-chat"
 	| "cursor-agent"
+	| "gitlab-duo-agent"
 	| "devin-agent";
 export type Api = KnownApi | (string & {});
 
@@ -236,6 +237,28 @@ export interface OpenAICompat {
 	 * models).
 	 */
 	replayReasoningContent?: boolean;
+	/**
+	 * Send `preserve_thinking: true` so the Qwen3.6+ chat template renders
+	 * `<think>...</think>` markup for EVERY assistant turn (not just turns
+	 * after the last user message). Without it, the template strips the think
+	 * block from older assistant turns:
+	 *
+	 * ```jinja
+	 * {%- if (preserve_thinking is defined and preserve_thinking is true)
+	 *        or (loop.index0 > ns.last_query_index) %}
+	 *   <|im_start|>assistant\n<think>\n{rc}\n</think>\n\n{content}
+	 * {%- else %}
+	 *   <|im_start|>assistant\n{content}
+	 * ```
+	 *
+	 * The cache from the original generation has `<think>...</think>` tokens,
+	 * so once a new user message arrives the prior assistant turns become
+	 * "older" and the stripped re-render diverges — full prompt re-processing
+	 * on SWA models (#3541). Default: auto-detected (Qwen thinking format on
+	 * a local llama.cpp-style backend, paired with `replayReasoningContent`).
+	 * Non-Qwen templates ignore the flag, so the auto-detection is safe.
+	 */
+	qwenPreserveThinking?: boolean;
 	/** Whether assistant tool-call messages must include non-empty content. Default: false. */
 	requiresAssistantContentForToolCalls?: boolean;
 	/** Whether the provider supports the `tool_choice` parameter. Default: true. */
@@ -246,6 +269,14 @@ export interface OpenAICompat {
 	 * to provider-default auto selection. Default: true.
 	 */
 	supportsForcedToolChoice?: boolean;
+	/**
+	 * Whether the chat-completions endpoint accepts the object form that pins one
+	 * named function (`{ type: "function", function: { name } }`). Some
+	 * OpenAI-compatible hosts such as llama.cpp only accept string
+	 * `tool_choice` values; request builders downgrade a named force to
+	 * `"required"` when this is false. Default: true.
+	 */
+	supportsNamedToolChoice?: boolean;
 	/**
 	 * Drop reasoning fields (`reasoning_effort`, OpenRouter `reasoning`) for
 	 * the request when `tool_choice` forces a tool call. Mirrors the Anthropic
@@ -443,11 +474,13 @@ export interface ResolvedOpenAISharedCompat {
 	disableReasoningOnToolChoice: boolean;
 	supportsToolChoice: boolean;
 	supportsForcedToolChoice: boolean;
+	supportsNamedToolChoice: boolean;
 	reasoningContentField?: OpenAICompat["reasoningContentField"];
 	requiresReasoningContentForToolCalls: boolean;
 	requiresReasoningContentForAllAssistantTurns: boolean;
 	allowsSyntheticReasoningContentForToolCalls: boolean;
 	replayReasoningContent: boolean;
+	qwenPreserveThinking: boolean;
 	requiresThinkingAsText: boolean;
 	requiresMistralToolIds: boolean;
 	requiresToolResultName: boolean;
@@ -493,11 +526,13 @@ export type ResolvedOpenAICompat = ResolvedOpenAISharedCompat &
 			| "disableReasoningOnToolChoice"
 			| "supportsToolChoice"
 			| "supportsForcedToolChoice"
+			| "supportsNamedToolChoice"
 			| "reasoningContentField"
 			| "requiresReasoningContentForToolCalls"
 			| "requiresReasoningContentForAllAssistantTurns"
 			| "allowsSyntheticReasoningContentForToolCalls"
 			| "replayReasoningContent"
+			| "qwenPreserveThinking"
 			| "requiresThinkingAsText"
 			| "requiresMistralToolIds"
 			| "requiresToolResultName"
@@ -618,6 +653,18 @@ export type CompatOf<TApi extends Api> = TApi extends "openrouter"
 					? ResolvedDevinCompat
 					: undefined;
 
+/** Provider-native compaction endpoint configuration for one model. */
+export interface RemoteCompactionConfig<TApi extends Api = Api> {
+	/** Enables provider-native compaction for providers not enabled by built-in policy. */
+	enabled?: boolean;
+	/** Adapter family used by the configured compaction endpoint. */
+	api?: TApi;
+	/** Absolute compact endpoint URL; when omitted, the adapter derives it from the model base URL. */
+	endpoint?: string;
+	/** Model id sent to the compaction endpoint when it differs from the active model id. */
+	model?: string;
+}
+
 // Model interface for the unified model system
 export interface Model<TApi extends Api = Api> {
 	id: string;
@@ -648,6 +695,8 @@ export interface Model<TApi extends Api = Api> {
 	 * reports that native tool calling is unsupported.
 	 */
 	supportsTools?: boolean;
+	/** GitLab Duo Workflow root namespace selected during catalog discovery. */
+	gitlabDuoWorkflowRootNamespaceId?: string;
 	cost: {
 		input: number; // $/million tokens
 		output: number; // $/million tokens
@@ -690,6 +739,10 @@ export interface Model<TApi extends Api = Api> {
 	preferWebsockets?: boolean;
 	/** Preferred model to switch to when context promotion is triggered (model id or provider/id). */
 	contextPromotionTarget?: string;
+	/** Preferred model to use only for compaction (model id or provider/id); the active session model is unchanged. */
+	compactionModel?: string;
+	/** Provider-native compaction endpoint configuration. */
+	remoteCompaction?: RemoteCompactionConfig<TApi>;
 	/** Provider-assigned priority value (lower = higher priority). */
 	priority?: number;
 	/** Canonical thinking capability metadata for this model. */

package/src/wire/coreweave.ts

@@ -0,0 +1,42 @@
+export const COREWEAVE_PROJECT_HEADER = "OpenAI-Project" as const;
+
+export interface CoreWeaveProjectEnv {
+	[key: string]: string | undefined;
+	COREWEAVE_PROJECT?: string;
+	WANDB_INFERENCE_PROJECT?: string;
+	WANDB_ENTITY?: string;
+	WANDB_PROJECT?: string;
+}
+
+function cleanEnvValue(value: string | undefined): string | undefined {
+	const trimmed = value?.trim();
+	return trimmed ? trimmed : undefined;
+}
+
+export function resolveCoreWeaveProject(env: CoreWeaveProjectEnv): string | undefined {
+	const explicitProject = cleanEnvValue(env.COREWEAVE_PROJECT) ?? cleanEnvValue(env.WANDB_INFERENCE_PROJECT);
+	if (explicitProject) {
+		return explicitProject;
+	}
+
+	const wandbProject = cleanEnvValue(env.WANDB_PROJECT);
+	if (!wandbProject) {
+		return undefined;
+	}
+	if (wandbProject.includes("/")) {
+		return wandbProject;
+	}
+
+	const wandbEntity = cleanEnvValue(env.WANDB_ENTITY);
+	return wandbEntity ? `${wandbEntity}/${wandbProject}` : undefined;
+}
+
+export function coreWeaveProjectHeaders(env: CoreWeaveProjectEnv): Record<string, string> | undefined {
+	const project = resolveCoreWeaveProject(env);
+	return project ? { [COREWEAVE_PROJECT_HEADER]: project } : undefined;
+}
+
+export function hasCoreWeaveProjectHeader(headers: Record<string, string>): boolean {
+	const normalized = COREWEAVE_PROJECT_HEADER.toLowerCase();
+	return Object.keys(headers).some(header => header.toLowerCase() === normalized);
+}