@jsonstudio/llms 0.4.3 → 0.4.5

package/dist/conversion/shared/reasoning-tool-normalizer.js

@@ -0,0 +1,132 @@
+import { extractToolCallsFromReasoningText } from './reasoning-tool-parser.js';
+import { mergeToolCalls } from './tool-call-utils.js';
+const THINK_TAG_PATTERN = /<\/?think[^>]*>/gi;
+const REFLECTION_TAG_PATTERN = /<\/?reflection[^>]*>/gi;
+function flattenReasoning(value, depth = 0) {
+    if (depth > 4 || value == null) {
+        return '';
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value
+            .map((item) => flattenReasoning(item, depth + 1))
+            .filter(Boolean)
+            .join('\n');
+    }
+    if (typeof value === 'object') {
+        const record = value;
+        if (typeof record.text === 'string') {
+            return record.text;
+        }
+        if (typeof record.content === 'string') {
+            return record.content;
+        }
+        if (Array.isArray(record.content) || typeof record.content === 'object') {
+            return flattenReasoning(record.content, depth + 1);
+        }
+    }
+    return '';
+}
+function collectReasoningFragments(message) {
+    const fragments = [];
+    if ('reasoning_content' in message) {
+        const text = flattenReasoning(message.reasoning_content);
+        if (text) {
+            fragments.push(text);
+        }
+    }
+    if ('reasoning' in message) {
+        const text = flattenReasoning(message.reasoning);
+        if (text) {
+            fragments.push(text);
+        }
+    }
+    return fragments;
+}
+function writeReasoningContent(message, text) {
+    const trimmed = text.trim();
+    if (trimmed.length) {
+        message.reasoning_content = trimmed;
+    }
+    else if (Object.prototype.hasOwnProperty.call(message, 'reasoning_content')) {
+        delete message.reasoning_content;
+    }
+    if (typeof message.reasoning === 'string') {
+        if (trimmed.length) {
+            message.reasoning = trimmed;
+        }
+        else {
+            delete message.reasoning;
+        }
+    }
+}
+function stripReasoningTags(text) {
+    if (!text) {
+        return '';
+    }
+    return text.replace(THINK_TAG_PATTERN, '').replace(REFLECTION_TAG_PATTERN, '').trim();
+}
+export function normalizeMessageReasoningTools(message, options) {
+    if (!message || typeof message !== 'object') {
+        return { toolCallsAdded: 0 };
+    }
+    const fragments = collectReasoningFragments(message);
+    if (!fragments.length) {
+        const existing = typeof message.reasoning_content === 'string'
+            ? message.reasoning_content.trim()
+            : '';
+        if (!existing && Object.prototype.hasOwnProperty.call(message, 'reasoning_content')) {
+            delete message.reasoning_content;
+        }
+        return { toolCallsAdded: 0 };
+    }
+    const combined = fragments.join('\n').trim();
+    if (!combined.length) {
+        writeReasoningContent(message, '');
+        return { toolCallsAdded: 0 };
+    }
+    const sanitized = stripReasoningTags(combined);
+    if (!sanitized.length) {
+        writeReasoningContent(message, '');
+        return { toolCallsAdded: 0 };
+    }
+    const idPrefix = options?.idPrefix ?? 'reasoning';
+    const { cleanedText, toolCalls } = extractToolCallsFromReasoningText(sanitized, { idPrefix });
+    const trimmed = (cleanedText || '').trim();
+    writeReasoningContent(message, trimmed);
+    if (!Array.isArray(toolCalls) || toolCalls.length === 0) {
+        return { toolCallsAdded: 0, cleanedReasoning: trimmed };
+    }
+    const current = Array.isArray(message.tool_calls)
+        ? message.tool_calls
+        : undefined;
+    const merged = mergeToolCalls(current, toolCalls);
+    message.tool_calls = merged;
+    return {
+        toolCallsAdded: merged.length - (current?.length ?? 0),
+        cleanedReasoning: trimmed
+    };
+}
+export function normalizeChatResponseReasoningTools(response, options) {
+    if (!response || typeof response !== 'object') {
+        return;
+    }
+    const choices = Array.isArray(response.choices)
+        ? response.choices
+        : [];
+    for (let i = 0; i < choices.length; i++) {
+        const choice = choices[i];
+        if (!choice || typeof choice !== 'object') {
+            continue;
+        }
+        const message = choice.message;
+        if (!message || typeof message !== 'object') {
+            continue;
+        }
+        normalizeMessageReasoningTools(message, {
+            idPrefix: `${options?.idPrefixBase ?? 'reasoning_choice'}_${i + 1}`
+        });
+    }
+}

package/dist/conversion/shared/reasoning-tool-parser.d.ts

@@ -0,0 +1,10 @@
+type ToolCallRecord = Record<string, unknown>;
+interface ExtractionOptions {
+    idPrefix?: string;
+}
+interface ExtractionResult {
+    cleanedText: string;
+    toolCalls: ToolCallRecord[];
+}
+export declare function extractToolCallsFromReasoningText(text: string, options?: ExtractionOptions): ExtractionResult;
+export {};

package/dist/conversion/shared/reasoning-tool-parser.js

@@ -0,0 +1,95 @@
+import { repairArgumentsToString, parseLenient } from './jsonish.js';
+const FENCE_PATTERN = /```(?:tool_call|tool_calls|function_call|json)?\s*([\s\S]*?)\s*```/gi;
+const TAG_PATTERN = /<(tool_call|function_call)(?:\s+name="([^"]+)")?\s*>([\s\S]*?)<\/\1>/gi;
+const BRACKET_PATTERN = /\[(tool_call|function_call)(?:\s+name="([^"]+)")?\]([\s\S]*?)\[\/\1\]/gi;
+const LABEL_PATTERN = /(tool_call|function_call)\s*[:=]\s*({[\s\S]+?})/gi;
+export function extractToolCallsFromReasoningText(text, options) {
+    if (typeof text !== 'string' || !text.trim()) {
+        return { cleanedText: typeof text === 'string' ? text : '', toolCalls: [] };
+    }
+    const idPrefix = options?.idPrefix ?? 'reasoning';
+    const matches = [];
+    const consume = (pattern, getPayload) => {
+        pattern.lastIndex = 0;
+        let match;
+        while ((match = pattern.exec(text))) {
+            const payload = getPayload(match);
+            if (!payload) {
+                continue;
+            }
+            const parsed = parseToolCall(payload.body, payload.nameHint);
+            if (!parsed) {
+                continue;
+            }
+            matches.push({ start: match.index, end: match.index + match[0].length, call: parsed });
+        }
+    };
+    consume(FENCE_PATTERN, match => ({ body: match[1] ?? '' }));
+    consume(TAG_PATTERN, match => ({ body: match[3] ?? '', nameHint: match[2] }));
+    consume(BRACKET_PATTERN, match => ({ body: match[3] ?? '', nameHint: match[2] }));
+    consume(LABEL_PATTERN, match => ({ body: match[2] ?? '' }));
+    if (!matches.length) {
+        const parsed = parseToolCall(text);
+        if (parsed) {
+            return {
+                cleanedText: '',
+                toolCalls: [buildToolCall(parsed, idPrefix, 0)]
+            };
+        }
+        return { cleanedText: text, toolCalls: [] };
+    }
+    const toolCalls = matches.map((entry, index) => buildToolCall(entry.call, idPrefix, index));
+    matches.sort((a, b) => b.start - a.start);
+    let cleaned = text;
+    for (const entry of matches) {
+        cleaned = cleaned.slice(0, entry.start) + cleaned.slice(entry.end);
+    }
+    return {
+        cleanedText: cleaned.trim(),
+        toolCalls
+    };
+}
+function parseToolCall(raw, nameHint) {
+    if (!raw || typeof raw !== 'string') {
+        return null;
+    }
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        return null;
+    }
+    const parsed = parseLenient(trimmed);
+    if (!parsed || typeof parsed !== 'object') {
+        return null;
+    }
+    const candidateName = parsed.name ??
+        parsed.function?.name ??
+        parsed.tool_name ??
+        parsed.tool ??
+        nameHint;
+    const name = typeof candidateName === 'string' ? candidateName.trim() : undefined;
+    if (!name) {
+        return null;
+    }
+    const argsSource = parsed.function?.arguments ??
+        parsed.arguments ??
+        parsed.input ??
+        parsed.params ??
+        parsed.parameters ??
+        parsed.payload ??
+        {};
+    const args = repairArgumentsToString(argsSource);
+    return {
+        name,
+        args
+    };
+}
+function buildToolCall(parsed, prefix, index) {
+    return {
+        id: `${prefix}_${index + 1}`,
+        type: 'function',
+        function: {
+            name: parsed.name,
+            arguments: parsed.args
+        }
+    };
+}

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

@@ -0,0 +1,2 @@
+export declare function extractReasoningSegments(source: string, reasoningCollector?: string[]): string;
+export declare function sanitizeReasoningTaggedText(value: string): string;

package/dist/conversion/shared/reasoning-utils.js

@@ -0,0 +1,42 @@
+export function extractReasoningSegments(source, reasoningCollector) {
+    let working = source ?? '';
+    const hasExplicitOpen = /<think>/i.test(source) ||
+        /<reflection>/i.test(source) ||
+        /```\s*(?:think|reflection)/i.test(source);
+    const hasExplicitClose = /<\/think>/i.test(source) || /<\/reflection>/i.test(source);
+    const push = (value) => {
+        const trimmed = (value ?? '').trim();
+        if (trimmed && reasoningCollector) {
+            reasoningCollector.push(trimmed);
+        }
+    };
+    const patterns = [
+        /<think>([\s\S]*?)<\/think>/gi,
+        /<reflection>([\s\S]*?)<\/reflection>/gi,
+        /```\s*(?:think|reflection)[\s\S]*?```/gi
+    ];
+    for (const pattern of patterns) {
+        working = working.replace(pattern, (_match, inner) => {
+            push(inner);
+            return '';
+        });
+    }
+    working = working.replace(/<\/?think>/gi, '').replace(/<\/?reflection>/gi, '');
+    working = working.replace(/\n{3,}/g, '\n\n');
+    if (reasoningCollector && !hasExplicitOpen && hasExplicitClose) {
+        const trimmed = working.trim();
+        if (trimmed.length) {
+            reasoningCollector.push(trimmed);
+        }
+        return '';
+    }
+    return working.trim();
+}
+export function sanitizeReasoningTaggedText(value) {
+    try {
+        return extractReasoningSegments(value);
+    }
+    catch {
+        return value;
+    }
+}

package/dist/conversion/shared/responses-conversation-store.js

@@ -1,4 +1,3 @@
-import { normalizeFunctionCallOutputId } from './responses-id-utils.js';
 const TTL_MS = 1000 * 60 * 30; // 30 minutes safety window
 function cloneDeep(value) {
     try {
@@ -114,9 +113,8 @@ function normalizeSubmittedToolOutputs(toolOutputs) {
                 : typeof rec.id === 'string'
                     ? rec.id
                     : undefined;
-        if (!rawId || !rawId.trim())
-            return;
-        const callId = rawId.trim();
+        const trimmed = typeof rawId === 'string' ? rawId.trim() : '';
+        const callId = trimmed.length ? trimmed : `fc_resume_${index}`;
         const outputValue = rec.output ?? null;
         const normalizedOutput = typeof outputValue === 'string'
             ? outputValue
@@ -128,17 +126,13 @@ function normalizeSubmittedToolOutputs(toolOutputs) {
                     return String(outputValue ?? '');
                 }
             })();
-        const identifier = normalizeFunctionCallOutputId({
-            callId,
-            fallback: `fc_resume_${index}`
-        });
         items.push({
             type: 'function_call_output',
-            id: identifier,
-            call_id: identifier,
+            id: callId,
+            call_id: callId,
             output: normalizedOutput
         });
-        submitted.push({ callId: identifier, originalId: callId, outputText: normalizedOutput });
+        submitted.push({ callId, originalId: rawId ?? callId, outputText: normalizedOutput });
     });
     return { items, submitted };
 }

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

@@ -0,0 +1,15 @@
+import type { ResponsesInputItem } from './responses-types.js';
+export declare function normalizeResponseRole(role: unknown): string;
+export declare function normalizeArgumentsBySchema(argsStringOrObj: unknown, _functionName: string | undefined, _tools: unknown): string;
+export declare function normalizeToolOutput(entry: ResponsesInputItem): string | null;
+export interface BuildResponsesInputOptions {
+    messages: Array<Record<string, unknown>>;
+    tools?: Array<Record<string, unknown>> | undefined;
+}
+export interface BuildResponsesInputResult {
+    input: ResponsesInputItem[];
+    combinedSystemInstruction?: string;
+    latestUserInstruction?: string;
+    originalSystemMessages: string[];
+}
+export declare function buildResponsesInputFromChatMessages(options: BuildResponsesInputOptions): BuildResponsesInputResult;

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

@@ -0,0 +1,206 @@
+import { normalizeFunctionCallId, normalizeFunctionCallOutputId } from './responses-id-utils.js';
+export function normalizeResponseRole(role) {
+    if (typeof role === 'string') {
+        const normalized = role.toLowerCase();
+        if (normalized === 'system' || normalized === 'assistant' || normalized === 'user' || normalized === 'tool') {
+            return normalized;
+        }
+    }
+    return 'user';
+}
+export function normalizeArgumentsBySchema(argsStringOrObj, _functionName, _tools) {
+    if (typeof argsStringOrObj === 'string')
+        return argsStringOrObj;
+    try {
+        return JSON.stringify(argsStringOrObj ?? {});
+    }
+    catch {
+        return String(argsStringOrObj);
+    }
+}
+export 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 collectText(value) {
+    if (!value)
+        return '';
+    if (typeof value === 'string')
+        return value;
+    if (Array.isArray(value)) {
+        return value.map(part => collectText(part)).join('');
+    }
+    if (typeof value === 'object') {
+        const record = value;
+        if (typeof record.text === 'string')
+            return record.text;
+        if (Array.isArray(record.content))
+            return collectText(record.content);
+        if (typeof record.content === 'string')
+            return record.content;
+    }
+    return '';
+}
+function extractUserTextFromEntry(entry) {
+    if (!entry || typeof entry !== 'object')
+        return '';
+    const directContent = entry.content ?? entry.message?.content;
+    if (typeof directContent === 'string')
+        return directContent.trim();
+    if (Array.isArray(directContent)) {
+        return directContent.map(block => collectText(block)).join('').trim();
+    }
+    const text = entry.text ?? entry.message?.text;
+    if (typeof text === 'string')
+        return text.trim();
+    return '';
+}
+export function buildResponsesInputFromChatMessages(options) {
+    const { messages, tools } = options;
+    const input = [];
+    const systemParts = [];
+    const originalSystemMessages = [];
+    let latestUserInstruction = null;
+    const pendingToolCallIds = [];
+    const knownToolCallIds = new Set();
+    const toolCallIdAliases = new Map();
+    for (const m of messages) {
+        if (!m || typeof m !== 'object')
+            continue;
+        const role = normalizeResponseRole(m.role || 'user');
+        const content = m.content;
+        const collectedText = collectText(content);
+        const text = role === 'system' ? collectedText : collectedText.trim();
+        if (role === 'system') {
+            if (collectedText && collectedText.length) {
+                originalSystemMessages.push(collectedText);
+                systemParts.push(collectedText);
+            }
+            continue;
+        }
+        if (role === 'tool') {
+            const rawToolId = m.tool_call_id ||
+                m.call_id ||
+                m.tool_use_id ||
+                m.id ||
+                undefined;
+            let callId = typeof rawToolId === 'string' ? rawToolId : undefined;
+            if (callId && toolCallIdAliases.has(callId)) {
+                callId = toolCallIdAliases.get(callId);
+            }
+            if (!callId || !knownToolCallIds.has(callId)) {
+                const fallbackId = pendingToolCallIds.length ? pendingToolCallIds.shift() : undefined;
+                if (fallbackId) {
+                    if (callId && callId !== fallbackId) {
+                        toolCallIdAliases.set(callId, fallbackId);
+                    }
+                    callId = fallbackId;
+                }
+            }
+            else if (callId) {
+                const idx = pendingToolCallIds.indexOf(callId);
+                if (idx >= 0)
+                    pendingToolCallIds.splice(idx, 1);
+            }
+            const normalizedCallId = normalizeFunctionCallId({
+                callId,
+                fallback: `fc_call_${input.length + 1}`
+            });
+            if (callId && callId !== normalizedCallId) {
+                toolCallIdAliases.set(callId, normalizedCallId);
+            }
+            const normalizedId = normalizeFunctionCallOutputId({
+                callId: normalizedCallId,
+                fallback: `fc_tool_${input.length + 1}`
+            });
+            const entry = {
+                type: 'function_call_output',
+                id: normalizedId,
+                call_id: normalizedCallId,
+                output: text || undefined
+            };
+            input.push(entry);
+            continue;
+        }
+        const toolCalls = Array.isArray(m.tool_calls) ? m.tool_calls : [];
+        if (toolCalls.length) {
+            for (const tc of toolCalls) {
+                try {
+                    const rawId = typeof tc?.id === 'string' && tc.id
+                        ? String(tc.id)
+                        : `call_${Math.random().toString(36).slice(2, 8)}`;
+                    const normalizedCallId = normalizeFunctionCallId({
+                        callId: rawId,
+                        fallback: `fc_call_${input.length + 1}`
+                    });
+                    if (rawId !== normalizedCallId) {
+                        toolCallIdAliases.set(rawId, normalizedCallId);
+                    }
+                    const fn = tc?.function || {};
+                    const name = typeof fn?.name === 'string' ? String(fn.name) : 'tool';
+                    const argsRaw = fn?.arguments;
+                    const args = typeof argsRaw === 'string'
+                        ? argsRaw
+                        : normalizeArgumentsBySchema(argsRaw, name, tools);
+                    const entry = {
+                        type: 'function_call',
+                        id: normalizedCallId,
+                        call_id: normalizedCallId,
+                        name,
+                        arguments: args
+                    };
+                    input.push(entry);
+                    knownToolCallIds.add(normalizedCallId);
+                    pendingToolCallIds.push(normalizedCallId);
+                }
+                catch {
+                    // ignore malformed tool_call
+                }
+            }
+            continue;
+        }
+        if (text) {
+            const tRole = role === 'assistant' ? 'output_text' : 'input_text';
+            const entry = {
+                type: 'message',
+                role,
+                content: [{ type: tRole, text }]
+            };
+            input.push(entry);
+            if (role === 'user') {
+                latestUserInstruction = text;
+            }
+        }
+    }
+    if (!latestUserInstruction) {
+        for (let i = input.length - 1; i >= 0; i -= 1) {
+            const entry = input[i];
+            const roleSource = entry?.role ?? entry?.message?.role;
+            const role = typeof roleSource === 'string' ? roleSource.toLowerCase() : '';
+            if (role !== 'user')
+                continue;
+            const text = extractUserTextFromEntry(entry);
+            if (text) {
+                latestUserInstruction = text;
+                break;
+            }
+        }
+    }
+    const combinedSystemInstruction = systemParts.join('\n\n').trim();
+    return {
+        input,
+        combinedSystemInstruction: combinedSystemInstruction.length ? combinedSystemInstruction : undefined,
+        latestUserInstruction: latestUserInstruction || undefined,
+        originalSystemMessages
+    };
+}

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

@@ -0,0 +1,15 @@
+import type { ResponsesOutputItem } from '../../sse/types/index.js';
+export interface BuildResponsesOutputOptions {
+    response: Record<string, unknown>;
+    message?: Record<string, unknown>;
+    requestId?: string;
+    sanitizeFunctionName: (raw: unknown) => string | undefined;
+}
+export interface BuildResponsesOutputResult {
+    outputItems: ResponsesOutputItem[];
+    outputText: string;
+    status: string;
+    requiredAction?: Record<string, unknown>;
+    usage?: unknown;
+}
+export declare function buildResponsesOutputFromChat(options: BuildResponsesOutputOptions): BuildResponsesOutputResult;