@jsonstudio/llms 0.4.3 → 0.4.5

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

@@ -0,0 +1,473 @@
+import { normalizeFunctionCallId, normalizeFunctionCallOutputId } from './bridge-id-utils.js';
+import { normalizeChatMessageContent } from './chat-output-normalizer.js';
+export function coerceBridgeRole(role) {
+    if (typeof role === 'string') {
+        const normalized = role.toLowerCase();
+        if (normalized === 'system' || normalized === 'assistant' || normalized === 'user' || normalized === 'tool') {
+            return normalized;
+        }
+    }
+    return 'user';
+}
+export function serializeToolArguments(argsStringOrObj, _functionName, _tools) {
+    if (typeof argsStringOrObj === 'string')
+        return argsStringOrObj;
+    try {
+        return JSON.stringify(argsStringOrObj ?? {});
+    }
+    catch {
+        return String(argsStringOrObj);
+    }
+}
+export function serializeToolOutput(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 convertMessagesToBridgeInput(options) {
+    const { messages, tools } = options;
+    const input = [];
+    const systemParts = [];
+    const originalSystemMessages = [];
+    let latestUserInstruction = null;
+    const pendingToolCallIds = [];
+    const knownToolCallIds = new Set();
+    for (const m of messages) {
+        if (!m || typeof m !== 'object')
+            continue;
+        const role = coerceBridgeRole(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.trim().length ? rawToolId.trim() : undefined;
+            if (callId && knownToolCallIds.has(callId)) {
+                const idx = pendingToolCallIds.indexOf(callId);
+                if (idx >= 0)
+                    pendingToolCallIds.splice(idx, 1);
+            }
+            if (!callId && pendingToolCallIds.length) {
+                callId = pendingToolCallIds.shift();
+            }
+            if (!callId) {
+                callId = normalizeFunctionCallId({
+                    callId,
+                    fallback: `fc_call_${input.length + 1}`
+                });
+            }
+            knownToolCallIds.add(callId);
+            const normalizedId = normalizeFunctionCallOutputId({
+                callId,
+                fallback: `fc_tool_${input.length + 1}`
+            });
+            const entry = {
+                type: 'function_call_output',
+                id: normalizedId,
+                call_id: callId,
+                output: typeof text === 'string' ? text : ''
+            };
+            input.push(entry);
+            continue;
+        }
+        const toolCalls = Array.isArray(m.tool_calls) ? m.tool_calls : [];
+        if (toolCalls.length) {
+            for (const tc of toolCalls) {
+                try {
+                    const rawIdCandidate = (typeof tc?.id === 'string' && tc.id.trim().length ? tc.id.trim() : undefined) ??
+                        (typeof tc?.call_id === 'string' && tc.call_id.trim().length ? tc.call_id.trim() : undefined);
+                    const callId = rawIdCandidate ?? normalizeFunctionCallId({
+                        callId: rawIdCandidate,
+                        fallback: `fc_call_${input.length + 1}`
+                    });
+                    const fn = tc?.function || {};
+                    const name = typeof fn?.name === 'string' ? String(fn.name) : 'tool';
+                    const argsRaw = fn?.arguments;
+                    const args = typeof argsRaw === 'string'
+                        ? argsRaw
+                        : serializeToolArguments(argsRaw, name, tools);
+                    const entry = {
+                        type: 'function_call',
+                        id: callId,
+                        call_id: callId,
+                        name,
+                        arguments: args
+                    };
+                    input.push(entry);
+                    knownToolCallIds.add(callId);
+                    pendingToolCallIds.push(callId);
+                }
+                catch {
+                    // ignore malformed tool_call
+                }
+            }
+            continue;
+        }
+        if (typeof text === 'string') {
+            const tRole = role === 'assistant' ? 'output_text' : 'input_text';
+            const entry = {
+                type: 'message',
+                role,
+                content: [{ type: tRole, text }]
+            };
+            input.push(entry);
+            if (role === 'user') {
+                const trimmed = typeof text === 'string' ? text.trim() : '';
+                if (trimmed.length) {
+                    latestUserInstruction = trimmed;
+                }
+            }
+        }
+    }
+    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
+    };
+}
+function defaultNormalizeFunctionName(raw) {
+    if (typeof raw !== 'string')
+        return undefined;
+    const trimmed = raw.trim();
+    return trimmed.length ? trimmed : undefined;
+}
+function toReasoningSegments(value) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => (typeof entry === 'string' ? entry.trim() : '')).filter((entry) => entry.length);
+    }
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        return trimmed.length ? [trimmed] : [];
+    }
+    return [];
+}
+function combineReasoningSegments(primary, secondary) {
+    const combined = [];
+    if (Array.isArray(primary)) {
+        combined.push(...primary.filter((entry) => typeof entry === 'string' && entry.trim().length).map((entry) => entry.trim()));
+    }
+    if (Array.isArray(secondary)) {
+        combined.push(...secondary.filter((entry) => typeof entry === 'string' && entry.trim().length).map((entry) => entry.trim()));
+    }
+    return combined;
+}
+function pushNormalizedChatMessage(target, role, rawContent, options) {
+    if (typeof rawContent !== 'string') {
+        return;
+    }
+    const normalized = normalizeChatMessageContent(rawContent);
+    const contentText = typeof normalized.contentText === 'string' ? normalized.contentText : '';
+    const reasoningText = typeof normalized.reasoningText === 'string' ? normalized.reasoningText.trim() : '';
+    const hasContent = contentText.trim().length > 0;
+    if (!hasContent && !reasoningText) {
+        return;
+    }
+    const message = {
+        role,
+        content: contentText
+    };
+    const combinedReasoning = combineReasoningSegments(reasoningText.length ? [reasoningText] : [], options?.reasoningSegments);
+    if (combinedReasoning.length) {
+        message.reasoning_content = combinedReasoning.join('\n');
+    }
+    target.push(message);
+}
+function processMessageBlocks(blocks, normalizeFunctionName, tools, toolNameById, lastToolCallId, toolResultFallbackText) {
+    const textParts = [];
+    const toolCalls = [];
+    const toolMessages = [];
+    let currentLastCall = lastToolCallId;
+    const reasoningSegments = [];
+    for (const block of blocks) {
+        if (!block || typeof block !== 'object')
+            continue;
+        const type = typeof block.type === 'string' ? block.type.toLowerCase() : '';
+        if (type === 'input_text' || type === 'output_text' || type === 'text' || type === 'commentary') {
+            if (typeof block.text === 'string')
+                textParts.push(block.text);
+            else if (typeof block.content === 'string')
+                textParts.push(block.content);
+            reasoningSegments.push(...toReasoningSegments(block.reasoning_content));
+            continue;
+        }
+        if (type === 'message' && Array.isArray(block.content)) {
+            const nested = processMessageBlocks(block.content, normalizeFunctionName, tools, toolNameById, currentLastCall, toolResultFallbackText);
+            if (nested.text)
+                textParts.push(nested.text);
+            for (const tc of nested.toolCalls)
+                toolCalls.push(tc);
+            for (const tm of nested.toolMessages)
+                toolMessages.push(tm);
+            currentLastCall = nested.lastCallId;
+            reasoningSegments.push(...nested.reasoningSegments);
+            continue;
+        }
+        if (type === 'function_call') {
+            const rawName = typeof block.name === 'string'
+                ? block.name
+                : (typeof block?.function?.name === 'string'
+                    ? block.function.name
+                    : undefined);
+            const name = normalizeFunctionName(rawName);
+            const args = block.arguments ?? block?.function?.arguments ?? {};
+            const parsedArgs = args;
+            const callIdCandidate = (typeof block.id === 'string' && block.id.trim().length ? block.id.trim() : undefined) ??
+                (typeof block.call_id === 'string' && block.call_id.trim().length ? block.call_id.trim() : undefined);
+            const callId = callIdCandidate ??
+                normalizeFunctionCallId({
+                    callId: callIdCandidate,
+                    fallback: `fc_call_${toolCalls.length + 1}`
+                });
+            if (typeof name !== 'string' || !name.trim()) {
+                currentLastCall = null;
+                continue;
+            }
+            const serialized = serializeToolArguments(parsedArgs, name, tools).trim();
+            toolNameById.set(callId, name);
+            toolCalls.push({ id: callId, type: 'function', function: { name, arguments: serialized } });
+            currentLastCall = callId;
+            continue;
+        }
+        if (type === 'function_call_output' || type === 'tool_result' || type === 'tool_message') {
+            let toolCallId = block.tool_call_id ||
+                block.call_id ||
+                block.tool_use_id ||
+                block.id ||
+                currentLastCall;
+            toolCallId = typeof toolCallId === 'string' && toolCallId.trim().length ? toolCallId.trim() : currentLastCall;
+            const output = serializeToolOutput(block);
+            if (toolCallId) {
+                try {
+                    let contentStr = output != null ? String(output) : '';
+                    if (!contentStr || contentStr.trim().length === 0) {
+                        contentStr = toolResultFallbackText;
+                    }
+                    const nm = toolNameById.get(String(toolCallId));
+                    const toolMsg = { role: 'tool', tool_call_id: String(toolCallId), content: contentStr };
+                    if (typeof nm === 'string' && nm.trim().length)
+                        toolMsg.name = nm;
+                    toolMessages.push(toolMsg);
+                }
+                catch {
+                    const fallback = (output ?? toolResultFallbackText);
+                    const nm = toolNameById.get(String(toolCallId));
+                    const toolMsg = { role: 'tool', tool_call_id: String(toolCallId), content: String(fallback) };
+                    if (typeof nm === 'string' && nm.trim().length)
+                        toolMsg.name = nm;
+                    toolMessages.push(toolMsg);
+                }
+                currentLastCall = null;
+            }
+            continue;
+        }
+    }
+    const text = textParts.length ? textParts.join('\n').trim() : null;
+    return { text, toolCalls, toolMessages, lastCallId: currentLastCall, reasoningSegments };
+}
+export function convertBridgeInputToChatMessages(options) {
+    const { input, tools, normalizeFunctionName, toolResultFallbackText } = options;
+    const messages = [];
+    if (!Array.isArray(input))
+        return messages;
+    const toolNameById = new Map();
+    let lastToolCallId = null;
+    const resolveFunctionName = normalizeFunctionName ?? defaultNormalizeFunctionName;
+    const fallbackText = toolResultFallbackText ?? 'Command succeeded (no output).';
+    for (let entryIndex = 0; entryIndex < input.length; entryIndex++) {
+        const entry = input[entryIndex];
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const entryType = typeof entry.type === 'string' ? entry.type.toLowerCase() : 'message';
+        const entryReasoningSegments = toReasoningSegments(entry.reasoning_content);
+        let entryReasoningConsumed = false;
+        const consumeEntryReasoning = () => {
+            if (entryReasoningConsumed || !entryReasoningSegments.length) {
+                return undefined;
+            }
+            entryReasoningConsumed = true;
+            return entryReasoningSegments;
+        };
+        if (typeof entry.content === 'string') {
+            const normalizedRole = coerceBridgeRole(entry.role || 'user');
+            const directText = (entry.content || '').toString();
+            pushNormalizedChatMessage(messages, normalizedRole, directText, {
+                reasoningSegments: consumeEntryReasoning()
+            });
+            continue;
+        }
+        if (entryType === 'function_call' || entryType === 'tool_call') {
+            const rawName = typeof entry.name === 'string'
+                ? entry.name
+                : (typeof entry?.function?.name === 'string' ? entry.function.name : undefined);
+            const name = resolveFunctionName(rawName);
+            if (typeof name !== 'string' || !name.trim()) {
+                continue;
+            }
+            const args = entry.arguments ?? entry?.function?.arguments ?? {};
+            const parsedArgs = args;
+            const callIdRaw = typeof entry.id === 'string' ? entry.id : (typeof entry.call_id === 'string' ? entry.call_id : undefined);
+            const callIdSource = typeof callIdRaw === 'string' && callIdRaw.trim().length ? callIdRaw.trim() : undefined;
+            let callId = callIdSource;
+            if (!callId) {
+                callId = normalizeFunctionCallId({
+                    callId: callIdSource,
+                    fallback: `fc_call_${messages.length + 1}`
+                });
+            }
+            const serialized = serializeToolArguments(parsedArgs, name, tools).trim();
+            toolNameById.set(callId, name);
+            messages.push({ role: 'assistant', tool_calls: [{ id: callId, type: 'function', function: { name, arguments: serialized } }] });
+            lastToolCallId = callId;
+            continue;
+        }
+        if (entryType === 'function_call_output' || entryType === 'tool_result' || entryType === 'tool_message') {
+            let toolCallId = entry.tool_call_id ||
+                entry.call_id ||
+                entry.tool_use_id ||
+                entry.id ||
+                lastToolCallId;
+            toolCallId = typeof toolCallId === 'string' && toolCallId.trim().length ? toolCallId.trim() : (lastToolCallId ?? undefined);
+            const output = serializeToolOutput(entry);
+            if (toolCallId) {
+                try {
+                    let contentStr = output != null ? String(output) : '';
+                    if (!contentStr || contentStr.trim().length === 0) {
+                        contentStr = fallbackText;
+                    }
+                    const nm = toolNameById.get(String(toolCallId));
+                    const toolMsg = { role: 'tool', tool_call_id: String(toolCallId), content: contentStr };
+                    if (typeof nm === 'string' && nm.trim().length)
+                        toolMsg.name = nm;
+                    messages.push(toolMsg);
+                }
+                catch {
+                    const fallback = (output ?? fallbackText);
+                    const nm = toolNameById.get(String(toolCallId));
+                    const toolMsg = { role: 'tool', tool_call_id: String(toolCallId), content: String(fallback) };
+                    if (typeof nm === 'string' && nm.trim().length)
+                        toolMsg.name = nm;
+                    messages.push(toolMsg);
+                }
+                lastToolCallId = null;
+            }
+            continue;
+        }
+        let handledViaExplicitMessage = false;
+        if (entry && typeof entry.message === 'object' && Array.isArray(entry.message?.content)) {
+            const explicit = entry.message;
+            const nested = processMessageBlocks(Array.isArray(explicit.content) ? explicit.content : [], resolveFunctionName, tools, toolNameById, lastToolCallId, fallbackText);
+            if (nested.toolCalls.length)
+                messages.push({ role: 'assistant', tool_calls: nested.toolCalls });
+            for (const msg of nested.toolMessages)
+                messages.push(msg);
+            const normalizedRole = coerceBridgeRole((explicit.role ?? entry.role) || 'user');
+            if (typeof nested.text === 'string') {
+                pushNormalizedChatMessage(messages, normalizedRole, nested.text, {
+                    reasoningSegments: combineReasoningSegments(consumeEntryReasoning(), nested.reasoningSegments)
+                });
+            }
+            lastToolCallId = nested.lastCallId;
+            handledViaExplicitMessage = true;
+        }
+        if (!handledViaExplicitMessage) {
+            const nested = processMessageBlocks(Array.isArray(entry.content) ? entry.content : [], resolveFunctionName, tools, toolNameById, lastToolCallId, fallbackText);
+            if (nested.toolCalls.length)
+                messages.push({ role: 'assistant', tool_calls: nested.toolCalls });
+            for (const msg of nested.toolMessages)
+                messages.push(msg);
+            const normalizedRole = coerceBridgeRole(entry.role || 'user');
+            if (typeof nested.text === 'string') {
+                pushNormalizedChatMessage(messages, normalizedRole, nested.text, {
+                    reasoningSegments: combineReasoningSegments(consumeEntryReasoning(), nested.reasoningSegments)
+                });
+            }
+            lastToolCallId = nested.lastCallId;
+        }
+        try {
+            const t = String(entry.type || '').toLowerCase();
+            if ((t === 'input_text' || t === 'text' || t === 'output_text' || t === 'commentary') &&
+                typeof entry.text === 'string') {
+                const normalizedRole = coerceBridgeRole(entry.role || 'user');
+                const s = entry.text;
+                if (s && s.length) {
+                    pushNormalizedChatMessage(messages, normalizedRole, s, {
+                        reasoningSegments: consumeEntryReasoning()
+                    });
+                }
+            }
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    return messages;
+}

package/dist/conversion/shared/bridge-metadata.d.ts

@@ -0,0 +1 @@
+export declare const BRIDGE_RAW_SYSTEM_METADATA_KEY = "__rcc_raw_system";

package/dist/conversion/shared/bridge-metadata.js

@@ -0,0 +1 @@
+export const BRIDGE_RAW_SYSTEM_METADATA_KEY = '__rcc_raw_system';

package/dist/conversion/shared/bridge-policies.d.ts

@@ -0,0 +1,18 @@
+import type { BridgeActionDescriptor, BridgeActionStage } from './bridge-actions.js';
+type PhaseConfig = {
+    inbound?: BridgeActionDescriptor[];
+    outbound?: BridgeActionDescriptor[];
+};
+export interface BridgePolicy {
+    id: string;
+    protocol?: string;
+    moduleType?: string;
+    request?: PhaseConfig;
+    response?: PhaseConfig;
+}
+export declare function resolveBridgePolicy(options: {
+    protocol?: string;
+    moduleType?: string;
+} | undefined): BridgePolicy | undefined;
+export declare function resolvePolicyActions(policy: BridgePolicy | undefined, stage: BridgeActionStage): BridgeActionDescriptor[] | undefined;
+export {};