ghc-proxy 0.7.0 → 0.7.2

package/README.md

@@ -195,6 +195,8 @@ All fields are optional. The full schema:
 | `responsesApiAutoCompactInput` | `boolean` | `false` | Automatically trim Responses `input` to the latest `compaction` item |
 | `responsesApiAutoContextManagement` | `boolean` | `false` | Automatically inject Responses `context_management` for selected models |
 | `responsesApiContextManagementModels` | `string[]` | -- | Models eligible for auto-injected Responses `context_management` |
+| `responsesApiParameterFilters` | `{ models, params }[]` | -- | Extra rules to strip request parameters on the Responses boundary (see [Responses Parameter Filters](#responses-parameter-filters)) |
+| `responsesApiParameterFiltersReplaceDefault` | `boolean` | `false` | Disable the built-in reasoning-model default rule so only your `responsesApiParameterFilters` apply |
 | `responsesOfficialEmulator` | `boolean` | `false` | Enable local OpenAI-style Responses state emulation for `previous_response_id`, `conversation`, retrieve, input_items, delete, and input_tokens |
 | `responsesOfficialEmulatorTtlSeconds` | `number` | `14400` | In-memory TTL for locally emulated Responses state |
 | `modelReasoningEfforts` | `Record<string, string>` | -- | Per-model reasoning effort defaults for Anthropic-to-Responses translation |
@@ -381,6 +383,7 @@ This keeps the existing chat pipeline stable while allowing newer Copilot models
 - automatic Responses `context_management` injection is disabled by default and only applies when `responsesApiAutoContextManagement` is `true` and the model matches `responsesApiContextManagementModels`
 - automatic trimming of Responses `input` to the latest `compaction` item is disabled by default and only applies when `responsesApiAutoCompactInput` is `true`
 - reasoning defaults for Anthropic -> Responses translation can be tuned with `modelReasoningEfforts`
+- request parameters that a model rejects (e.g. `temperature`/`top_p` on reasoning models) are stripped on the Responses boundary rather than leaked upstream as a `400`; see [Responses Parameter Filters](#responses-parameter-filters)
 - known unsupported builtin tools, such as `web_search`, fail explicitly with `400` instead of being silently removed
 - external image URLs on the Responses path fail explicitly with `400`; use `file_id` or data URL image input instead
 - official `input_file` and `item_reference` input items are modeled explicitly and validated before forwarding
@@ -399,6 +402,28 @@ Example opt-in configuration for these two Responses-specific policies:
 
 > See [Responses Upstream Notes](./docs/responses-upstream-notes.md) for detailed upstream compatibility observations from live testing.
 
+### Responses Parameter Filters
+
+Some Copilot models reject request parameters that the OpenAI wire format allows. The clearest case: **reasoning models** (the `gpt-5` family, o-series, codex) reject sampling parameters and answer `POST /responses` with `400 Unsupported parameter: 'temperature' is not supported with this model.` Since the client cannot always be changed, the proxy strips the offending parameters on the Responses boundary instead of leaking the incompatibility outward.
+
+This is expressed as a small rule engine that runs on both the native `/v1/responses` path and the `/v1/messages` → Responses translation path:
+
+- **Built-in default rule:** any model that advertises `reasoning_effort` has `temperature` and `top_p` stripped. This covers the whole reasoning family (including future point releases like `gpt-5.4-mini`) with no configuration.
+- **`responsesApiParameterFilters`:** add your own rules. Each rule is `{ "models": [glob, ...], "params": [name, ...] }`; every rule whose `models` glob matches the resolved model contributes its `params`. Rules are **added** to the default (the union of parameters is stripped). Model globs use the same `*` wildcard as `modelRewrites`.
+- **`responsesApiParameterFiltersReplaceDefault`:** set to `true` to disable the built-in reasoning-model rule, so only your `responsesApiParameterFilters` apply — use this to fully **overwrite** the default behavior.
+
+Stripped parameters are removed entirely (never sent as `null`), because upstream rejects the mere presence of the key.
+
+```json
+{
+  "responsesApiParameterFilters": [
+    { "models": ["gpt-5*", "o1*"], "params": ["temperature", "top_p"] },
+    { "models": ["some-model"], "params": ["top_k"] }
+  ],
+  "responsesApiParameterFiltersReplaceDefault": false
+}
+```
+
 ## Docker
 
 Pre-built images are available on GHCR:

package/dist/main.mjs

@@ -5754,6 +5754,11 @@ const configFileSchema = object({
 	responsesApiAutoCompactInput: boolean().optional(),
 	responsesApiAutoContextManagement: boolean().optional(),
 	responsesApiContextManagementModels: array(string()).optional(),
+	responsesApiParameterFilters: array(object({
+		models: array(string()).min(1),
+		params: array(string()).min(1)
+	})).optional(),
+	responsesApiParameterFiltersReplaceDefault: boolean().optional(),
 	responsesOfficialEmulator: boolean().optional(),
 	responsesOfficialEmulatorTtlSeconds: number().int().positive().optional(),
 	modelReasoningEfforts: record(string(), reasoningEffortSchema).optional(),
@@ -5871,6 +5876,12 @@ var ConfigStore = class {
 	getReasoningEffort(model) {
 		return getCachedConfig().modelReasoningEfforts?.[model] ?? "high";
 	}
+	getResponsesParameterFilters() {
+		return getCachedConfig().responsesApiParameterFilters ?? [];
+	}
+	shouldReplaceDefaultParameterFilters() {
+		return getCachedConfig().responsesApiParameterFiltersReplaceDefault ?? false;
+	}
 	getModelRewrites() {
 		return getCachedConfig().modelRewrites ?? [];
 	}
@@ -5933,6 +5944,9 @@ var ModelCache = class {
 	supportsVision(model) {
 		return model?.capabilities.supports.vision ?? false;
 	}
+	supportsReasoningEffort(model) {
+		return (model?.capabilities.supports.reasoning_effort?.length ?? 0) > 0;
+	}
 	supportsOutputConfig(model) {
 		if (!model) return true;
 		return !MODELS_REJECTING_OUTPUT_CONFIG.has(model.id);
@@ -7350,7 +7364,7 @@ const checkUsage = defineCommand({
 });
 //#endregion
 //#region src/util/version.ts
-const VERSION = "0.7.0";
+const VERSION = "0.7.2";
 //#endregion
 //#region src/debug.ts
 function getRuntimeInfo() {
@@ -48603,10 +48617,15 @@ const anthropicMcpToolUseBlockSchema = object({
 	input: jsonObjectSchema,
 	server_name: string().min(1)
 }).loose();
+const anthropicDocumentBlockSchema = object({
+	type: literal("document"),
+	source: jsonObjectSchema
+}).loose();
 const anthropicToolResultContentBlockSchema = union([
 	anthropicTextBlockSchema,
 	anthropicImageBlockSchema,
-	anthropicSearchResultBlockSchema
+	anthropicSearchResultBlockSchema,
+	anthropicDocumentBlockSchema
 ]);
 const anthropicToolResultBlockSchema = object({
 	type: literal("tool_result"),
@@ -48634,10 +48653,6 @@ const anthropicServerToolResultBlockSchema = object({
 	content: unknown(),
 	is_error: boolean().optional()
 }).loose();
-const anthropicDocumentBlockSchema = object({
-	type: literal("document"),
-	source: jsonObjectSchema
-}).loose();
 const anthropicMessageSchema = union([
 	object({
 		role: literal("user"),
@@ -49624,6 +49639,31 @@ function normalizeOutputConfigEffort(effort, model) {
 function hasOutputConfigFormat(payload) {
 	return payload?.output_config?.format != null;
 }
+function budgetTokensToEffort(budget) {
+	if (budget >= 24e3) return "high";
+	if (budget >= 8e3) return "medium";
+	return "low";
+}
+/**
+* Models whose upstream `/v1/messages` endpoint only accepts the adaptive
+* thinking API reject the classic `thinking.type: "enabled"` shape with a 400.
+* Convert `enabled` → `adaptive` (+ derive `output_config.effort` from the
+* requested `budget_tokens`) for those models before forwarding. Models that
+* do not advertise `adaptive_thinking` keep the classic `enabled` shape.
+*
+* Must run before `sanitizeOutputConfig` so the derived effort is normalized
+* against the model's advertised efforts.
+*/
+function convertEnabledThinkingToAdaptive(payload, model) {
+	if (payload.thinking?.type !== "enabled") return;
+	if (!modelCache.supportsAdaptiveThinking(model)) return;
+	const budget = payload.thinking.budget_tokens;
+	payload.thinking = { type: "adaptive" };
+	if (payload.output_config?.effort == null && modelCache.supportsOutputConfig(model)) payload.output_config = {
+		...payload.output_config,
+		effort: budgetTokensToEffort(budget)
+	};
+}
 function sanitizeOutputConfig(payload, model) {
 	if (!payload.output_config) return;
 	if (!modelCache.supportsOutputConfig(model)) {
@@ -49654,6 +49694,44 @@ const messagesModelChain = composeModelTransforms(rewriteStep, modelPolicyStep);
 const chatCompletionsModelChain = composeModelTransforms(rewriteStep);
 const responsesModelChain = composeModelTransforms(rewriteStep);
 //#endregion
+//#region src/translator/anthropic/document.ts
+/** Trimmed text of a `content`-source document part, or undefined when it carries none. */
+function documentPartText(part) {
+	if (part && typeof part === "object" && typeof part.text === "string") return part.text.trim() || void 0;
+}
+/** A short reference identifying a non-text document source, or '' when none is available. */
+function documentSourceRef(source) {
+	if (typeof source.url === "string") return `: ${source.url}`;
+	if (typeof source.file_id === "string") return `: ${source.file_id}`;
+	if (typeof source.media_type === "string") return `: ${source.media_type}`;
+	return "";
+}
+/**
+* Flatten an Anthropic `document` content block to plain text for translation
+* paths that cannot carry an attachment (Chat Completions, and the native
+* mixed-search-result flatten path). Text and content sources inline their
+* text; file/url/base64 sources have no text to inline, so they degrade to a
+* reference-labelled placeholder (mirroring `[image omitted: <media_type>]`)
+* rather than a content-free token. Anthropic allows `document` blocks inside
+* `tool_result.content` alongside `text`, `image`, and `search_result`.
+*/
+function formatDocumentBlock(block) {
+	const source = block.source;
+	if (source.type === "text" && typeof source.data === "string") {
+		const text = source.data.trim();
+		return text ? `[document]\n${text}` : "[document]";
+	}
+	if (source.type === "content" && Array.isArray(source.content)) {
+		const parts = [];
+		for (const part of source.content) {
+			const text = documentPartText(part);
+			if (text) parts.push(text);
+		}
+		return parts.length ? `[document]\n${parts.join("\n")}` : "[document]";
+	}
+	return `[document${documentSourceRef(source)}]`;
+}
+//#endregion
 //#region src/translator/anthropic/search-result.ts
 function formatSearchResultBlock(block) {
 	const content = block.content.map((part) => part.text.trim()).filter(Boolean).join("\n");
@@ -49697,6 +49775,7 @@ function normalizeToolResultContentValue(content) {
 			case "text": return textBlock(contentBlock.text);
 			case "image": return imageBlock(contentBlock.source.media_type, contentBlock.source.data);
 			case "search_result": return textBlock(formatSearchResultBlock(contentBlock));
+			case "document": return textBlock(formatDocumentBlock(contentBlock));
 			default: return assertNever(contentBlock);
 		}
 	});
@@ -50865,6 +50944,61 @@ function containsVisionContent(value) {
 	return false;
 }
 //#endregion
+//#region src/transform/parameter-filter.ts
+/**
+* Parameters the default rule strips for reasoning models on the Responses
+* boundary. Reasoning models (gpt-5 family, o-series, codex) reject sampling
+* parameters upstream with a 400 "Unsupported parameter" error, so the proxy
+* drops them instead of leaking the incompatibility to the client.
+*/
+const DEFAULT_REASONING_UNSUPPORTED_PARAMS = ["temperature", "top_p"];
+/**
+* A reasoning model is any model that advertises one or more
+* `reasoning_effort` levels. This dynamically covers the full reasoning
+* family (mini, codex, future point releases) without a hardcoded ID list.
+*/
+function isReasoningModel(model) {
+	return modelCache.supportsReasoningEffort(model);
+}
+/**
+* Resolve the set of request parameters to strip for a given model on the
+* Responses boundary.
+*
+* Rule composition:
+* 1. Built-in default: reasoning models strip {@link DEFAULT_REASONING_UNSUPPORTED_PARAMS}.
+*    Disabled entirely when `responsesApiParameterFiltersReplaceDefault` is true.
+* 2. User rules (`responsesApiParameterFilters`): every rule whose `models`
+*    glob matches the resolved model id contributes its `params`.
+*
+* The result is the union of all matching rules, so user rules ADD to the
+* default. Setting `responsesApiParameterFiltersReplaceDefault: true` disables
+* the default so user rules fully OVERWRITE it.
+*/
+function resolveStrippedResponsesParams(model) {
+	const params = /* @__PURE__ */ new Set();
+	if (!configStore.shouldReplaceDefaultParameterFilters() && isReasoningModel(model)) for (const param of DEFAULT_REASONING_UNSUPPORTED_PARAMS) params.add(param);
+	const modelId = model?.id;
+	if (modelId) {
+		for (const rule of configStore.getResponsesParameterFilters()) if (rule.models.some((pattern) => matchesGlob(pattern, modelId))) for (const param of rule.params) params.add(param);
+	}
+	return params;
+}
+/**
+* Strip unsupported parameters from a Responses payload before dispatch.
+* Keys are deleted entirely (never set to null) because upstream rejects the
+* mere presence of the key, not just non-null values.
+*/
+function applyResponsesParameterFilters(payload, model) {
+	const strip = resolveStrippedResponsesParams(model);
+	if (strip.size === 0) return;
+	const removed = [];
+	for (const key of strip) if (key in payload) {
+		delete payload[key];
+		removed.push(key);
+	}
+	if (removed.length > 0) consola.debug(`Stripped unsupported responses params for model ${model?.id}: ${removed.join(", ")}`);
+}
+//#endregion
 //#region src/translator/responses/function-schema.ts
 function isRecord$2(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -51057,6 +51191,12 @@ function convertToolResultContent(content) {
 		case "search_result":
 			result.push(createTextContent(formatSearchResultBlock(block)));
 			break;
+		case "document": {
+			const source = block.source;
+			if (source.type === "file" || source.type === "url" || source.type === "base64") result.push(createDocumentContent(block));
+			else result.push(createTextContent(formatDocumentBlock(block)));
+			break;
+		}
 		default: break;
 	}
 	return result;
@@ -51381,6 +51521,7 @@ function stringifyToolResultContent(content) {
 			case "text": return block.text;
 			case "image": return `[image omitted: ${block.source.media_type}]`;
 			case "search_result": return formatSearchResultBlock(block);
+			case "document": return formatDocumentBlock(block);
 		}
 		return "";
 	}).filter(Boolean).join("\n\n");
@@ -52004,6 +52145,7 @@ const nativeMessagesEntry = {
 	name: "native-messages",
 	canHandle: (model, ctx) => modelCache.supportsEndpoint(model, "/v1/messages") && !hasOutputConfigFormat(ctx?.anthropicPayload),
 	async execute(ctx) {
+		convertEnabledThinkingToAdaptive(ctx.anthropicPayload, ctx.selectedModel);
 		filterThinkingBlocksForNativeMessages(ctx.anthropicPayload);
 		sanitizeOutputConfig(ctx.anthropicPayload, ctx.selectedModel);
 		sanitizeCacheControl(ctx.anthropicPayload);
@@ -52020,6 +52162,7 @@ const responsesApiEntry = {
 		const responsesPayload = withTranslationErrors(() => translateAnthropicToResponsesPayload(ctx.anthropicPayload, { reasoningEffortResolver: (model) => configStore.getReasoningEffort(model) }));
 		applyContextManagement(responsesPayload, ctx.selectedModel?.capabilities.limits.max_prompt_tokens);
 		compactInputByLatestCompaction(responsesPayload);
+		applyResponsesParameterFilters(responsesPayload, ctx.selectedModel);
 		const { vision, initiator } = getResponsesRequestOptions(responsesPayload);
 		return await runStrategy(createMessagesViaResponsesStrategy(ctx.copilotClient, responsesPayload, {
 			vision,
@@ -52517,6 +52660,7 @@ async function handleResponsesCore({ body, signal, headers }) {
 			if (!selectedModel) throwInvalidRequestError("The selected model could not be resolved.", "model");
 			if (!modelCache.supportsEndpoint(selectedModel, "/responses")) throwInvalidRequestError("The selected model does not support the responses endpoint.", "model");
 			applyContextManagement(payload, selectedModel.capabilities.limits.max_prompt_tokens);
+			applyResponsesParameterFilters(payload, selectedModel);
 		},
 		buildStrategyContext({ payload, meta, copilotClient, upstreamSignal }) {
 			const { vision, initiator } = getResponsesRequestOptions(payload);