@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
155 lines (146 loc) • 6.5 kB
text/typescript
/**
* Hosted tools rejected by specific native model slugs or exact provider destinations.
*
* Add a row only for a destination that refuses the tool itself.
*/
const UNSUPPORTED_HOSTED_TOOLS: ReadonlyArray<{
match: (model: string, baseUrl?: string) => boolean;
tools: ReadonlySet<string>;
}> = [
{
// MiMo rejects hosted search with "tool type 'web_search' is not supported by this gateway phase" (#5501).
match: (_model, baseUrl) => {
if (!baseUrl) return false;
try {
return /(?:^|\.)xiaomimimo\.com$/i.test(new URL(baseUrl).hostname);
} catch {
return false;
}
},
tools: new Set(["web_search", "web_search_preview"]),
},
];
/**
* Hosted-tool declaration names an operator may list in `unsupportedHostedTools` or
* `unsupportedHostedToolsWithClientTools`.
*
* A gateway must be able to deny anything a client can send it, so this is the set of
* nameless hosted/private declaration types the proxy recognizes on a Responses request.
* It is deliberately a closed vocabulary: the provider config schema ends in
* `.passthrough()`, so an unvalidated misspelling would be accepted, persisted, and then
* silently strip nothing -- which is the exact 400 the operator set the field to avoid
* (the `codexToolMode` lesson in #2106).
*/
export const DECLARABLE_HOSTED_TOOL_TYPES: ReadonlySet<string> = new Set([
"web_search",
"web_search_preview",
"file_search",
"computer_use_preview",
"computer_use",
"code_interpreter",
"image_generation",
"image_gen",
"mcp",
"tool_search",
"local_shell",
"x_search",
]);
/**
* Spellings that name one capability. Declaring either member denies both, because the
* rest of the proxy already treats these as a single tool: the parser folds
* `web_search_preview` onto one name (`src/responses/parser-tools.ts`), Chat ingress
* accepts the pair together (`src/chat/inbound.ts`), and the canonical-field strip lists
* the pair in a single `toolTypes` set
* (`src/adapters/openai-responses/request-strips.ts`).
*
* Without the alias a capability declaration would be honoured for the spelling the
* operator happened to write and ignored for the one the client happened to send, which
* reproduces the original rejection while the config claims to have prevented it.
*/
const HOSTED_TOOL_ALIAS_GROUPS: ReadonlyArray<ReadonlySet<string>> = [
new Set(["web_search", "web_search_preview"]),
new Set(["image_generation", "image_gen"]),
new Set(["computer_use_preview", "computer_use"]),
];
const NO_DECLARED_HOSTED_TOOLS: ReadonlySet<string> = new Set();
function addDeclaredHostedTools(out: Set<string>, declared: readonly string[] | undefined): void {
if (!Array.isArray(declared)) return;
for (const raw of declared) {
if (typeof raw !== "string") continue;
const tool = raw.trim();
if (!tool) continue;
out.add(tool);
for (const group of HOSTED_TOOL_ALIAS_GROUPS) {
if (!group.has(tool)) continue;
for (const alias of group) out.add(alias);
}
}
}
/**
* Expand a provider's declared denials through the alias groups once per request, so the
* per-tool predicate stays a set lookup. Returns a shared empty set when the provider
* declares nothing, keeping the common path allocation-free.
*
* `withClientTools` says whether the request being shaped also declares client tools. Only
* then does `unsupportedHostedToolsWithClientTools` join the unconditional list (#8204);
* config-time callers leave it false and see the unconditional denials alone.
*/
export function declaredUnsupportedHostedTools(
provider?: {
unsupportedHostedTools?: readonly string[];
unsupportedHostedToolsWithClientTools?: readonly string[];
},
withClientTools = false,
): ReadonlySet<string> {
const declared = provider?.unsupportedHostedTools;
const conditional = withClientTools ? provider?.unsupportedHostedToolsWithClientTools : undefined;
const hasDeclared = Array.isArray(declared) && declared.length > 0;
const hasConditional = Array.isArray(conditional) && conditional.length > 0;
if (!hasDeclared && !hasConditional) return NO_DECLARED_HOSTED_TOOLS;
const out = new Set<string>();
addDeclaredHostedTools(out, declared);
addDeclaredHostedTools(out, conditional);
return out.size > 0 ? out : NO_DECLARED_HOSTED_TOOLS;
}
/** A declaration the client executes and answers: a function, a custom tool, or a namespace of them. */
function isClientToolDeclaration(tool: unknown): boolean {
if (tool === null || typeof tool !== "object" || Array.isArray(tool)) return false;
const entry = tool as { type?: unknown; tools?: unknown };
if (entry.type === "function" || entry.type === "custom") return true;
return entry.type === "namespace" && Array.isArray(entry.tools) && entry.tools.some(isClientToolDeclaration);
}
/**
* Whether a Responses body declares any client tool the upstream will see: in `tools`, in a
* client-loaded `additional_tools` catalog, or in the definitions a client-executed
* `tool_search_output` returned. Hosted declarations never count, so stripping them cannot
* change the answer.
*/
export function responsesBodyDeclaresClientTools(body: Record<string, unknown>): boolean {
if (Array.isArray(body.tools) && body.tools.some(isClientToolDeclaration)) return true;
if (!Array.isArray(body.input)) return false;
return body.input.some(item => {
if (item === null || typeof item !== "object" || Array.isArray(item)) return false;
const entry = item as { type?: unknown; tools?: unknown };
return (entry.type === "additional_tools" || entry.type === "tool_search_output")
&& Array.isArray(entry.tools)
&& entry.tools.some(isClientToolDeclaration);
});
}
/**
* True when forwarding this hosted tool to the model would be rejected upstream.
*
* `declaredUnsupported` is the provider's own capability declaration, expanded by
* `declaredUnsupportedHostedTools`. It is additive to the built-in table rather than a
* replacement for it: the table covers destinations that reject a tool regardless of how
* the operator configured them, so an operator who never heard of the field stays
* protected.
*/
export function isHostedToolUnsupportedForModel(
modelId: string,
tool: string,
baseUrl?: string,
declaredUnsupported?: ReadonlySet<string>,
): boolean {
if (declaredUnsupported?.has(tool)) return true;
return UNSUPPORTED_HOSTED_TOOLS.some(entry => entry.match(modelId, baseUrl) && entry.tools.has(tool));
}