@jsonstudio/rcc 0.85.9 → 0.89.3

package/node_modules/@jsonstudio/llms/dist/conversion/shared/responses-output-builder.js

@@ -0,0 +1,230 @@
+import { normalizeFunctionCallId } from './bridge-id-utils.js';
+import { normalizeContentPart } from './output-content-normalizer.js';
+import { expandResponsesMessageItem } from '../../sse/shared/responses-output-normalizer.js';
+function appendReasoningSegments(target, raw) {
+    if (typeof raw !== 'string' || !raw.length) {
+        return;
+    }
+    const segments = raw.split('\n');
+    let previousValue;
+    for (const segment of segments) {
+        if (!segment.length)
+            continue;
+        let value = segment;
+        if (previousValue) {
+            const prevLast = previousValue.charAt(previousValue.length - 1) || '';
+            const currFirst = segment.charAt(0) || '';
+            const prevWord = /[A-Za-z0-9_]$/.test(prevLast);
+            const currWord = /^[A-Za-z0-9]/.test(currFirst);
+            const currQuote = currFirst === '"' || currFirst === "'";
+            const prevPunct = /[:;]/.test(prevLast);
+            const prevEndsWhitespace = /\s$/.test(previousValue);
+            const prevSentenceEnd = /[.?!"]$/.test(prevLast);
+            if (((prevWord || prevSentenceEnd) && currWord && !prevEndsWhitespace) ||
+                (prevPunct && currQuote)) {
+                value = ` ${segment}`;
+            }
+        }
+        target.push(value);
+        previousValue = value;
+    }
+}
+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;
+    let toolCalls = Array.isArray(message?.tool_calls) ? message.tool_calls : [];
+    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 */
+    }
+    const hasToolCalls = toolCalls.length > 0;
+    const reasoningChunks = [];
+    const preservedReasoning = Array.isArray(response?.__responses_reasoning)
+        ? response.__responses_reasoning
+        : undefined;
+    if (preservedReasoning && preservedReasoning.length) {
+        reasoningChunks.push(...preservedReasoning);
+    }
+    else {
+        appendReasoningSegments(reasoningChunks, message?.reasoning_content);
+    }
+    const convertedContent = convertChatContentToResponses(content);
+    const shouldEmitMessage = Boolean(message) && (convertedContent.length > 0 || reasoningChunks.length > 0 || !hasToolCalls);
+    if (shouldEmitMessage) {
+        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: reasoningChunks
+        });
+        for (const expanded of expandedItems) {
+            outputItems.push(expanded);
+        }
+    }
+    const normalizedToolCalls = [];
+    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 outputTextMeta = response?.__responses_output_text_meta;
+    const outputText = resolveOutputText(convertedContent, outputTextMeta);
+    const hasNormalizedToolCalls = normalizedToolCalls.length > 0;
+    if (hasNormalizedToolCalls) {
+        for (const item of outputItems) {
+            if (item.type === 'message') {
+                item.status = 'in_progress';
+            }
+        }
+    }
+    const requiredAction = hasNormalizedToolCalls
+        ? buildRequiredActionFromNormalized(normalizedToolCalls)
+        : undefined;
+    const status = hasNormalizedToolCalls ? '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 = 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 : '';
+}
+function resolveOutputText(parts, meta) {
+    if (meta && typeof meta === 'object') {
+        const hasField = Boolean(meta.hasField);
+        if (hasField) {
+            const raw = meta.value;
+            if (typeof raw === 'string') {
+                return raw;
+            }
+            return '';
+        }
+        return undefined;
+    }
+    const text = extractOutputText(parts);
+    return text.length ? text : undefined;
+}

package/node_modules/@jsonstudio/llms/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/node_modules/@jsonstudio/llms/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/node_modules/@jsonstudio/llms/dist/conversion/shared/responses-reasoning-registry.d.ts

@@ -0,0 +1,8 @@
+export interface ResponsesOutputTextMeta {
+    hasField: boolean;
+    value?: string;
+}
+export declare function registerResponsesReasoning(id: unknown, segments: string[] | undefined): void;
+export declare function consumeResponsesReasoning(id: unknown): string[] | undefined;
+export declare function registerResponsesOutputTextMeta(id: unknown, meta: ResponsesOutputTextMeta | undefined): void;
+export declare function consumeResponsesOutputTextMeta(id: unknown): ResponsesOutputTextMeta | undefined;

package/node_modules/@jsonstudio/llms/dist/conversion/shared/responses-reasoning-registry.js

@@ -0,0 +1,61 @@
+const registry = new Map();
+function ensureEntry(id) {
+    let entry = registry.get(id);
+    if (!entry) {
+        entry = {};
+        registry.set(id, entry);
+    }
+    return entry;
+}
+function pruneEntry(id) {
+    const entry = registry.get(id);
+    if (!entry)
+        return;
+    if (!entry.reasoning && !entry.outputText) {
+        registry.delete(id);
+    }
+}
+export function registerResponsesReasoning(id, segments) {
+    if (typeof id !== 'string')
+        return;
+    if (!Array.isArray(segments) || segments.length === 0)
+        return;
+    const entry = ensureEntry(id);
+    entry.reasoning = [...segments];
+}
+export function consumeResponsesReasoning(id) {
+    if (typeof id !== 'string')
+        return undefined;
+    const entry = registry.get(id);
+    if (!entry?.reasoning)
+        return undefined;
+    const value = [...entry.reasoning];
+    entry.reasoning = undefined;
+    pruneEntry(id);
+    return value;
+}
+export function registerResponsesOutputTextMeta(id, meta) {
+    if (typeof id !== 'string')
+        return;
+    if (!meta)
+        return;
+    const entry = ensureEntry(id);
+    entry.outputText = {
+        hasField: Boolean(meta.hasField),
+        value: typeof meta.value === 'string' ? meta.value : undefined
+    };
+}
+export function consumeResponsesOutputTextMeta(id) {
+    if (typeof id !== 'string')
+        return undefined;
+    const entry = registry.get(id);
+    if (!entry?.outputText)
+        return undefined;
+    const value = {
+        hasField: Boolean(entry.outputText.hasField),
+        value: entry.outputText.value
+    };
+    entry.outputText = undefined;
+    pruneEntry(id);
+    return value;
+}

package/node_modules/@jsonstudio/llms/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;