@victor-software-house/pi-openai-proxy 4.7.1 → 4.9.0

package/dist/index.mjs

@@ -1247,28 +1247,36 @@ const REASONING_EFFORT_MAP = {
 	xhigh: "xhigh"
 };
 /**
-* APIs that use the OpenAI chat completions wire format and accept standard
-* passthrough fields (stop, seed, top_p, tool_choice, etc.) in the payload.
-*
-* Only these APIs receive injected fields via onPayload. All other APIs
-* (anthropic-messages, google-*, bedrock-*, openai-codex-responses) use
-* different payload schemas that reject unknown fields.
+* APIs that accept the full set of OpenAI passthrough fields (stop, seed, top_p,
+* tool_choice, frequency_penalty, etc.) as top-level payload properties.
 */
-const OPENAI_COMPLETIONS_COMPATIBLE_APIS = new Set([
+const OPENAI_FULL_PASSTHROUGH_APIS = new Set([
 	"openai-completions",
 	"openai-responses",
 	"azure-openai-responses",
 	"mistral-conversations"
 ]);
 /**
-* Collect fields that need to be injected via onPayload.
-* Only injects for APIs that use the OpenAI chat completions wire format.
-* Non-compatible APIs (Anthropic, Google, Bedrock, Codex) reject unknown fields.
+* The Codex Responses API accepts only tool_choice and parallel_tool_calls.
+* Other standard fields (top_p, seed, stop, user, frequency_penalty, etc.)
+* are rejected with "Unsupported parameter". The SDK hardcodes
+* tool_choice: "auto" and parallel_tool_calls: true; onPayload overrides
+* those when the client sends explicit values.
+*/
+const CODEX_APIS = new Set(["openai-codex-responses"]);
+const ANTHROPIC_APIS = new Set(["anthropic-messages"]);
+const GOOGLE_APIS = new Set([
+	"google-generative-ai",
+	"google-gemini-cli",
+	"google-vertex"
+]);
+/**
+* Collect OpenAI-format fields for OpenAI-compatible APIs.
+* Fields are injected as flat top-level properties on the payload.
 *
 * @internal Exported for unit testing only.
 */
-function collectPayloadFields(request, api) {
-	if (!OPENAI_COMPLETIONS_COMPATIBLE_APIS.has(api)) return;
+function collectOpenAIPayloadFields(request) {
 	const fields = {};
 	let hasFields = false;
 	if (request.stop !== void 0) {
@@ -1318,6 +1326,198 @@ function collectPayloadFields(request, api) {
 	return hasFields ? fields : void 0;
 }
 /**
+* Translate OpenAI tool_choice to Anthropic tool_choice format.
+*
+* OpenAI "auto" -> { type: "auto" }
+* OpenAI "none" -> { type: "none" } (Anthropic skips tool calling)
+* OpenAI "required" -> { type: "any" } (force tool use)
+* OpenAI { type: "function", function: { name } } -> { type: "tool", name }
+*
+* @internal Exported for unit testing only.
+*/
+function translateToolChoiceForAnthropic(toolChoice) {
+	if (toolChoice === void 0) return;
+	if (toolChoice === "auto") return { type: "auto" };
+	if (toolChoice === "none") return { type: "none" };
+	if (toolChoice === "required") return { type: "any" };
+	return {
+		type: "tool",
+		name: toolChoice.function.name
+	};
+}
+/**
+* Collect Anthropic-format fields translated from the OpenAI request.
+*
+* Supported translations:
+* - top_p -> top_p (same name, natively supported)
+* - stop -> stop_sequences (different field name)
+* - tool_choice -> Anthropic tool_choice format (object with type)
+* - parallel_tool_calls: false -> disable_parallel_tool_use on tool_choice
+* - user -> metadata.user_id
+*
+* Not supported (silently skipped — these concepts don't exist in Anthropic):
+* - seed, frequency_penalty, presence_penalty, response_format, prediction, metadata (arbitrary keys)
+*
+* @internal Exported for unit testing only.
+*/
+function collectAnthropicPayloadFields(request) {
+	const fields = {};
+	let hasFields = false;
+	if (request.top_p !== void 0) {
+		fields["top_p"] = request.top_p;
+		hasFields = true;
+	}
+	if (request.stop !== void 0) {
+		fields["stop_sequences"] = Array.isArray(request.stop) ? request.stop : [request.stop];
+		hasFields = true;
+	}
+	const toolChoice = translateToolChoiceForAnthropic(request.tool_choice);
+	const disableParallel = request.parallel_tool_calls === false;
+	if (toolChoice !== void 0) {
+		if (disableParallel) toolChoice["disable_parallel_tool_use"] = true;
+		fields["tool_choice"] = toolChoice;
+		hasFields = true;
+	} else if (disableParallel) {
+		fields["tool_choice"] = {
+			type: "auto",
+			disable_parallel_tool_use: true
+		};
+		hasFields = true;
+	}
+	if (request.user !== void 0) {
+		fields["metadata"] = { user_id: request.user };
+		hasFields = true;
+	}
+	return hasFields ? fields : void 0;
+}
+/**
+* Translate OpenAI tool_choice to Google FunctionCallingConfigMode string.
+*
+* OpenAI "auto" -> "AUTO"
+* OpenAI "none" -> "NONE"
+* OpenAI "required" -> "ANY"
+* Named function choice -> "ANY" (Google doesn't support per-function forcing
+* in the same way, but ANY forces tool use)
+*/
+function translateToolChoiceForGoogle(toolChoice) {
+	if (toolChoice === void 0) return;
+	if (toolChoice === "auto") return "AUTO";
+	if (toolChoice === "none") return "NONE";
+	return "ANY";
+}
+/**
+* Patch Google's nested payload structure with translated fields.
+*
+* Google's payload shape: { model, contents, config: { generationConfig, toolConfig, ... } }
+* Fields go into config.generationConfig (camelCase) or config.toolConfig.
+*
+* Supported translations:
+* - top_p -> config.generationConfig.topP (camelCase, nested)
+* - stop -> config.generationConfig.stopSequences (array, nested)
+* - seed -> config.generationConfig.seed (nested)
+* - frequency_penalty -> config.generationConfig.frequencyPenalty (nested)
+* - presence_penalty -> config.generationConfig.presencePenalty (nested)
+* - tool_choice -> config.toolConfig.functionCallingConfig.mode (nested)
+*
+* Not supported (silently skipped):
+* - response_format, metadata, prediction, parallel_tool_calls, user
+*
+* @internal Exported for unit testing only.
+*/
+function patchGooglePayload(payload, request) {
+	let patched = false;
+	const config = isRecord(payload["config"]) ? payload["config"] : void 0;
+	if (config === void 0) return false;
+	let genConfig = isRecord(config["generationConfig"]) ? config["generationConfig"] : void 0;
+	if (request.top_p !== void 0) {
+		genConfig ??= {};
+		genConfig["topP"] = request.top_p;
+		patched = true;
+	}
+	if (request.stop !== void 0) {
+		genConfig ??= {};
+		const sequences = Array.isArray(request.stop) ? request.stop : [request.stop];
+		genConfig["stopSequences"] = sequences;
+		patched = true;
+	}
+	if (request.seed !== void 0) {
+		genConfig ??= {};
+		genConfig["seed"] = request.seed;
+		patched = true;
+	}
+	if (request.frequency_penalty !== void 0) {
+		genConfig ??= {};
+		genConfig["frequencyPenalty"] = request.frequency_penalty;
+		patched = true;
+	}
+	if (request.presence_penalty !== void 0) {
+		genConfig ??= {};
+		genConfig["presencePenalty"] = request.presence_penalty;
+		patched = true;
+	}
+	if (genConfig !== void 0 && patched) config["generationConfig"] = genConfig;
+	const mode = translateToolChoiceForGoogle(request.tool_choice);
+	if (mode !== void 0) {
+		let toolConfig = isRecord(config["toolConfig"]) ? config["toolConfig"] : void 0;
+		toolConfig ??= {};
+		let funcConfig = isRecord(toolConfig["functionCallingConfig"]) ? toolConfig["functionCallingConfig"] : void 0;
+		funcConfig ??= {};
+		funcConfig["mode"] = mode;
+		toolConfig["functionCallingConfig"] = funcConfig;
+		config["toolConfig"] = toolConfig;
+		patched = true;
+	}
+	return patched;
+}
+/**
+* Collect the restricted set of fields the Codex Responses API accepts.
+*
+* Only tool_choice and parallel_tool_calls are supported. The SDK hardcodes
+* tool_choice: "auto" and parallel_tool_calls: true; these overrides let clients
+* control tool behavior explicitly.
+*
+* @internal Exported for unit testing only.
+*/
+function collectCodexPayloadFields(request) {
+	const fields = {};
+	let hasFields = false;
+	if (request.tool_choice !== void 0) {
+		fields["tool_choice"] = request.tool_choice;
+		hasFields = true;
+	}
+	if (request.parallel_tool_calls !== void 0) {
+		fields["parallel_tool_calls"] = request.parallel_tool_calls;
+		hasFields = true;
+	}
+	return hasFields ? fields : void 0;
+}
+/**
+* Collect API-specific payload fields from an OpenAI request.
+*
+* Dispatches to the appropriate translator based on the target API:
+* - OpenAI full passthrough: all standard fields (same names)
+* - Codex: restricted to tool_choice + parallel_tool_calls only
+* - Anthropic: translated field names and formats
+* - Google: nested generationConfig patching (handled separately in onPayload)
+* - Others (Bedrock): no passthrough
+*
+* For Google APIs, returns undefined (patching is done directly in onPayload
+* via patchGooglePayload because the payload structure is nested).
+*
+* @internal Exported for unit testing only.
+*/
+function collectPayloadFields(request, api) {
+	if (OPENAI_FULL_PASSTHROUGH_APIS.has(api)) return collectOpenAIPayloadFields(request);
+	if (CODEX_APIS.has(api)) return collectCodexPayloadFields(request);
+	if (ANTHROPIC_APIS.has(api)) return collectAnthropicPayloadFields(request);
+}
+/**
+* Whether the given API requires Google-style nested payload patching.
+*/
+function isGoogleApi(api) {
+	return GOOGLE_APIS.has(api);
+}
+/**
 * Collect tool strict flags from the original OpenAI request.
 *
 * The pi SDK's `Tool` interface has no `strict` field, so the SDK always sets
@@ -1391,9 +1591,11 @@ async function buildStreamOptions(model, request, options) {
 	}
 	const payloadFields = collectPayloadFields(request, model.api);
 	const strictFlags = collectToolStrictFlags(request.tools);
-	if (payloadFields !== void 0 || strictFlags !== void 0) opts.onPayload = (payload) => {
+	const needsGooglePatch = isGoogleApi(model.api);
+	if (payloadFields !== void 0 || strictFlags !== void 0 || needsGooglePatch) opts.onPayload = (payload) => {
 		if (isRecord(payload)) {
 			if (payloadFields !== void 0) for (const [key, value] of Object.entries(payloadFields)) payload[key] = value;
+			if (needsGooglePatch) patchGooglePayload(payload, request);
 			if (strictFlags !== void 0) applyToolStrictFlags(payload, strictFlags);
 		}
 		return payload;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@victor-software-house/pi-openai-proxy",
-	"version": "4.7.1",
+	"version": "4.9.0",
 	"description": "OpenAI-compatible HTTP proxy for pi's multi-provider model registry",
 	"license": "MIT",
 	"author": "Victor Software House",