@jsonstudio/llms 0.4.4 → 0.4.6

package/dist/conversion/shared/responses-output-builder.js

@@ -0,0 +1,179 @@
+import { normalizeFunctionCallId } from './bridge-id-utils.js';
+import { normalizeContentPart } from './output-content-normalizer.js';
+import { expandResponsesMessageItem } from '../../sse/shared/responses-output-normalizer.js';
+export function buildResponsesOutputFromChat(options) {
+    const { response, message, requestId, sanitizeFunctionName } = options;
+    const outputItems = [];
+    const allocateOutputId = (prefix) => `${prefix}_${requestId ?? Date.now()}_${outputItems.length + 1}`;
+    const role = message?.role || 'assistant';
+    const content = message?.content;
+    const reasoningText = typeof message?.reasoning_content === 'string' && message.reasoning_content.trim().length
+        ? String(message.reasoning_content).trim()
+        : undefined;
+    const convertedContent = convertChatContentToResponses(content);
+    if (message || convertedContent.length > 0 || reasoningText) {
+        const responsesMessage = {
+            id: allocateOutputId('message'),
+            type: 'message',
+            status: 'completed',
+            role,
+            content: convertedContent.length > 0 ? convertedContent : []
+        };
+        const expandedItems = expandResponsesMessageItem(responsesMessage, {
+            requestId: requestId ?? 'responses_outbound',
+            outputIndex: outputItems.length,
+            extraReasoning: reasoningText
+        });
+        for (const expanded of expandedItems) {
+            outputItems.push(expanded);
+        }
+    }
+    let toolCalls = Array.isArray(message?.tool_calls) ? message.tool_calls : [];
+    const normalizedToolCalls = [];
+    try {
+        toolCalls = toolCalls.filter((it) => {
+            const nm = (it && typeof it === 'object') ? (it?.function?.name || it.name) : undefined;
+            return typeof nm === 'string' && nm.trim().length > 0 && nm.toLowerCase() !== 'tool';
+        });
+    }
+    catch {
+        /* ignore */
+    }
+    let toolFallbackCounter = 0;
+    for (const call of toolCalls) {
+        const outputEntry = buildFunctionCallOutput(call, allocateOutputId, sanitizeFunctionName, outputItems.length, ++toolFallbackCounter);
+        if (outputEntry) {
+            outputItems.push(outputEntry.output);
+            normalizedToolCalls.push({
+                id: outputEntry.call_id,
+                name: outputEntry.name,
+                args: outputEntry.arguments
+            });
+        }
+    }
+    const usage = normalizeUsage(response.usage);
+    const outputText = extractOutputText(convertedContent);
+    const hasToolCalls = toolCalls.length > 0;
+    if (hasToolCalls) {
+        for (const item of outputItems) {
+            if (item.type === 'message') {
+                item.status = 'in_progress';
+            }
+        }
+    }
+    const requiredAction = normalizedToolCalls.length
+        ? buildRequiredActionFromNormalized(normalizedToolCalls)
+        : undefined;
+    const status = hasToolCalls ? 'requires_action' : 'completed';
+    return {
+        outputItems,
+        outputText,
+        status,
+        requiredAction,
+        usage
+    };
+}
+function normalizeUsage(usageRaw) {
+    if (usageRaw && typeof usageRaw === 'object') {
+        const usage = { ...usageRaw };
+        if (usage.input_tokens != null && usage.prompt_tokens == null) {
+            usage.prompt_tokens = usage.input_tokens;
+        }
+        if (usage.output_tokens != null && usage.completion_tokens == null) {
+            usage.completion_tokens = usage.output_tokens;
+        }
+        if (usage.prompt_tokens != null && usage.completion_tokens != null && usage.total_tokens == null) {
+            const total = Number(usage.prompt_tokens) + Number(usage.completion_tokens);
+            if (!Number.isNaN(total))
+                usage.total_tokens = total;
+        }
+        try {
+            delete usage.input_tokens;
+            delete usage.output_tokens;
+        }
+        catch {
+            /* ignore */
+        }
+        return usage;
+    }
+    return usageRaw;
+}
+function buildFunctionCallOutput(call, allocateOutputId, sanitizeFunctionName, baseCount, offset) {
+    try {
+        const fn = call?.function || {};
+        const callName = typeof fn?.name === 'string' && fn.name.trim().length
+            ? fn.name
+            : (typeof call.name === 'string' ? call.name : 'tool');
+        const sanitized = sanitizeFunctionName(callName);
+        if (!sanitized || sanitized.toLowerCase() === 'tool')
+            return null;
+        const rawArgs = fn?.arguments ?? call.arguments ?? {};
+        const argsStr = typeof rawArgs === 'string'
+            ? rawArgs
+            : (() => {
+                try {
+                    return JSON.stringify(rawArgs ?? {});
+                }
+                catch {
+                    return '{}';
+                }
+            })();
+        const originalCallId = typeof call.id === 'string' && call.id.trim().length
+            ? String(call.id)
+            : (typeof call.call_id === 'string' && call.call_id.trim().length ? String(call.call_id) : undefined);
+        const callId = originalCallId && originalCallId.trim().length
+            ? originalCallId.trim()
+            : normalizeFunctionCallId({
+                callId: originalCallId,
+                fallback: `fc_call_${baseCount + offset}`
+            });
+        const output = {
+            id: allocateOutputId('function_call'),
+            type: 'function_call',
+            status: 'in_progress',
+            name: sanitized,
+            call_id: callId,
+            arguments: argsStr
+        };
+        return { output, call_id: callId, name: sanitized, arguments: argsStr };
+    }
+    catch {
+        return null;
+    }
+}
+function buildRequiredActionFromNormalized(calls) {
+    if (!calls.length)
+        return undefined;
+    const submitCalls = calls.map((entry) => ({
+        id: entry.id,
+        type: 'function',
+        function: {
+            name: entry.name,
+            arguments: entry.args
+        }
+    }));
+    return { type: 'submit_tool_outputs', submit_tool_outputs: { tool_calls: submitCalls } };
+}
+function convertChatContentToResponses(content) {
+    if (content == null)
+        return [];
+    if (Array.isArray(content)) {
+        return content
+            .map((part) => normalizeContentPart(part, []))
+            .filter((entry) => !!entry);
+    }
+    const normalized = normalizeContentPart(content, []);
+    return normalized ? [normalized] : [];
+}
+function extractOutputText(parts) {
+    if (!parts.length)
+        return '';
+    const reasoningCollector = [];
+    const normalizedTexts = parts
+        .map((part) => normalizeContentPart(part, reasoningCollector))
+        .filter((entry) => !!entry)
+        .map((entry) => (typeof entry.text === 'string' ? entry.text : ''))
+        .filter(Boolean);
+    const text = normalizedTexts.join('\n').trim();
+    return text.length ? text : '';
+}

package/dist/conversion/shared/responses-output-utils.d.ts

@@ -0,0 +1,7 @@
+type UnknownRecord = Record<string, unknown>;
+export declare function extractResponsesOutputSegments(response: UnknownRecord | undefined): {
+    textParts: string[];
+    reasoningParts: string[];
+};
+export declare function normalizeResponsesContentPart(part: unknown, reasoningCollector: string[]): UnknownRecord | null;
+export {};

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

@@ -0,0 +1,108 @@
+import { extractReasoningSegments, sanitizeReasoningTaggedText } from './reasoning-utils.js';
+function collectMessageTexts(blocks, accumulator) {
+    const pushText = (value) => {
+        if (typeof value === 'string' && value.trim().length) {
+            const cleaned = extractReasoningSegments(value, accumulator.reasoningParts);
+            if (cleaned.length) {
+                accumulator.textParts.push(cleaned);
+            }
+        }
+    };
+    if (typeof blocks === 'string') {
+        pushText(blocks);
+        return;
+    }
+    if (!Array.isArray(blocks))
+        return;
+    for (const block of blocks) {
+        if (!block || typeof block !== 'object')
+            continue;
+        const type = typeof block.type === 'string' ? String(block.type).toLowerCase() : '';
+        if (type === 'text' || type === 'input_text' || type === 'output_text' || type === 'commentary') {
+            pushText(block.text ?? block.content);
+            continue;
+        }
+        if (Array.isArray(block.content)) {
+            collectMessageTexts(block.content, accumulator);
+            continue;
+        }
+        if (typeof block.text === 'string') {
+            pushText(block.text);
+        }
+    }
+}
+export function extractResponsesOutputSegments(response) {
+    if (!response || typeof response !== 'object') {
+        return { textParts: [], reasoningParts: [] };
+    }
+    const textParts = [];
+    const reasoningParts = [];
+    const outputItems = Array.isArray(response.output) ? response.output : [];
+    for (const item of outputItems) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const type = typeof item.type === 'string' ? String(item.type).toLowerCase() : '';
+        if (type === 'message') {
+            const message = item.message && typeof item.message === 'object'
+                ? item.message
+                : item;
+            const content = Array.isArray(message.content) ? message.content : [];
+            collectMessageTexts(content, { textParts, reasoningParts });
+            continue;
+        }
+        if (type === 'output_text') {
+            if (typeof item.text === 'string') {
+                const cleaned = extractReasoningSegments(item.text, reasoningParts);
+                if (cleaned.length) {
+                    textParts.push(cleaned);
+                }
+            }
+            continue;
+        }
+        if (type === 'reasoning') {
+            const content = Array.isArray(item.content) ? item.content : [];
+            for (const block of content) {
+                if (block && typeof block === 'object' && typeof block.text === 'string') {
+                    const sanitized = sanitizeReasoningTaggedText(block.text);
+                    if (sanitized.length)
+                        reasoningParts.push(sanitized);
+                }
+            }
+        }
+    }
+    return { textParts, reasoningParts };
+}
+export function normalizeResponsesContentPart(part, reasoningCollector) {
+    if (part == null) {
+        return null;
+    }
+    if (typeof part === 'string') {
+        const cleaned = extractReasoningSegments(part, reasoningCollector);
+        return { type: 'output_text', text: cleaned };
+    }
+    if (typeof part !== 'object') {
+        return { type: 'output_text', text: sanitizeReasoningTaggedText(String(part)) };
+    }
+    const clone = { ...part };
+    delete clone._initialText;
+    delete clone._hasDelta;
+    if (typeof clone.text === 'string') {
+        clone.text = extractReasoningSegments(clone.text, reasoningCollector);
+    }
+    if (clone.output_text && typeof clone.output_text === 'object' && typeof clone.output_text.text === 'string') {
+        clone.output_text = {
+            ...clone.output_text,
+            text: extractReasoningSegments(clone.output_text.text, reasoningCollector)
+        };
+    }
+    if (typeof clone.content === 'string') {
+        clone.content = extractReasoningSegments(clone.content, reasoningCollector);
+    }
+    if (!clone.type) {
+        clone.type = 'output_text';
+    }
+    if (clone.type === 'output_text' && typeof clone.text !== 'string') {
+        clone.text = '';
+    }
+    return clone;
+}

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

@@ -0,0 +1,28 @@
+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;

package/dist/conversion/shared/responses-request-adapter.js

@@ -1,5 +1,6 @@
 import { normalizeFunctionCallId, normalizeFunctionCallOutputId } from './responses-id-utils.js';
 import { ensureResponsesInstructions } from './responses-instructions.js';
+import { serializeToolArguments, coerceBridgeRole, serializeToolOutput } from './bridge-message-utils.js';
 export function captureResponsesContext(payload, dto) {
     ensureResponsesInstructions(payload);
     const context = {
@@ -197,7 +198,7 @@ function mapResponsesInputToChat(options) {
         if (typeof entry.content === 'string') {
             const directText = (entry.content || '').toString().trim();
             if (directText.length) {
-                const normalizedRole = normalizeResponseRole(entry.role || 'user');
+                const normalizedRole = coerceBridgeRole(entry.role || 'user');
                 messages.push({ role: normalizedRole, content: directText });
                 continue;
             }
@@ -215,7 +216,7 @@ function mapResponsesInputToChat(options) {
             if (callIdRaw && callIdRaw !== callId) {
                 toolCallIdAliases.set(callIdRaw, callId);
             }
-            const serialized = normalizeArgumentsBySchema(parsedArgs, name, toolsNormalized).trim();
+            const serialized = serializeToolArguments(parsedArgs, name, toolsNormalized).trim();
             toolNameById.set(callId, name);
             messages.push({ role: 'assistant', tool_calls: [{ id: callId, type: 'function', function: { name, arguments: serialized } }] });
             lastToolCallId = callId;
@@ -233,7 +234,7 @@ function mapResponsesInputToChat(options) {
                 }
                 toolCallId = normalized;
             }
-            const output = normalizeToolOutput(entry);
+            const output = serializeToolOutput(entry);
             if (toolCallId) {
                 try {
                     let contentStr = output != null ? String(output) : '';
@@ -266,7 +267,7 @@ function mapResponsesInputToChat(options) {
                 messages.push({ role: 'assistant', tool_calls: toolCalls });
             for (const msg of toolMessages)
                 messages.push(msg);
-            const normalizedRole = normalizeResponseRole((explicit.role ?? entry.role) || 'user');
+            const normalizedRole = coerceBridgeRole((explicit.role ?? entry.role) || 'user');
             if (typeof text === 'string' && text.trim().length) {
                 messages.push({ role: normalizedRole, content: text.trim() });
             }
@@ -279,7 +280,7 @@ function mapResponsesInputToChat(options) {
                 messages.push({ role: 'assistant', tool_calls: toolCalls });
             for (const msg of toolMessages)
                 messages.push(msg);
-            const normalizedRole = normalizeResponseRole(entry.role || 'user');
+            const normalizedRole = coerceBridgeRole(entry.role || 'user');
             if (typeof text === 'string' && text.trim().length) {
                 messages.push({ role: normalizedRole, content: text.trim() });
             }
@@ -288,7 +289,7 @@ function mapResponsesInputToChat(options) {
         try {
             const t = String(entry.type || '').toLowerCase();
             if ((t === 'input_text' || t === 'text' || t === 'output_text' || t === 'commentary') && typeof entry.text === 'string') {
-                const normalizedRole = normalizeResponseRole(entry.role || 'user');
+                const normalizedRole = coerceBridgeRole(entry.role || 'user');
                 const s = entry.text;
                 if (s && s.length)
                     messages.push({ role: normalizedRole, content: s });
@@ -339,7 +340,7 @@ function processMessageBlocks(blocks, toolsNormalized, toolNameById, toolCallIdA
                 currentLastCall = null;
                 continue;
             }
-            const serialized = normalizeArgumentsBySchema(parsedArgs, name, toolsNormalized).trim();
+            const serialized = serializeToolArguments(parsedArgs, name, toolsNormalized).trim();
             toolNameById.set(callId, name);
             toolCalls.push({ id: callId, type: 'function', function: { name, arguments: serialized } });
             currentLastCall = callId;
@@ -357,7 +358,7 @@ function processMessageBlocks(blocks, toolsNormalized, toolNameById, toolCallIdA
                 }
                 toolCallId = normalized;
             }
-            const output = normalizeToolOutput(block);
+            const output = serializeToolOutput(block);
             if (toolCallId) {
                 try {
                     let contentStr = output != null ? String(output) : '';
@@ -390,38 +391,6 @@ function processMessageBlocks(blocks, toolsNormalized, toolNameById, toolCallIdA
         lastCallId: currentLastCall
     };
 }
-function normalizeResponseRole(role) {
-    if (typeof role === 'string') {
-        const normalized = role.toLowerCase();
-        if (normalized === 'system' || normalized === 'assistant' || normalized === 'user' || normalized === 'tool')
-            return normalized;
-    }
-    return 'user';
-}
-function normalizeArgumentsBySchema(argsStringOrObj, _functionName, _tools) {
-    if (typeof argsStringOrObj === 'string')
-        return argsStringOrObj;
-    try {
-        return JSON.stringify(argsStringOrObj ?? {});
-    }
-    catch {
-        return String(argsStringOrObj);
-    }
-}
-function normalizeToolOutput(entry) {
-    const out = entry?.output;
-    if (typeof out === 'string')
-        return out;
-    if (out && typeof out === 'object') {
-        try {
-            return JSON.stringify(out);
-        }
-        catch {
-            return String(out);
-        }
-    }
-    return null;
-}
 function normalizeTools(tools) {
     const normalized = [];
     for (const tool of tools) {

package/dist/conversion/shared/responses-response-utils.d.ts

@@ -0,0 +1,3 @@
+export declare function collectToolCallsFromResponses(response: Record<string, unknown>): Array<Record<string, unknown>>;
+export declare function resolveFinishReason(response: Record<string, unknown>, toolCalls: Array<Record<string, unknown>>): string;
+export declare function buildChatResponseFromResponses(payload: unknown): Record<string, unknown> | unknown;

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

@@ -0,0 +1,209 @@
+import { sanitizeResponsesFunctionName } from './responses-tool-utils.js';
+import { normalizeFunctionCallId } from './bridge-id-utils.js';
+import { extractOutputSegments } from './output-content-normalizer.js';
+import { sanitizeReasoningTaggedText } from './reasoning-utils.js';
+import { createBridgeActionState, runBridgeActionPipeline } from './bridge-actions.js';
+import { resolveBridgePolicy, resolvePolicyActions } from './bridge-policies.js';
+function selectCallId(entry) {
+    const candidates = [
+        entry?.call_id,
+        entry?.tool_call_id,
+        entry?.tool_use_id,
+        entry?.id
+    ];
+    for (const candidate of candidates) {
+        if (typeof candidate === 'string' && candidate.trim().length > 0) {
+            return candidate.trim();
+        }
+    }
+    return undefined;
+}
+function normalizeToolCall(entry, fallbackPrefix) {
+    if (!entry || typeof entry !== 'object')
+        return null;
+    const fn = entry.function || {};
+    const rawName = sanitizeResponsesFunctionName(fn.name ?? entry.name);
+    if (!rawName)
+        return null;
+    const argsRaw = fn.arguments ?? entry.arguments ?? {};
+    const argsStr = typeof argsRaw === 'string'
+        ? argsRaw
+        : (() => {
+            try {
+                return JSON.stringify(argsRaw ?? {});
+            }
+            catch {
+                return '{}';
+            }
+        })();
+    const callIdRaw = selectCallId(entry);
+    const callId = typeof callIdRaw === 'string' && callIdRaw.length
+        ? callIdRaw
+        : normalizeFunctionCallId({
+            callId: callIdRaw,
+            fallback: `${fallbackPrefix}_${Math.random().toString(36).slice(2, 10)}`
+        });
+    return {
+        id: callId,
+        type: 'function',
+        function: {
+            name: rawName,
+            arguments: argsStr
+        }
+    };
+}
+export function collectToolCallsFromResponses(response) {
+    const collected = [];
+    const seenIds = new Set();
+    const pushCall = (call, source) => {
+        if (!call)
+            return;
+        const key = typeof call.id === 'string' ? call.id : `${source}_${collected.length}`;
+        if (key && seenIds.has(key))
+            return;
+        if (key)
+            seenIds.add(key);
+        collected.push(call);
+    };
+    const required = response?.required_action?.submit_tool_outputs?.tool_calls;
+    if (Array.isArray(required)) {
+        for (const call of required) {
+            pushCall(normalizeToolCall(call, 'req_call'), 'req_call');
+        }
+    }
+    const outputItems = Array.isArray(response.output) ? response.output : [];
+    for (const item of outputItems) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const type = typeof item.type === 'string' ? String(item.type).toLowerCase() : '';
+        if (type !== 'function_call')
+            continue;
+        pushCall(normalizeToolCall(item, 'output_call'), 'output_call');
+    }
+    return collected;
+}
+export function resolveFinishReason(response, toolCalls) {
+    const meta = response.metadata && typeof response.metadata === 'object'
+        ? response.metadata
+        : undefined;
+    if (meta && typeof meta.finish_reason === 'string') {
+        return meta.finish_reason;
+    }
+    if (toolCalls.length > 0) {
+        return 'tool_calls';
+    }
+    const status = typeof response.status === 'string' ? response.status.toLowerCase() : '';
+    if (status === 'requires_action')
+        return 'tool_calls';
+    if (status === 'in_progress' || status === 'streaming')
+        return 'length';
+    if (status === 'cancelled')
+        return 'cancelled';
+    if (status === 'failed')
+        return 'error';
+    return 'stop';
+}
+function unwrapResponsesResponse(payload) {
+    if (!payload || typeof payload !== 'object')
+        return undefined;
+    if (typeof payload.object === 'string' && payload.object === 'response') {
+        return payload;
+    }
+    if (Array.isArray(payload.output) ||
+        typeof payload.status === 'string' ||
+        payload.required_action) {
+        return payload;
+    }
+    let current = payload;
+    const visited = new Set();
+    while (current && typeof current === 'object' && !Array.isArray(current)) {
+        if (visited.has(current))
+            break;
+        visited.add(current);
+        if (typeof current.object === 'string' && current.object === 'response') {
+            return current;
+        }
+        if (current.response && typeof current.response === 'object') {
+            current = current.response;
+            continue;
+        }
+        if (current.data && typeof current.data === 'object') {
+            current = current.data;
+            continue;
+        }
+        break;
+    }
+    return undefined;
+}
+export function buildChatResponseFromResponses(payload) {
+    if (!payload || typeof payload !== 'object')
+        return payload;
+    const response = unwrapResponsesResponse(payload);
+    if (!response) {
+        if (Array.isArray(payload.choices))
+            return payload;
+        return payload;
+    }
+    const id = typeof response.id === 'string' ? response.id : `resp_${Date.now()}`;
+    const model = response.model;
+    const created = typeof response.created_at === 'number'
+        ? response.created_at
+        : (response.created ?? Math.floor(Date.now() / 1000));
+    const usage = response.usage;
+    const toolCalls = collectToolCallsFromResponses(response);
+    const { textParts, reasoningParts } = extractOutputSegments(response);
+    const explicitOutput = typeof response.output_text === 'string' && response.output_text.trim().length
+        ? sanitizeReasoningTaggedText(response.output_text)
+        : undefined;
+    const messageContentText = explicitOutput || textParts.join('\n').trim();
+    const messageContent = messageContentText || '';
+    const message = {
+        role: 'assistant',
+        content: messageContent
+    };
+    try {
+        const bridgePolicy = resolveBridgePolicy({ protocol: 'openai-responses', moduleType: 'openai-responses' });
+        const policyActions = resolvePolicyActions(bridgePolicy, 'response_inbound');
+        if (policyActions?.length) {
+            const actionState = createBridgeActionState({
+                messages: [message],
+                rawResponse: response
+            });
+            runBridgeActionPipeline({
+                stage: 'response_inbound',
+                actions: policyActions,
+                protocol: bridgePolicy?.protocol ?? 'openai-responses',
+                moduleType: bridgePolicy?.moduleType ?? 'openai-responses',
+                requestId: typeof response?.id === 'string' ? response.id : undefined,
+                state: actionState
+            });
+        }
+    }
+    catch {
+        // Ignore policy errors
+    }
+    if (toolCalls.length) {
+        message.tool_calls = toolCalls;
+    }
+    if (reasoningParts.length) {
+        message.reasoning_content = reasoningParts.join('\n');
+    }
+    const finishReason = resolveFinishReason(response, toolCalls);
+    const chat = {
+        id,
+        object: 'chat.completion',
+        created,
+        model,
+        choices: [
+            {
+                index: 0,
+                finish_reason: finishReason,
+                message
+            }
+        ]
+    };
+    if (usage !== undefined) {
+        chat.usage = usage;
+    }
+    return chat;
+}

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

@@ -0,0 +1,12 @@
+export type ToolCallIdStyle = 'preserve' | 'fc';
+type BridgeInputItem = Record<string, unknown>;
+export interface CallIdTransformer {
+    normalizeCallId(raw: unknown): string;
+    normalizeOutputId(callId: string, raw: unknown): string;
+}
+export declare function createToolCallIdTransformer(style: ToolCallIdStyle): CallIdTransformer | null;
+export declare function enforceToolCallIdStyle(input: BridgeInputItem[], transformer: CallIdTransformer): void;
+export declare function resolveToolCallIdStyle(metadata: Record<string, unknown> | undefined): ToolCallIdStyle;
+export declare function stripInternalToolingMetadata(metadata: unknown): void;
+export declare function sanitizeResponsesFunctionName(rawName: unknown): string | undefined;
+export {};