@jsonstudio/llms 0.4.4 → 0.4.6

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

@@ -0,0 +1,90 @@
+import { normalizeFunctionCallId, normalizeFunctionCallOutputId } from './bridge-id-utils.js';
+export function createToolCallIdTransformer(style) {
+    if (style !== 'fc') {
+        return null;
+    }
+    let callCounter = 0;
+    let outputCounter = 0;
+    const alias = new Map();
+    const normalizeCallId = (raw) => {
+        const rawStr = typeof raw === 'string' && raw.trim().length ? raw.trim() : undefined;
+        if (rawStr && alias.has(rawStr)) {
+            return alias.get(rawStr);
+        }
+        const normalized = normalizeFunctionCallId({
+            callId: rawStr,
+            fallback: `fc_call_${++callCounter}`
+        });
+        if (rawStr) {
+            alias.set(rawStr, normalized);
+        }
+        return normalized;
+    };
+    const normalizeOutputId = (callId, raw) => {
+        const rawStr = typeof raw === 'string' && raw.trim().length ? raw.trim() : undefined;
+        return normalizeFunctionCallOutputId({
+            callId,
+            fallback: rawStr ?? `fc_tool_${++outputCounter}`
+        });
+    };
+    return {
+        normalizeCallId,
+        normalizeOutputId
+    };
+}
+export function enforceToolCallIdStyle(input, transformer) {
+    for (const entry of input) {
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const type = typeof entry.type === 'string' ? entry.type.toLowerCase() : '';
+        if (type === 'function_call') {
+            const normalized = transformer.normalizeCallId(entry.call_id ?? entry.id);
+            entry.call_id = normalized;
+            entry.id = normalized;
+            continue;
+        }
+        if (type === 'function_call_output' || type === 'tool_result' || type === 'tool_message') {
+            const normalized = transformer.normalizeCallId(entry.call_id ?? entry.id);
+            entry.call_id = normalized;
+            entry.id = transformer.normalizeOutputId(normalized, entry.id);
+        }
+    }
+}
+export function resolveToolCallIdStyle(metadata) {
+    if (!metadata)
+        return 'fc';
+    const raw = metadata.toolCallIdStyle;
+    if (typeof raw === 'string') {
+        const lowered = raw.trim().toLowerCase();
+        if (lowered === 'fc') {
+            return 'fc';
+        }
+        if (lowered === 'preserve') {
+            return 'preserve';
+        }
+    }
+    return 'fc';
+}
+export function stripInternalToolingMetadata(metadata) {
+    if (!metadata || typeof metadata !== 'object')
+        return;
+    if ('toolCallIdStyle' in metadata) {
+        delete metadata.toolCallIdStyle;
+    }
+}
+export function sanitizeResponsesFunctionName(rawName) {
+    if (typeof rawName !== 'string') {
+        return undefined;
+    }
+    const trimmed = rawName.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const dotIndex = trimmed.indexOf('.');
+    const base = dotIndex >= 0 ? trimmed.slice(dotIndex + 1) : trimmed;
+    const sanitized = base.replace(/[^A-Za-z0-9_-]/g, '_');
+    if (sanitized.length > 0) {
+        return sanitized;
+    }
+    return 'tool_call';
+}

package/dist/conversion/shared/responses-types.d.ts

@@ -0,0 +1,33 @@
+export type ResponsesContentPart = {
+    type: string;
+    text?: string;
+    content?: unknown;
+};
+export type ResponsesInputItem = {
+    type: string;
+    role?: string;
+    content?: Array<ResponsesContentPart> | null;
+    name?: string;
+    arguments?: unknown;
+    call_id?: string;
+    output?: unknown;
+    function?: {
+        name?: string;
+        arguments?: unknown;
+    };
+    message?: {
+        role?: string;
+        content?: Array<ResponsesContentPart>;
+    };
+    id?: string;
+    tool_call_id?: string;
+    tool_use_id?: string;
+    text?: string;
+};
+export type ResponsesToolDefinition = {
+    type: string;
+    name?: string;
+    description?: string;
+    strict?: boolean;
+    parameters?: unknown;
+};

package/dist/conversion/shared/responses-types.js

@@ -0,0 +1 @@
+export {};

package/dist/conversion/shared/tool-call-utils.d.ts

@@ -0,0 +1,11 @@
+type UnknownRecord = Record<string, unknown>;
+/**
+ * Derive a deterministic key for a tool call by combining the normalized
+ * function name and serialized arguments. Used to deduplicate inferred calls.
+ */
+export declare function deriveToolCallKey(call: UnknownRecord | null | undefined): string | null;
+/**
+ * Merge tool call entries with deduplication (by derived key). Returns the new array.
+ */
+export declare function mergeToolCalls(existing: UnknownRecord[] | undefined, additions: UnknownRecord[] | undefined): UnknownRecord[];
+export {};

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

@@ -0,0 +1,56 @@
+/**
+ * Derive a deterministic key for a tool call by combining the normalized
+ * function name and serialized arguments. Used to deduplicate inferred calls.
+ */
+export function deriveToolCallKey(call) {
+    if (!call || typeof call !== 'object') {
+        return null;
+    }
+    const fn = call.function;
+    const name = typeof fn?.name === 'string' ? fn.name.trim() : '';
+    const argsRaw = fn?.arguments;
+    let args = '';
+    if (typeof argsRaw === 'string') {
+        args = argsRaw.trim();
+    }
+    else if (argsRaw !== undefined) {
+        try {
+            args = JSON.stringify(argsRaw);
+        }
+        catch {
+            args = '';
+        }
+    }
+    if (!name && !args) {
+        return null;
+    }
+    return `${name}::${args}`;
+}
+/**
+ * Merge tool call entries with deduplication (by derived key). Returns the new array.
+ */
+export function mergeToolCalls(existing, additions) {
+    const base = Array.isArray(existing) ? [...existing] : [];
+    const next = Array.isArray(additions) ? additions : [];
+    if (!next.length) {
+        return base;
+    }
+    const seen = new Set();
+    for (const call of base) {
+        const key = deriveToolCallKey(call);
+        if (key) {
+            seen.add(key);
+        }
+    }
+    for (const call of next) {
+        const key = deriveToolCallKey(call);
+        if (key && seen.has(key)) {
+            continue;
+        }
+        base.push(call);
+        if (key) {
+            seen.add(key);
+        }
+    }
+    return base;
+}

package/dist/conversion/shared/tool-governor.js

@@ -1,5 +1,8 @@
 // Unified tool governance API (标准)
 // Centralizes tool augmentation, guidance injection/refinement, and textual→tool_calls canonicalization
+// canonicalizer 按需加载（避免在请求侧仅注入时引入不必要的模块）
+// enforceChatBudget: 为避免在请求侧引入多余依赖，这里提供最小实现（保留形状，不裁剪）。
+import { augmentOpenAITools } from '../../guidance/index.js';
 function isObject(v) { return !!v && typeof v === 'object' && !Array.isArray(v); }
 // Note: tool schema strict augmentation removed per alignment
 function enforceChatBudget(chat, _modelId) { return chat; }
@@ -63,6 +66,8 @@ export function processChatRequestTools(request, opts) {
                     t.function = { ...fn, parameters: {} };
                 }
             }
+            // 严格化工具 schema（apply_patch/shell/MCP 等）保持在唯一治理点，避免重复注入
+            out.tools = augmentOpenAITools(tools);
         }
     }
     catch { /* best-effort: 保持原样 */ }

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

@@ -0,0 +1,19 @@
+import type { ChatToolDefinition } from '../hub/types/chat-envelope.js';
+import type { BridgeToolDefinition } from './bridge-message-types.js';
+export interface ToolCallFunction {
+    name: string;
+    arguments: string;
+}
+export interface ToolCallItem {
+    id?: string;
+    type: 'function';
+    function: ToolCallFunction;
+}
+export declare function stringifyArgs(args: unknown): string;
+export interface BridgeToolMapOptions {
+    sanitizeName?: (raw: unknown) => string | undefined;
+}
+export declare function bridgeToolToChatDefinition(rawTool: BridgeToolDefinition | Record<string, unknown> | null | undefined, options?: BridgeToolMapOptions): ChatToolDefinition | null;
+export declare function mapBridgeToolsToChat(rawTools: unknown, options?: BridgeToolMapOptions): ChatToolDefinition[] | undefined;
+export declare function chatToolToBridgeDefinition(rawTool: ChatToolDefinition | Record<string, unknown> | null | undefined, options?: BridgeToolMapOptions): BridgeToolDefinition | null;
+export declare function mapChatToolsToBridge(rawTools: unknown, options?: BridgeToolMapOptions): BridgeToolDefinition[] | undefined;

package/dist/conversion/shared/tool-mapping.js

@@ -8,3 +8,127 @@ export function stringifyArgs(args) {
         return String(args);
     }
 }
+const DEFAULT_SANITIZER = (value) => {
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        return trimmed.length ? trimmed : undefined;
+    }
+    return undefined;
+};
+function resolveToolName(candidate, options) {
+    const sanitized = options?.sanitizeName?.(candidate);
+    if (typeof sanitized === 'string' && sanitized.trim().length) {
+        return sanitized.trim();
+    }
+    return DEFAULT_SANITIZER(candidate);
+}
+function pickToolName(candidates, options) {
+    for (const candidate of candidates) {
+        const name = resolveToolName(candidate, options);
+        if (name) {
+            return name;
+        }
+    }
+    return undefined;
+}
+function resolveToolDescription(candidate) {
+    if (typeof candidate === 'string' && candidate.trim().length) {
+        return candidate.trim();
+    }
+    return undefined;
+}
+function resolveToolParameters(container, fallback) {
+    if (container && Object.prototype.hasOwnProperty.call(container, 'parameters')) {
+        return container.parameters;
+    }
+    if (fallback && Object.prototype.hasOwnProperty.call(fallback, 'parameters')) {
+        return fallback.parameters;
+    }
+    return undefined;
+}
+function resolveToolStrict(container, fallback) {
+    if (container && typeof container.strict === 'boolean') {
+        return container.strict;
+    }
+    if (fallback && typeof fallback.strict === 'boolean') {
+        return fallback.strict;
+    }
+    return undefined;
+}
+export function bridgeToolToChatDefinition(rawTool, options) {
+    if (!rawTool || typeof rawTool !== 'object') {
+        return null;
+    }
+    const tool = rawTool;
+    const fnNode = tool.function && typeof tool.function === 'object' ? tool.function : undefined;
+    const name = pickToolName([fnNode?.name, tool.name], options);
+    if (!name) {
+        return null;
+    }
+    const description = resolveToolDescription(fnNode?.description ?? tool.description);
+    const parameters = resolveToolParameters(fnNode, tool);
+    const strict = resolveToolStrict(fnNode, tool);
+    const rawType = typeof tool.type === 'string' && tool.type.trim().length ? tool.type.trim() : 'function';
+    const normalizedType = rawType.toLowerCase() === 'custom' ? 'function' : rawType;
+    const fnOut = { name };
+    if (description !== undefined) {
+        fnOut.description = description;
+    }
+    if (parameters !== undefined) {
+        fnOut.parameters = parameters;
+    }
+    if (strict !== undefined) {
+        fnOut.strict = strict;
+    }
+    return {
+        type: normalizedType,
+        function: fnOut
+    };
+}
+export function mapBridgeToolsToChat(rawTools, options) {
+    if (!Array.isArray(rawTools) || rawTools.length === 0) {
+        return undefined;
+    }
+    const mapped = rawTools
+        .map((entry) => bridgeToolToChatDefinition(entry, options))
+        .filter((entry) => !!entry);
+    return mapped.length ? mapped : undefined;
+}
+export function chatToolToBridgeDefinition(rawTool, options) {
+    if (!rawTool || typeof rawTool !== 'object') {
+        return null;
+    }
+    const tool = rawTool;
+    const fnNode = tool.function && typeof tool.function === 'object' ? tool.function : undefined;
+    const name = pickToolName([fnNode?.name, tool.name], options);
+    if (!name) {
+        return null;
+    }
+    const description = resolveToolDescription(fnNode?.description);
+    const parameters = resolveToolParameters(fnNode, undefined);
+    const strict = resolveToolStrict(fnNode, undefined);
+    const normalizedType = typeof tool.type === 'string' && tool.type.trim().length ? tool.type.trim() : 'function';
+    const responseShape = {
+        type: normalizedType,
+        name
+    };
+    if (description !== undefined) {
+        responseShape.description = description;
+    }
+    if (parameters !== undefined) {
+        responseShape.parameters = parameters;
+    }
+    if (strict !== undefined) {
+        responseShape.strict = strict;
+    }
+    return responseShape;
+}
+export function mapChatToolsToBridge(rawTools, options) {
+    if (!Array.isArray(rawTools) || rawTools.length === 0) {
+        return undefined;
+    }
+    const mapped = rawTools
+        .map((entry) => chatToolToBridgeDefinition(entry, options))
+        .filter((entry) => !!entry);
+    return mapped.length ? mapped : undefined;
+}

package/dist/conversion/shared/tool-normalizers.d.ts

@@ -0,0 +1,4 @@
+import type { ChatToolDefinition, MissingField } from '../hub/types/chat-envelope.js';
+import type { JsonValue } from '../hub/types/json.js';
+export declare function normalizeAnthropicTools(rawTools: JsonValue | undefined, missing?: MissingField[]): ChatToolDefinition[] | undefined;
+export declare function normalizeGeminiTools(rawTools: JsonValue | undefined, missing?: MissingField[]): ChatToolDefinition[] | undefined;

package/dist/conversion/shared/tool-normalizers.js

@@ -0,0 +1,84 @@
+import { isJsonObject, jsonClone } from '../hub/types/json.js';
+export function normalizeAnthropicTools(rawTools, missing) {
+    if (!Array.isArray(rawTools) || rawTools.length === 0)
+        return undefined;
+    const tools = [];
+    rawTools.forEach((entry, index) => {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+            missing?.push({
+                path: `tools[${index}]`,
+                reason: 'invalid_entry',
+                originalValue: jsonClone(entry)
+            });
+            return;
+        }
+        const nameValue = entry.name;
+        if (typeof nameValue !== 'string' || !nameValue.trim())
+            return;
+        const desc = entry.description;
+        const schema = entry.input_schema;
+        const parameters = schema && typeof schema === 'object' && !Array.isArray(schema)
+            ? schema
+            : { type: 'object', properties: {} };
+        tools.push({
+            type: 'function',
+            function: {
+                name: nameValue,
+                description: typeof desc === 'string' ? desc : undefined,
+                parameters
+            }
+        });
+    });
+    return tools.length ? tools : undefined;
+}
+export function normalizeGeminiTools(rawTools, missing) {
+    if (!rawTools)
+        return undefined;
+    const arr = Array.isArray(rawTools) ? rawTools : [rawTools];
+    const tools = [];
+    arr.forEach((entry, index) => {
+        if (!entry || typeof entry !== 'object') {
+            missing?.push({
+                path: `tools[${index}]`,
+                reason: 'invalid_entry',
+                originalValue: jsonClone(entry)
+            });
+            return;
+        }
+        const obj = entry;
+        const declarations = Array.isArray(obj.functionDeclarations) ? obj.functionDeclarations : undefined;
+        if (declarations && declarations.length) {
+            declarations.forEach((decl, declIndex) => {
+                if (!decl || typeof decl !== 'object') {
+                    missing?.push({ path: `tools[${index}].functionDeclarations[${declIndex}]`, reason: 'invalid_entry' });
+                    return;
+                }
+                const def = decl;
+                const name = typeof def.name === 'string' ? def.name : undefined;
+                if (!name)
+                    return;
+                tools.push({
+                    type: 'function',
+                    function: {
+                        name,
+                        description: typeof def.description === 'string' ? def.description : undefined,
+                        parameters: isJsonObject(def.parameters) ? jsonClone(def.parameters) : { type: 'object', properties: {} }
+                    }
+                });
+            });
+            return;
+        }
+        const name = typeof obj.name === 'string' ? obj.name : undefined;
+        if (!name)
+            return;
+        tools.push({
+            type: 'function',
+            function: {
+                name,
+                description: typeof obj.description === 'string' ? obj.description : undefined,
+                parameters: isJsonObject(obj.parameters) ? jsonClone(obj.parameters) : { type: 'object', properties: {} }
+            }
+        });
+    });
+    return tools.length ? tools : undefined;
+}

package/dist/router/virtual-router/bootstrap.js

@@ -99,7 +99,8 @@ function buildProviderRuntimeEntries(providers) {
                 auth: runtimeAuth,
                 outboundProfile: normalizedProvider.outboundProfile,
                 compatibilityProfile: normalizedProvider.compatibilityProfile,
-                processMode: normalizedProvider.processMode
+                processMode: normalizedProvider.processMode,
+                responsesConfig: normalizedProvider.responsesConfig
             };
         }
     }
@@ -154,7 +155,8 @@ function buildProviderProfiles(targetKeys, runtimeEntries) {
             compatibilityProfile: runtime.compatibilityProfile,
             runtimeKey,
             modelId: parsed.modelId,
-            processMode: runtime.processMode || 'chat'
+            processMode: runtime.processMode || 'chat',
+            responsesConfig: runtime.responsesConfig
         };
         targetRuntime[targetKey] = {
             ...runtime,
@@ -207,6 +209,7 @@ function normalizeProvider(providerId, raw) {
                 : '';
     const headers = normalizeHeaders(provider.headers);
     const compatibilityProfile = resolveCompatibilityProfile(provider);
+    const responsesConfig = normalizeResponsesConfig(provider);
     const processMode = normalizeProcessMode(provider.process);
     return {
         providerId,
@@ -215,9 +218,21 @@ function normalizeProvider(providerId, raw) {
         headers,
         outboundProfile: mapOutboundProfile(providerType),
         compatibilityProfile,
-        processMode
+        processMode,
+        responsesConfig
     };
 }
+function normalizeResponsesConfig(provider) {
+    const node = asRecord(provider.responses);
+    if (!node) {
+        return undefined;
+    }
+    const rawStyle = typeof node.toolCallIdStyle === 'string' ? node.toolCallIdStyle.trim().toLowerCase() : undefined;
+    if (rawStyle === 'fc' || rawStyle === 'preserve') {
+        return { toolCallIdStyle: rawStyle };
+    }
+    return undefined;
+}
 function resolveCompatibilityProfile(provider) {
     const compat = provider.compat;
     if (typeof compat === 'string' && compat.trim().length > 0) {

package/dist/router/virtual-router/provider-registry.js

@@ -41,7 +41,8 @@ export class ProviderRegistry {
             compatibilityProfile: profile.compatibilityProfile,
             runtimeKey: profile.runtimeKey,
             modelId,
-            processMode: profile.processMode || 'chat'
+            processMode: profile.processMode || 'chat',
+            responsesConfig: profile.responsesConfig
         };
     }
     static normalizeProfile(key, profile) {
@@ -56,7 +57,8 @@ export class ProviderRegistry {
             compatibilityProfile: profile.compatibilityProfile,
             runtimeKey: profile.runtimeKey,
             modelId,
-            processMode: profile.processMode || 'chat'
+            processMode: profile.processMode || 'chat',
+            responsesConfig: profile.responsesConfig
         };
     }
 }