@jsonstudio/llms 0.4.6 → 0.6.2

package/dist/conversion/hub/types/chat-envelope.d.ts

@@ -0,0 +1,68 @@
+export type ChatRole = 'system' | 'user' | 'assistant' | 'tool';
+import type { JsonObject, JsonValue } from './json.js';
+export interface ChatMessageContentPart {
+    type: string;
+    text?: string;
+    [key: string]: JsonValue;
+}
+export interface ChatToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+    [key: string]: JsonValue;
+}
+export interface ChatMessage {
+    role: ChatRole;
+    content?: string | ChatMessageContentPart[] | null;
+    tool_calls?: ChatToolCall[];
+    name?: string;
+    [key: string]: JsonValue;
+}
+export interface ChatToolDefinition {
+    type: 'function' | string;
+    function: {
+        name: string;
+        description?: string;
+        parameters?: JsonValue;
+        strict?: boolean;
+    };
+    [key: string]: JsonValue;
+}
+export interface ChatToolOutput {
+    tool_call_id: string;
+    content: string;
+    name?: string;
+    [key: string]: JsonValue;
+}
+export interface MissingField extends JsonObject {
+    path: string;
+    reason: string;
+    originalValue?: JsonValue;
+}
+export interface AdapterContext {
+    requestId: string;
+    entryEndpoint: string;
+    providerProtocol: string;
+    providerId?: string;
+    routeId?: string;
+    profileId?: string;
+    streamingHint?: 'auto' | 'force' | 'disable';
+    originalModelId?: string;
+    clientModelId?: string;
+    toolCallIdStyle?: 'fc' | 'preserve';
+    [key: string]: JsonValue;
+}
+export interface ChatEnvelope {
+    messages: ChatMessage[];
+    tools?: ChatToolDefinition[];
+    toolOutputs?: ChatToolOutput[];
+    parameters?: JsonObject;
+    metadata: {
+        context: AdapterContext;
+        missingFields?: MissingField[];
+        [key: string]: JsonValue;
+    };
+}

package/dist/conversion/hub/types/standardized.d.ts

@@ -0,0 +1,97 @@
+import type { ChatMessageContentPart } from './chat-envelope.js';
+import type { JsonObject } from './json.js';
+export type ToolChoice = 'none' | 'auto' | 'required' | {
+    type: 'function';
+    function: {
+        name: string;
+    };
+} | Record<string, unknown>;
+export interface StandardizedTool {
+    type: 'function';
+    function: {
+        name: string;
+        description?: string;
+        parameters: {
+            type?: string | string[];
+            properties?: Record<string, unknown>;
+            required?: string[];
+            additionalProperties?: boolean;
+            [key: string]: unknown;
+        };
+        strict?: boolean;
+    };
+}
+export interface ToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+export interface ToolCallResult {
+    tool_call_id: string;
+    status: 'success' | 'error' | 'timeout' | 'pending';
+    result?: JsonObject | JsonObject[] | string | number | boolean | null;
+    error?: string;
+    executionTime?: number;
+}
+export type StandardizedMessageContent = string | ChatMessageContentPart[] | null;
+export interface StandardizedMessage {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: StandardizedMessageContent;
+    tool_calls?: ToolCall[];
+    tool_call_id?: string;
+    name?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface StandardizedParameters {
+    temperature?: number;
+    max_tokens?: number;
+    top_p?: number;
+    frequency_penalty?: number;
+    presence_penalty?: number;
+    stop?: string | string[];
+    stream?: boolean;
+    [key: string]: unknown;
+}
+export interface StandardizedMetadata {
+    originalEndpoint: string;
+    capturedContext?: Record<string, unknown>;
+    requestId?: string;
+    stream?: boolean;
+    toolChoice?: ToolChoice;
+    providerKey?: string;
+    providerType?: string;
+    processMode?: 'chat' | 'passthrough';
+    routeHint?: string;
+    [key: string]: unknown;
+}
+export interface StandardizedRequest {
+    model: string;
+    messages: StandardizedMessage[];
+    tools?: StandardizedTool[];
+    parameters: StandardizedParameters;
+    metadata: StandardizedMetadata;
+}
+export interface ProcessedRequest extends StandardizedRequest {
+    processed: {
+        timestamp: number;
+        appliedRules: string[];
+        status: 'success' | 'partial' | 'failed';
+    };
+    processingMetadata: {
+        toolCalls?: ToolCallResult[];
+        streaming?: {
+            enabled: boolean;
+            chunkCount?: number;
+            totalTokens?: number;
+        };
+        context?: {
+            systemPrompt?: string;
+            conversationHistory?: string[];
+            relevantContext?: Record<string, unknown>;
+        };
+        passthrough?: boolean;
+    };
+}

package/dist/conversion/pipeline/codecs/v2/anthropic-openai-pipeline.js

@@ -14,6 +14,23 @@ function assertJsonObject(value, stage) {
     }
     return value;
 }
+function coerceAliasMap(candidate) {
+    if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)) {
+        return undefined;
+    }
+    let populated = false;
+    const result = {};
+    for (const [key, value] of Object.entries(candidate)) {
+        if (typeof key !== 'string' || typeof value !== 'string')
+            continue;
+        const trimmedKey = key.trim();
+        if (!trimmedKey.length)
+            continue;
+        result[trimmedKey] = value;
+        populated = true;
+    }
+    return populated ? result : undefined;
+}
 function createAnthropicHooks() {
     const formatAdapter = new AnthropicFormatAdapter();
     const semanticMapper = new AnthropicSemanticMapper();
@@ -28,6 +45,12 @@ function createAnthropicHooks() {
                 });
                 const formatEnvelope = await formatAdapter.parseRequest(wire, adapterContext);
                 const chatEnvelope = await semanticMapper.toChat(formatEnvelope, adapterContext);
+                const aliasMap = coerceAliasMap(adapterContext.anthropicToolNameMap) ??
+                    coerceAliasMap(chatEnvelope.metadata?.anthropicToolNameMap);
+                if (aliasMap) {
+                    context.metadata = context.metadata ?? {};
+                    context.metadata.anthropicToolNameMap = aliasMap;
+                }
                 const canonical = chatEnvelopeToStandardized(chatEnvelope, {
                     adapterContext,
                     endpoint: context.entryEndpoint ?? DEFAULT_ANTHROPIC_ENDPOINT,
@@ -37,8 +60,12 @@ function createAnthropicHooks() {
             }
         },
         outbound: {
-            serialize: async ({ canonical }) => {
-                const anthropicPayload = buildAnthropicFromOpenAIChat(canonical);
+            serialize: async ({ canonical, context }) => {
+                const aliasMap = coerceAliasMap(context.metadata?.anthropicToolNameMap);
+                const anthropicPayload = buildAnthropicFromOpenAIChat(canonical, {
+                    toolNameMap: aliasMap,
+                    requestId: context.requestId
+                });
                 return { payload: assertJsonObject(anthropicPayload, 'anthropic_outbound_serialize') };
             }
         }

package/dist/conversion/pipeline/codecs/v2/responses-openai-pipeline.js

@@ -14,6 +14,71 @@ function assertJsonObject(value, stage) {
     }
     return value;
 }
+function sanitizeResponsesMessages(payload) {
+    const messages = Array.isArray(payload?.messages) ? payload.messages : [];
+    if (!messages.length)
+        return;
+    const sanitized = [];
+    let counter = 0;
+    const normalizeId = (raw) => {
+        if (typeof raw !== 'string')
+            return undefined;
+        const trimmed = raw.trim();
+        if (!trimmed.length)
+            return undefined;
+        if (trimmed.startsWith('fc_'))
+            return trimmed;
+        const stripped = trimmed.replace(/^call[_-]?/i, '');
+        const normalized = stripped.length ? stripped : trimmed;
+        return normalized.startsWith('fc_') ? normalized : `fc_${normalized}`;
+    };
+    for (const message of messages) {
+        if (!message || typeof message !== 'object')
+            continue;
+        const role = String(message.role || '').toLowerCase();
+        if (role === 'assistant' && Array.isArray(message.tool_calls) && message.tool_calls.length) {
+            message.tool_calls = message.tool_calls.map((call) => {
+                if (!call || typeof call !== 'object')
+                    return call;
+                const existing = normalizeId(call.id) ?? normalizeId(call.call_id) ?? `fc_function_call_${counter++}`;
+                if (existing) {
+                    call.id = existing;
+                }
+                if (call.call_id !== undefined)
+                    delete call.call_id;
+                if (call.tool_call_id !== undefined)
+                    delete call.tool_call_id;
+                return call;
+            });
+            sanitized.push(message);
+            continue;
+        }
+        if (role === 'tool') {
+            const clone = { ...message };
+            const normalizedToolId = normalizeId(clone.tool_call_id ?? clone.call_id);
+            if (normalizedToolId) {
+                clone.tool_call_id = normalizedToolId;
+            }
+            else if (typeof clone.tool_call_id === 'string') {
+                const trimmed = clone.tool_call_id.trim();
+                if (!trimmed.length) {
+                    delete clone.tool_call_id;
+                }
+                else {
+                    clone.tool_call_id = trimmed;
+                }
+            }
+            if ('call_id' in clone)
+                delete clone.call_id;
+            if ('id' in clone)
+                delete clone.id;
+            sanitized.push(clone);
+            continue;
+        }
+        sanitized.push(message);
+    }
+    payload.messages = sanitized;
+}
 function cloneResponsesContext(context) {
     try {
         return JSON.parse(JSON.stringify(context ?? {}));
@@ -143,7 +208,9 @@ export class ResponsesOpenAIPipelineCodec {
             entryEndpoint: context.entryEndpoint ?? DEFAULT_RESPONSES_ENDPOINT,
             endpoint: context.endpoint ?? DEFAULT_RESPONSES_ENDPOINT
         };
-        return runStandardChatRequestFilters(openaiPayload, profile, filterContext);
+        const filtered = await runStandardChatRequestFilters(openaiPayload, profile, filterContext);
+        sanitizeResponsesMessages(filtered);
+        return filtered;
     }
     async convertResponse(payload, profile, context) {
         this.ensureInitialized();

package/dist/conversion/responses/responses-openai-bridge.d.ts

@@ -1,7 +1,9 @@
 import type { BridgeInputItem, BridgeToolDefinition } from '../shared/bridge-message-types.js';
 import type { ChatToolDefinition } from '../hub/types/chat-envelope.js';
 import type { BridgeInputBuildResult } from '../shared/bridge-message-utils.js';
-export interface ResponsesRequestContext {
+import type { ToolCallIdStyle } from '../shared/responses-tool-utils.js';
+type Unknown = Record<string, unknown>;
+export interface ResponsesRequestContext extends Unknown {
     requestId?: string;
     originalSystemMessages?: string[];
     input?: BridgeInputItem[];
@@ -24,6 +26,9 @@ export interface ResponsesRequestContext {
     } | null;
     toolsRaw?: BridgeToolDefinition[];
     toolsNormalized?: Array<Record<string, unknown>>;
+    parameters?: Record<string, unknown>;
+    systemInstruction?: string;
+    toolCallIdStyle?: ToolCallIdStyle;
 }
 export interface BuildChatRequestResult {
     request: Record<string, unknown>;

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

@@ -17,10 +17,11 @@ function isObject(v) {
 // NOTE: 自修复提示已移除（统一标准：不做模糊兜底）。
 // --- Public bridge functions ---
 export function captureResponsesContext(payload, dto) {
+    const preservedInput = cloneBridgeEntries(payload.input);
     ensureBridgeInstructions(payload);
     const context = {
         requestId: dto?.route?.requestId,
-        input: Array.isArray(payload.input) ? payload.input : undefined,
+        input: preservedInput,
         include: payload.include,
         store: payload.store,
         toolChoice: payload.tool_choice,
@@ -30,8 +31,14 @@ export function captureResponsesContext(payload, dto) {
         stream: typeof payload.stream === 'boolean' ? payload.stream : undefined,
         isChatPayload: Array.isArray(payload.messages)
     };
+    if (payload.parameters && typeof payload.parameters === 'object') {
+        context.parameters = { ...payload.parameters };
+    }
+    if (typeof payload.instructions === 'string' && payload.instructions.trim().length) {
+        context.systemInstruction = payload.instructions;
+    }
     if (Array.isArray(payload.tools)) {
-        context.toolsRaw = payload.tools;
+        context.toolsRaw = cloneBridgeEntries(payload.tools);
     }
     context.isResponsesPayload = !context.isChatPayload && Array.isArray(context.input);
     return context;
@@ -154,7 +161,6 @@ export function buildResponsesRequestFromChat(payload, ctx, extras) {
         'response_format',
         'user',
         'top_p',
-        'max_output_tokens',
         'logit_bias',
         'seed'
     ];
@@ -162,9 +168,6 @@ export function buildResponsesRequestFromChat(payload, ctx, extras) {
         if (chat[key] !== undefined)
             out[key] = chat[key];
     }
-    if (typeof chat.max_tokens === 'number' && chat.max_output_tokens === undefined) {
-        out.max_output_tokens = chat.max_tokens;
-    }
     let messages = Array.isArray(chat.messages) ? chat.messages : [];
     let bridgeMetadata;
     try {
@@ -193,8 +196,21 @@ export function buildResponsesRequestFromChat(payload, ctx, extras) {
         // ignore policy errors
     }
     const envelopeMetadata = ctx?.metadata && typeof ctx.metadata === 'object' ? ctx.metadata : undefined;
-    const toolCallIdStyle = resolveToolCallIdStyle(envelopeMetadata);
-    const historySeed = normalizeBridgeHistory(bridgeMetadata?.bridgeHistory ?? envelopeMetadata?.bridgeHistory ?? extras?.bridgeHistory);
+    const metadataExtraFields = extractMetadataExtraFields(envelopeMetadata);
+    const contextToolCallIdStyle = readToolCallIdStyleFromContext(ctx);
+    const toolCallIdStyle = contextToolCallIdStyle ?? resolveToolCallIdStyle(envelopeMetadata);
+    const fallbackHistory = ctx?.input && Array.isArray(ctx.input)
+        ? {
+            input: ctx.input,
+            originalSystemMessages: ctx.originalSystemMessages,
+            combinedSystemInstruction: ctx.systemInstruction
+        }
+        : undefined;
+    const historySeed = normalizeBridgeHistory(extras?.bridgeHistory) ??
+        normalizeBridgeHistory(fallbackHistory) ??
+        normalizeBridgeHistory(bridgeMetadata?.bridgeHistory) ??
+        normalizeBridgeHistory(envelopeMetadata?.bridgeHistory) ??
+        fallbackHistory;
     const history = historySeed ??
         convertMessagesToBridgeInput({
             messages,
@@ -206,6 +222,7 @@ export function buildResponsesRequestFromChat(payload, ctx, extras) {
     }
     const { input, combinedSystemInstruction, originalSystemMessages } = history;
     const instructionCandidates = [
+        typeof ctx?.systemInstruction === 'string' && ctx.systemInstruction.trim().length ? ctx.systemInstruction.trim() : undefined,
         typeof extras?.systemInstruction === 'string' && extras.systemInstruction.trim().length ? extras.systemInstruction.trim() : undefined,
         typeof envelopeMetadata?.systemInstruction === 'string' && envelopeMetadata.systemInstruction.trim().length ? envelopeMetadata.systemInstruction.trim() : undefined,
         combinedSystemInstruction && combinedSystemInstruction.length > 0 ? combinedSystemInstruction : undefined
@@ -233,9 +250,112 @@ export function buildResponsesRequestFromChat(payload, ctx, extras) {
     else if (resolvedStream === false) {
         out.stream = false;
     }
+    if (ctx?.include !== undefined && out.include === undefined) {
+        out.include = ctx.include;
+    }
+    else if (metadataExtraFields?.include !== undefined && out.include === undefined) {
+        out.include = metadataExtraFields.include;
+    }
+    if (ctx?.store !== undefined && out.store === undefined) {
+        out.store = ctx.store;
+    }
+    else if (metadataExtraFields?.store !== undefined && out.store === undefined) {
+        out.store = metadataExtraFields.store;
+    }
+    if (ctx?.toolChoice !== undefined && out.tool_choice === undefined) {
+        out.tool_choice = ctx.toolChoice;
+    }
+    else if (metadataExtraFields?.tool_choice !== undefined && out.tool_choice === undefined) {
+        out.tool_choice = metadataExtraFields.tool_choice;
+    }
+    if (typeof ctx?.parallelToolCalls === 'boolean' && out.parallel_tool_calls === undefined) {
+        out.parallel_tool_calls = ctx.parallelToolCalls;
+    }
+    else if (typeof metadataExtraFields?.parallel_tool_calls === 'boolean' && out.parallel_tool_calls === undefined) {
+        out.parallel_tool_calls = metadataExtraFields.parallel_tool_calls;
+    }
+    if (ctx?.responseFormat !== undefined && out.response_format === undefined) {
+        out.response_format = ctx.responseFormat;
+    }
+    else if (metadataExtraFields?.response_format !== undefined && out.response_format === undefined) {
+        out.response_format = metadataExtraFields.response_format;
+    }
+    if (ctx?.metadata && Object.keys(ctx.metadata).length) {
+        out.metadata = { ...ctx.metadata };
+    }
+    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 };
+    }
     ensureBridgeInstructions(out);
     return { request: out, originalSystemMessages };
 }
+function readToolCallIdStyleFromContext(ctx) {
+    if (!ctx) {
+        return undefined;
+    }
+    const direct = normalizeToolCallIdStyleCandidate(ctx.toolCallIdStyle);
+    if (direct) {
+        return direct;
+    }
+    if (ctx.metadata && typeof ctx.metadata === 'object') {
+        const fromMetadata = normalizeToolCallIdStyleCandidate(ctx.metadata.toolCallIdStyle);
+        if (fromMetadata) {
+            return fromMetadata;
+        }
+    }
+    return undefined;
+}
+function normalizeToolCallIdStyleCandidate(candidate) {
+    if (typeof candidate !== 'string') {
+        return undefined;
+    }
+    const normalized = candidate.trim().toLowerCase();
+    if (normalized === 'fc') {
+        return 'fc';
+    }
+    if (normalized === 'preserve') {
+        return 'preserve';
+    }
+    return undefined;
+}
+function cloneBridgeEntries(entries) {
+    if (!Array.isArray(entries)) {
+        return undefined;
+    }
+    return entries.map((entry) => {
+        if (!entry || typeof entry !== 'object') {
+            return entry;
+        }
+        try {
+            return JSON.parse(JSON.stringify(entry));
+        }
+        catch {
+            return entry;
+        }
+    });
+}
+function extractMetadataExtraFields(metadata) {
+    if (!metadata) {
+        return undefined;
+    }
+    const extras = metadata.extraFields;
+    if (extras && typeof extras === 'object' && !Array.isArray(extras)) {
+        return extras;
+    }
+    return undefined;
+}
+function isPlainObject(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
 export function buildResponsesPayloadFromChat(payload, context) {
     if (!payload || typeof payload !== 'object')
         return payload;
@@ -297,9 +417,11 @@ export function buildResponsesPayloadFromChat(payload, context) {
         created_at: response.created_at || response.created || Math.floor(Date.now() / 1000),
         model: response.model,
         status: outputBuild.status,
-        output: outputBuild.outputItems,
-        output_text: outputBuild.outputText || ''
+        output: outputBuild.outputItems
     };
+    if (typeof outputBuild.outputText === 'string') {
+        out.output_text = outputBuild.outputText;
+    }
     if (outputBuild.usage !== undefined)
         out.usage = outputBuild.usage;
     if (outputBuild.requiredAction)

package/dist/conversion/shared/anthropic-message-utils.d.ts

@@ -1,12 +1,20 @@
 import type { ChatToolDefinition, MissingField } from '../hub/types/chat-envelope.js';
+import { type JsonObject } from '../hub/types/json.js';
 type Unknown = Record<string, unknown>;
 type UnknownArray = Unknown[];
 interface OpenAIChatPayload extends Unknown {
     messages: UnknownArray;
 }
+export declare function normalizeAnthropicToolName(value: unknown): string | undefined;
+export declare function denormalizeAnthropicToolName(value: unknown): string | undefined;
 export declare function buildOpenAIChatFromAnthropic(payload: unknown): OpenAIChatPayload;
-export declare function buildAnthropicFromOpenAIChat(oa: unknown): Unknown;
+export interface BuildAnthropicFromOpenAIOptions {
+    toolNameMap?: Record<string, string>;
+    requestId?: string;
+}
+export declare function buildAnthropicFromOpenAIChat(oa: unknown, options?: BuildAnthropicFromOpenAIOptions): Unknown;
 export declare function buildAnthropicRequestFromOpenAIChat(chatReq: unknown): Unknown;
 export declare function mapAnthropicToolsToChat(rawTools: unknown, missing?: MissingField[]): ChatToolDefinition[] | undefined;
 export declare function mapChatToolsToAnthropicTools(rawTools: unknown): UnknownArray | undefined;
+export declare function buildAnthropicToolAliasMap(rawTools: unknown): JsonObject | undefined;
 export {};