@jsonstudio/llms 0.6.802 → 0.6.954

package/dist/conversion/responses/responses-openai-bridge.js

@@ -424,14 +424,40 @@ export function buildResponsesRequestFromChat(payload, ctx, extras) {
     else if (isPlainObject(metadataExtraFields?.metadata)) {
         out.metadata = { ...metadataExtraFields.metadata };
     }
-    if (ctx?.parameters && Object.keys(ctx.parameters).length) {
-        out.parameters = { ...ctx.parameters };
-    }
-    else if (chat.parameters && typeof chat.parameters === 'object') {
-        out.parameters = { ...chat.parameters };
-    }
-    else if (isPlainObject(metadataExtraFields?.parameters)) {
-        out.parameters = { ...metadataExtraFields.parameters };
+    // Some upstream `/v1/responses` providers reject an unknown top-level `parameters` object
+    // (e.g. HTTP 400: Unsupported parameter: parameters).
+    // We accept `parameters` as an internal carrier (capturedChatRequest.parameters, followups),
+    // but must flatten supported fields into the top-level request shape before sending upstream.
+    const parametersCandidate = (ctx?.parameters && Object.keys(ctx.parameters).length ? { ...ctx.parameters } : undefined) ??
+        (chat.parameters && typeof chat.parameters === 'object' && !Array.isArray(chat.parameters) ? { ...chat.parameters } : undefined) ??
+        (isPlainObject(metadataExtraFields?.parameters) ? { ...metadataExtraFields.parameters } : undefined);
+    if (parametersCandidate) {
+        const allowed = new Set([
+            // Common OpenAI Responses parameters
+            'temperature',
+            'top_p',
+            'max_output_tokens',
+            'seed',
+            'logit_bias',
+            'user',
+            'parallel_tool_calls',
+            'tool_choice',
+            'response_format',
+            'stream'
+        ]);
+        // Back-compat: StandardizedRequest uses max_tokens; map it to Responses max_output_tokens.
+        if (parametersCandidate.max_output_tokens === undefined && parametersCandidate.max_tokens !== undefined) {
+            parametersCandidate.max_output_tokens = parametersCandidate.max_tokens;
+        }
+        for (const [key, value] of Object.entries(parametersCandidate)) {
+            if (!allowed.has(key))
+                continue;
+            if (key === 'stream')
+                continue; // handled by resolvedStream above
+            if (out[key] === undefined) {
+                out[key] = value;
+            }
+        }
     }
     ensureBridgeInstructions(out);
     return { request: out, originalSystemMessages };
@@ -590,8 +616,21 @@ export function buildResponsesPayloadFromChat(payload, context) {
                 });
             }
         }
-        catch {
-            // best-effort bridge policy application
+        catch (error) {
+            const message = error instanceof Error
+                ? error.message
+                : typeof error === 'string'
+                    ? error
+                    : 'unknown_error';
+            try {
+                // eslint-disable-next-line no-console
+                console.error(`\x1b[31m[responses-bridge][response_outbound] bridge action pipeline failed requestId=${context?.requestId ?? 'unknown'} error=${message}\x1b[0m`);
+            }
+            catch {
+                // ignore logging failures
+            }
+            // Do not fail-close here: preserve protocol-correct payload shape and let the client
+            // handle any downstream validation errors. The bridge policy pipeline is best-effort.
         }
     }
     if (message) {
@@ -625,6 +664,10 @@ export function buildResponsesPayloadFromChat(payload, context) {
         out.usage = outputBuild.usage;
     if (outputBuild.requiredAction)
         out.required_action = outputBuild.requiredAction;
+    // Normalize tool_call arguments for client-declared tool formats (e.g. format:"freeform").
+    // If we cannot repair/match the declared schema/format, we fall back to returning the
+    // original tool-call arguments and let the client surface the error.
+    normalizeResponsesToolCallArgumentsForClient(out, context);
     // Do not inject captured tool results here; keep Chat back-half behavior standard.
     if (context) {
         for (const k of ['metadata', 'parallel_tool_calls', 'tool_choice', 'include']) {
@@ -649,6 +692,216 @@ export function buildResponsesPayloadFromChat(payload, context) {
     }
     return out;
 }
+function normalizeResponsesToolCallArgumentsForClient(responsesPayload, context) {
+    const toolsRaw = Array.isArray(context?.toolsRaw) ? context?.toolsRaw : [];
+    if (!toolsRaw.length) {
+        return;
+    }
+    const toolIndex = buildClientToolIndex(toolsRaw);
+    if (!toolIndex.size) {
+        return;
+    }
+    const normalizeCallArgs = (toolName, argsRaw) => {
+        const spec = toolIndex.get(toolName);
+        if (!spec)
+            return argsRaw;
+        // format:"freeform" means client expects raw text (not JSON) in the arguments field.
+        if (typeof spec.format === 'string' && spec.format.trim().toLowerCase() === 'freeform') {
+            const rawText = extractFreeformTextFromArgs(argsRaw);
+            if (rawText && rawText.trim().length) {
+                return rawText;
+            }
+            return argsRaw;
+        }
+        // Schema-aware key alignment for common server-side tools.
+        // If we cannot repair, keep original args and let the client surface the error.
+        const params = spec.parameters;
+        if (!params)
+            return argsRaw;
+        const schema = extractJsonSchemaLike(params);
+        if (!schema)
+            return argsRaw;
+        const parsed = tryParseJson(argsRaw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return argsRaw;
+        }
+        const record = parsed;
+        const repaired = repairToolArgsBySchemaKeys(toolName, record, schema);
+        if (!repaired) {
+            return argsRaw;
+        }
+        try {
+            return JSON.stringify(repaired);
+        }
+        catch {
+            return argsRaw;
+        }
+    };
+    // 1) output[] function_call items
+    const output = Array.isArray(responsesPayload.output) ? responsesPayload.output : [];
+    for (const item of output) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const type = typeof item.type === 'string' ? String(item.type).trim().toLowerCase() : '';
+        if (type !== 'function_call')
+            continue;
+        const name = typeof item.name === 'string' ? String(item.name).trim() : '';
+        if (!name)
+            continue;
+        if (!toolIndex.has(name))
+            continue;
+        item.arguments = normalizeCallArgs(name, item.arguments);
+    }
+    // 2) required_action.submit_tool_outputs.tool_calls[] tool calls
+    const toolCalls = responsesPayload?.required_action?.submit_tool_outputs?.tool_calls;
+    const calls = Array.isArray(toolCalls) ? toolCalls : [];
+    for (const call of calls) {
+        if (!call || typeof call !== 'object')
+            continue;
+        const fn = call.function && typeof call.function === 'object' && !Array.isArray(call.function) ? call.function : null;
+        const name = typeof fn?.name === 'string' ? String(fn.name).trim() : '';
+        if (!name)
+            continue;
+        if (!toolIndex.has(name))
+            continue;
+        fn.arguments = normalizeCallArgs(name, fn.arguments);
+    }
+}
+function buildClientToolIndex(toolsRaw) {
+    const index = new Map();
+    for (const tool of toolsRaw) {
+        if (!tool || typeof tool !== 'object' || Array.isArray(tool))
+            continue;
+        const t = tool;
+        const fn = t.function && typeof t.function === 'object' && !Array.isArray(t.function) ? t.function : undefined;
+        const nameRaw = (fn && typeof fn.name === 'string' ? fn.name : undefined) ?? (typeof t.name === 'string' ? t.name : undefined);
+        const name = typeof nameRaw === 'string' ? nameRaw.trim() : '';
+        if (!name)
+            continue;
+        const formatRaw = (typeof t.format === 'string' ? t.format : undefined) ??
+            (fn && typeof fn.format === 'string' ? fn.format : undefined);
+        const parametersRaw = (fn && fn.parameters && typeof fn.parameters === 'object' && !Array.isArray(fn.parameters) ? fn.parameters : undefined) ??
+            (t.parameters && typeof t.parameters === 'object' && !Array.isArray(t.parameters) ? t.parameters : undefined) ??
+            undefined;
+        index.set(name, {
+            name,
+            ...(typeof formatRaw === 'string' && formatRaw.trim().length ? { format: formatRaw.trim() } : {}),
+            ...(parametersRaw ? { parameters: parametersRaw } : {})
+        });
+    }
+    return index;
+}
+function tryParseJson(value) {
+    if (typeof value !== 'string')
+        return null;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return null;
+    if (!(trimmed.startsWith('{') || trimmed.startsWith('[')))
+        return null;
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return null;
+    }
+}
+function looksLikeApplyPatchText(value) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return false;
+    return trimmed.includes('*** Begin Patch') && trimmed.includes('*** End Patch');
+}
+function extractFreeformTextFromArgs(argsRaw) {
+    if (typeof argsRaw === 'string') {
+        const trimmed = argsRaw.trim();
+        if (!trimmed)
+            return null;
+        // If JSON wrapper, extract common fields first.
+        const parsed = tryParseJson(trimmed);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            const rec = parsed;
+            for (const key of ['instructions', 'patch', 'input', 'text']) {
+                if (typeof rec[key] === 'string' && rec[key].trim().length) {
+                    return String(rec[key]).trim();
+                }
+            }
+        }
+        // If it's already freeform (not a JSON wrapper), keep.
+        if (!trimmed.startsWith('{') && !trimmed.startsWith('[') && looksLikeApplyPatchText(trimmed)) {
+            return trimmed;
+        }
+        // Unknown freeform: return as-is so client can error.
+        return trimmed;
+    }
+    // If arguments is an object (malformed), try to extract patch-like fields.
+    if (argsRaw && typeof argsRaw === 'object' && !Array.isArray(argsRaw)) {
+        const rec = argsRaw;
+        for (const key of ['instructions', 'patch', 'input', 'text']) {
+            if (typeof rec[key] === 'string' && rec[key].trim().length) {
+                return String(rec[key]).trim();
+            }
+        }
+    }
+    return null;
+}
+function extractJsonSchemaLike(parameters) {
+    const required = Array.isArray(parameters.required)
+        ? parameters.required.filter((v) => typeof v === 'string' && v.trim().length > 0).map((v) => v.trim())
+        : [];
+    const props = parameters.properties && typeof parameters.properties === 'object' && !Array.isArray(parameters.properties)
+        ? parameters.properties
+        : {};
+    const properties = Object.keys(props);
+    if (!required.length && !properties.length) {
+        return null;
+    }
+    const additionalProperties = typeof parameters.additionalProperties === 'boolean' ? parameters.additionalProperties : true;
+    return { required, properties, additionalProperties };
+}
+function repairToolArgsBySchemaKeys(toolName, record, schema) {
+    // Apply known alias mappings only if the target keys are present in schema properties.
+    const wants = new Set(schema.properties);
+    const out = { ...record };
+    if (toolName === 'exec_command') {
+        if (wants.has('cmd') && out.command !== undefined && out.cmd === undefined)
+            out.cmd = out.command;
+        if (wants.has('command') && out.cmd !== undefined && out.command === undefined)
+            out.command = out.cmd;
+    }
+    if (toolName === 'write_stdin') {
+        if (wants.has('chars') && out.text !== undefined && out.chars === undefined)
+            out.chars = out.text;
+        if (wants.has('text') && out.chars !== undefined && out.text === undefined)
+            out.text = out.chars;
+    }
+    if (toolName === 'apply_patch') {
+        if (wants.has('instructions') && out.instructions === undefined) {
+            if (typeof out.patch === 'string' && out.patch.trim().length)
+                out.instructions = out.patch;
+            else if (typeof out.input === 'string' && out.input.trim().length)
+                out.instructions = out.input;
+        }
+        if (wants.has('patch') && out.patch === undefined) {
+            if (typeof out.instructions === 'string' && out.instructions.trim().length)
+                out.patch = out.instructions;
+            else if (typeof out.input === 'string' && out.input.trim().length)
+                out.patch = out.input;
+        }
+    }
+    for (const key of schema.required) {
+        if (!Object.prototype.hasOwnProperty.call(out, key)) {
+            return null;
+        }
+    }
+    if (schema.additionalProperties === false && schema.properties.length > 0) {
+        for (const key of Object.keys(out)) {
+            if (!wants.has(key))
+                delete out[key];
+        }
+    }
+    return out;
+}
 function unwrapData(value) {
     let current = value;
     const seen = new Set();

package/dist/conversion/schema-validator.d.ts

@@ -0,0 +1,7 @@
+export declare class SchemaValidator {
+    private readonly baseDir;
+    private readonly cache;
+    constructor(baseDir?: string);
+    validate(schemaPath: string | undefined, payload: unknown, context: string): Promise<void>;
+    private getValidator;
+}

package/dist/conversion/shared/args-mapping.d.ts

@@ -0,0 +1,18 @@
+export type Unknown = Record<string, unknown>;
+export interface NormalizeResult<T = Record<string, unknown>> {
+    ok: boolean;
+    value?: T;
+    errors?: string[];
+}
+type JsonSchema = {
+    type?: string | string[];
+    properties?: Record<string, JsonSchema & {
+        ['x-aliases']?: string[];
+    }>;
+    required?: string[];
+    items?: JsonSchema;
+    additionalProperties?: boolean;
+};
+export declare function normalizeArgsBySchema(input: any, schema?: JsonSchema): NormalizeResult;
+export declare function normalizeTools(tools: any[]): Unknown[];
+export {};

package/dist/conversion/shared/chat-request-filters.d.ts

@@ -0,0 +1,9 @@
+import type { ConversionContext, ConversionProfile } from '../types.js';
+/**
+ * 统一的 Chat 请求侧过滤链路。
+ *
+ * 目标：
+ * - 所有进入 Provider 的 Chat 形状请求（无论入口为 /v1/chat、/v1/responses 还是 /v1/messages），
+ *   都在这里走同一套工具治理与参数标准化逻辑。
+ */
+export declare function runStandardChatRequestFilters(chatRequest: any, profile: ConversionProfile, context: ConversionContext): Promise<any>;

package/dist/conversion/shared/errors.d.ts

@@ -1,4 +1,4 @@
-export type ProviderProtocolErrorCode = 'TOOL_PROTOCOL_ERROR' | 'SSE_DECODE_ERROR' | 'MALFORMED_RESPONSE' | 'MALFORMED_REQUEST' | 'SERVERTOOL_FOLLOWUP_FAILED' | 'SERVERTOOL_TIMEOUT' | 'SERVERTOOL_HANDLER_FAILED';
+export type ProviderProtocolErrorCode = 'TOOL_PROTOCOL_ERROR' | 'SSE_DECODE_ERROR' | 'MALFORMED_RESPONSE' | 'MALFORMED_REQUEST' | 'SERVERTOOL_FOLLOWUP_FAILED' | 'SERVERTOOL_EMPTY_FOLLOWUP' | 'SERVERTOOL_TIMEOUT' | 'SERVERTOOL_HANDLER_FAILED';
 export type ProviderErrorCategory = 'EXTERNAL_ERROR' | 'TOOL_ERROR' | 'INTERNAL_ERROR';
 export interface ProviderProtocolErrorOptions {
     code: ProviderProtocolErrorCode;

package/dist/conversion/shared/gemini-tool-utils.js

@@ -2,6 +2,38 @@ import { jsonClone } from '../hub/types/json.js';
 function isPlainRecord(value) {
     return !!value && typeof value === 'object' && !Array.isArray(value);
 }
+function pickBestSchemaVariant(variants) {
+    if (!Array.isArray(variants) || variants.length === 0) {
+        return { type: 'object', properties: {} };
+    }
+    const score = (value) => {
+        if (!isPlainRecord(value)) {
+            return 0;
+        }
+        const type = typeof value.type === 'string' ? value.type.trim().toLowerCase() : '';
+        // Prefer 'string' to maximize compatibility (can carry arbitrary serialized content),
+        // then object/array, then primitives.
+        if (type === 'string')
+            return 100;
+        if (type === 'object')
+            return 80;
+        if (type === 'array')
+            return 60;
+        if (type === 'integer' || type === 'number' || type === 'boolean')
+            return 50;
+        return 10;
+    };
+    let best = variants[0];
+    let bestScore = score(best);
+    for (const candidate of variants.slice(1)) {
+        const candidateScore = score(candidate);
+        if (candidateScore > bestScore) {
+            best = candidate;
+            bestScore = candidateScore;
+        }
+    }
+    return best;
+}
 function cloneParameters(value) {
     if (value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
         return value;
@@ -10,6 +42,28 @@ function cloneParameters(value) {
         return value.map((entry) => cloneParameters(entry));
     }
     if (isPlainRecord(value)) {
+        // Gemini function_declarations.parameters only support a subset of JSON Schema.
+        // Additionally, recent Antigravity/Gemini backends may produce MALFORMED_FUNCTION_CALL
+        // when schemas include combinators (oneOf/anyOf/allOf). Prefer a safe single-variant schema.
+        const combinator = Array.isArray(value.oneOf)
+            ? 'oneOf'
+            : Array.isArray(value.anyOf)
+                ? 'anyOf'
+                : Array.isArray(value.allOf)
+                    ? 'allOf'
+                    : undefined;
+        if (combinator) {
+            const variants = value[combinator];
+            const chosen = pickBestSchemaVariant(Array.isArray(variants) ? variants : []);
+            const simplified = cloneParameters(chosen);
+            // Preserve description if present on the wrapper node.
+            if (isPlainRecord(simplified) &&
+                typeof value.description === 'string' &&
+                typeof simplified.description !== 'string') {
+                simplified.description = String(value.description);
+            }
+            return simplified;
+        }
         const cloned = {};
         for (const [key, entry] of Object.entries(value)) {
             // Gemini function_declarations.parameters only support a subset of JSON Schema.
@@ -19,6 +73,13 @@ function cloneParameters(value) {
                     continue;
                 if (key === 'exclusiveMinimum' || key === 'exclusiveMaximum' || key === 'propertyNames')
                     continue;
+                // Keep Gemini tool schemas mostly permissive to avoid upstream MALFORMED_FUNCTION_CALL on strict validation.
+                // We selectively re-introduce safe required fields for critical tools in `buildGeminiToolsFromBridge`.
+                if (key === 'required' || key === 'additionalProperties')
+                    continue;
+                // Combinators are handled at the node level above.
+                if (key === 'oneOf' || key === 'anyOf' || key === 'allOf')
+                    continue;
             }
             cloned[key] = cloneParameters(entry);
         }
@@ -105,6 +166,49 @@ export function buildGeminiToolsFromBridge(defs) {
         return undefined;
     }
     const tools = [];
+    const applyFixups = (name, parameters) => {
+        if (!parameters || typeof parameters !== 'object' || Array.isArray(parameters)) {
+            return parameters;
+        }
+        const params = parameters;
+        const propsRaw = params.properties;
+        const props = isPlainRecord(propsRaw) ? propsRaw : {};
+        const lowered = String(name || '').trim().toLowerCase();
+        if (lowered === 'exec_command') {
+            // Keep Gemini tool schema aligned with historical functionCall args. We observed large
+            // conversations containing exec_command args as { command, workdir } and strict Gemini
+            // validation will emit MALFORMED_FUNCTION_CALL when schema/args mismatch.
+            if (!Object.prototype.hasOwnProperty.call(props, 'command') && Object.prototype.hasOwnProperty.call(props, 'cmd')) {
+                props.command = props.cmd;
+                try {
+                    delete props.cmd;
+                }
+                catch {
+                    // ignore
+                }
+            }
+            if (!Object.prototype.hasOwnProperty.call(props, 'command')) {
+                props.command = { type: 'string' };
+            }
+            params.properties = props;
+            params.required = ['command'];
+            return params;
+        }
+        if (lowered === 'write_stdin') {
+            params.required = ['session_id'];
+            return params;
+        }
+        if (lowered === 'apply_patch') {
+            // Force a non-empty patch payload; leaving the schema fully permissive results in repeated `{}` tool calls.
+            if (!Object.prototype.hasOwnProperty.call(props, 'patch')) {
+                props.patch = { type: 'string' };
+            }
+            params.properties = props;
+            params.required = ['patch'];
+            return params;
+        }
+        return params;
+    };
     defs.forEach((def) => {
         if (!def || typeof def !== 'object') {
             return;
@@ -123,7 +227,7 @@ export function buildGeminiToolsFromBridge(defs) {
             : typeof def.description === 'string'
                 ? def.description
                 : undefined;
-        const parameters = cloneParameters(fnNode?.parameters ?? def.parameters ?? { type: 'object', properties: {} });
+        const parameters = applyFixups(name, cloneParameters(fnNode?.parameters ?? def.parameters ?? { type: 'object', properties: {} }));
         tools.push({
             functionDeclarations: [
                 {

package/dist/conversion/shared/jsonish.d.ts

@@ -0,0 +1,3 @@
+export declare function tryParseJson<T = unknown>(s: unknown): T | unknown;
+export declare function parseLenient(value: unknown): unknown;
+export declare function repairArgumentsToString(value: unknown): string;

package/dist/conversion/shared/mcp-injection.d.ts

@@ -0,0 +1,2 @@
+export declare function injectMcpToolsForChat(tools: any[] | undefined, discoveredServers: string[]): any[];
+export declare function injectMcpToolsForResponses(tools: any[] | undefined, discoveredServers: string[]): any[];

package/dist/conversion/shared/media.d.ts

@@ -0,0 +1 @@
+export declare function isImagePath(p: unknown): boolean;

package/dist/conversion/shared/openai-message-normalize.d.ts

@@ -0,0 +1 @@
+export declare function normalizeChatRequest(request: any): any;

package/dist/conversion/shared/payload-budget.d.ts

@@ -0,0 +1,13 @@
+export declare function resolveBudgetForModelSync(modelId: string): {
+    maxBytes: number;
+    safetyRatio: number;
+    allowedBytes: number;
+    source: string;
+};
+export declare const resolveBudgetForModel: (modelId: string) => Promise<{
+    maxBytes: number;
+    safetyRatio: number;
+    allowedBytes: number;
+    source: string;
+}>;
+export declare function enforceChatBudget(chat: any, modelId: string): any;

package/dist/conversion/shared/reasoning-mapping.d.ts

@@ -0,0 +1,5 @@
+export interface ReasoningItem {
+    type: 'reasoning';
+    content: string;
+}
+export declare function mapReasoningContentToResponsesOutput(reasoningContent: any): ReasoningItem[];

package/dist/conversion/shared/responses-request-adapter.d.ts

@@ -1,28 +1 @@
-import type { BridgeInputItem, BridgeToolDefinition } from './bridge-message-types.js';
-export interface ResponsesRequestContext {
-    requestId?: string;
-    instructions?: string;
-    originalSystemMessages?: string[];
-    input?: BridgeInputItem[];
-    include?: unknown;
-    store?: unknown;
-    toolChoice?: unknown;
-    parallelToolCalls?: boolean;
-    metadata?: Record<string, unknown>;
-    responseFormat?: unknown;
-    toolsRaw?: BridgeToolDefinition[];
-    stream?: boolean;
-    instructionsIsRaw?: boolean;
-    isChatPayload?: boolean;
-    isResponsesPayload?: boolean;
-}
-export interface BuildChatRequestResult {
-    request: Record<string, unknown>;
-    toolsNormalized?: Array<Record<string, unknown>>;
-}
-export declare function captureResponsesContext(payload: Record<string, unknown>, dto?: {
-    route?: {
-        requestId?: string;
-    };
-}): ResponsesRequestContext;
-export declare function buildChatRequestFromResponses(payload: Record<string, unknown>, context: ResponsesRequestContext): BuildChatRequestResult;
+export { captureResponsesContext, buildChatRequestFromResponses } from '../responses/responses-openai-bridge.js';