ghc-proxy 0.7.0 → 0.7.1

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.1";
 //#endregion
 //#region src/debug.ts
 function getRuntimeInfo() {
@@ -50865,6 +50879,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);
@@ -52020,6 +52089,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 +52587,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);