@jsonstudio/llms 0.4.4 → 0.4.6

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

@@ -0,0 +1,709 @@
+import { normalizeMessageReasoningTools } from './reasoning-tool-normalizer.js';
+import { extractReasoningSegments } from './reasoning-utils.js';
+import { extractOutputSegments } from './output-content-normalizer.js';
+import { normalizeChatMessageContent } from './chat-output-normalizer.js';
+import { convertMessagesToBridgeInput } from './bridge-message-utils.js';
+const registry = new Map();
+export function registerBridgeAction(name, action) {
+    registry.set(name, action);
+}
+export function createBridgeActionState(seed) {
+    const state = {
+        messages: Array.isArray(seed?.messages) ? seed.messages : []
+    };
+    if (seed?.requiredAction)
+        state.requiredAction = seed.requiredAction;
+    if (seed?.capturedToolResults)
+        state.capturedToolResults = seed.capturedToolResults;
+    if (seed?.rawRequest)
+        state.rawRequest = seed.rawRequest;
+    if (seed?.rawResponse)
+        state.rawResponse = seed.rawResponse;
+    if (seed?.metadata)
+        state.metadata = seed.metadata;
+    return state;
+}
+export function runBridgeActionPipeline(options) {
+    const { stage, actions, protocol, moduleType, requestId, state } = options;
+    if (!actions?.length)
+        return;
+    for (const descriptor of actions) {
+        if (!descriptor || typeof descriptor !== 'object')
+            continue;
+        const action = registry.get(descriptor.name);
+        if (!action)
+            continue;
+        try {
+            action({
+                stage,
+                protocol,
+                moduleType,
+                requestId,
+                descriptor,
+                state
+            });
+        }
+        catch {
+            // Ignore action failures to preserve core flow; telemetry hooks can be added later.
+        }
+    }
+}
+function ensureMessagesArray(state) {
+    if (!Array.isArray(state.messages)) {
+        state.messages = [];
+    }
+    return state.messages;
+}
+function flattenContentToString(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        const parts = value
+            .map((entry) => flattenContentToString(entry))
+            .filter((entry) => typeof entry === 'string' && entry.length > 0);
+        if (parts.length) {
+            return parts.join('\n');
+        }
+        return '';
+    }
+    if (value && 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)) {
+            return flattenContentToString(record.content);
+        }
+    }
+    return undefined;
+}
+function ensureMetadataRecord(state) {
+    if (!state.metadata || typeof state.metadata !== 'object') {
+        state.metadata = {};
+    }
+    return state.metadata;
+}
+const injectSystemInstructionAction = (ctx) => {
+    if (ctx.stage !== 'request_inbound')
+        return;
+    const raw = ctx.state.rawRequest;
+    if (!raw || typeof raw !== 'object')
+        return;
+    const field = typeof ctx.descriptor.options?.field === 'string' ? ctx.descriptor.options.field : 'instructions';
+    const reasoningField = typeof ctx.descriptor.options?.reasoningField === 'string' ? ctx.descriptor.options.reasoningField : undefined;
+    const instructions = readInstructionValue(raw, field);
+    if (!instructions)
+        return;
+    const reasoningSegments = readInstructionReasoning(raw, reasoningField);
+    const message = buildInstructionMessage('system', instructions, reasoningSegments);
+    if (!message)
+        return;
+    const messages = ensureMessagesArray(ctx.state);
+    messages.unshift(message);
+};
+function readInstructionValue(source, field) {
+    if (!source || typeof source !== 'object')
+        return undefined;
+    const raw = source[field];
+    if (typeof raw !== 'string')
+        return undefined;
+    const trimmed = raw.trim();
+    return trimmed.length ? trimmed : undefined;
+}
+function readInstructionReasoning(source, field) {
+    if (!field || !source || typeof source !== 'object')
+        return [];
+    const raw = source[field];
+    if (!raw)
+        return [];
+    if (typeof raw === 'string') {
+        const trimmed = raw.trim();
+        return trimmed.length ? [trimmed] : [];
+    }
+    if (Array.isArray(raw)) {
+        return raw
+            .map((entry) => (typeof entry === 'string' ? entry.trim() : ''))
+            .filter((entry) => entry.length > 0);
+    }
+    return [];
+}
+function buildInstructionMessage(role, text, reasoningSegments) {
+    const normalized = normalizeChatMessageContent(text);
+    const content = typeof normalized.contentText === 'string' ? normalized.contentText : '';
+    const merged = [];
+    if (typeof normalized.reasoningText === 'string' && normalized.reasoningText.trim().length) {
+        merged.push(normalized.reasoningText.trim());
+    }
+    for (const segment of reasoningSegments) {
+        if (typeof segment === 'string' && segment.trim().length) {
+            merged.push(segment.trim());
+        }
+    }
+    if (!content.trim().length && !merged.length) {
+        return null;
+    }
+    const message = { role, content };
+    if (merged.length) {
+        message.reasoning_content = merged.join('\n');
+    }
+    return message;
+}
+function mapToolResults(state) {
+    const toolResults = new Map();
+    const append = (id, output, name) => {
+        if (typeof id !== 'string' || !id.trim()) {
+            return;
+        }
+        let text = '';
+        if (typeof output === 'string') {
+            text = output;
+        }
+        else if (output != null) {
+            try {
+                text = JSON.stringify(output);
+            }
+            catch {
+                text = String(output);
+            }
+        }
+        const trimmed = text.trim();
+        toolResults.set(id, trimmed);
+        if (typeof name === 'string' && name.trim().length) {
+            toolResults.set(`${id}::name`, name.trim());
+        }
+    };
+    const captured = state.capturedToolResults;
+    if (Array.isArray(captured)) {
+        for (const entry of captured) {
+            append(entry?.tool_call_id ?? entry?.call_id, entry?.output, entry?.name);
+        }
+    }
+    return toolResults;
+}
+function hasToolResponse(messages, startIndex, callId) {
+    for (let i = startIndex; i < messages.length; i++) {
+        const msg = messages[i];
+        if (!msg || typeof msg !== 'object')
+            continue;
+        const role = String(msg.role || '').toLowerCase();
+        if (role !== 'tool')
+            continue;
+        const id = msg.tool_call_id ||
+            msg.call_id ||
+            msg.tool_use_id;
+        if (typeof id === 'string' && id.trim() === callId) {
+            return true;
+        }
+    }
+    return false;
+}
+function normalizeToolName(value) {
+    if (typeof value === 'string' && value.trim().length) {
+        return value.trim();
+    }
+    return undefined;
+}
+const ensureToolResponsePlaceholders = (ctx) => {
+    const messages = ensureMessagesArray(ctx.state);
+    if (!messages.length)
+        return;
+    const inserts = [];
+    const toolResults = mapToolResults(ctx.state);
+    for (let i = 0; i < messages.length; i++) {
+        const message = messages[i];
+        if (!message || typeof message !== 'object')
+            continue;
+        const role = String(message.role || '').toLowerCase();
+        if (role !== 'assistant')
+            continue;
+        const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : undefined;
+        if (!toolCalls?.length)
+            continue;
+        for (const call of toolCalls) {
+            if (!call || typeof call !== 'object')
+                continue;
+            const callId = call.id ||
+                call.call_id ||
+                call.tool_call_id;
+            if (typeof callId !== 'string' || !callId.trim())
+                continue;
+            if (hasToolResponse(messages, i + 1, callId))
+                continue;
+            const content = toolResults.get(callId) ?? '';
+            const inferredName = toolResults.get(`${callId}::name`) ||
+                normalizeToolName(call.name) ||
+                normalizeToolName(call?.function?.name);
+            const toolMessage = {
+                role: 'tool',
+                tool_call_id: callId,
+                content
+            };
+            if (inferredName) {
+                toolMessage.name = inferredName;
+            }
+            inserts.push({ index: i + 1, message: toolMessage });
+        }
+    }
+    if (!inserts.length)
+        return;
+    let offset = 0;
+    for (const entry of inserts) {
+        const targetIndex = Math.min(messages.length, entry.index + offset);
+        messages.splice(targetIndex, 0, entry.message);
+        offset++;
+    }
+};
+function assignReasoning(message, parts) {
+    const trimmed = parts.map((item) => item.trim()).filter(Boolean);
+    if (!trimmed.length)
+        return;
+    const existing = typeof message.reasoning_content === 'string' && message.reasoning_content.trim().length
+        ? [message.reasoning_content.trim()]
+        : [];
+    const merged = [...existing, ...trimmed].filter(Boolean);
+    if (merged.length) {
+        message.reasoning_content = merged.join('\n').trim();
+    }
+}
+function processTextValue(value, collector, dropFromContent) {
+    try {
+        const sanitized = extractReasoningSegments(value, collector);
+        return dropFromContent ? sanitized : value;
+    }
+    catch {
+        return value;
+    }
+}
+function stripReasoningFromValue(value, collector, dropFromContent) {
+    if (typeof value === 'string') {
+        return processTextValue(value, collector, dropFromContent);
+    }
+    if (Array.isArray(value)) {
+        for (let i = 0; i < value.length; i++) {
+            value[i] = stripReasoningFromValue(value[i], collector, dropFromContent);
+        }
+        return value;
+    }
+    if (value && typeof value === 'object') {
+        const record = value;
+        if (typeof record.text === 'string') {
+            record.text = processTextValue(record.text, collector, dropFromContent);
+        }
+        if (typeof record.content === 'string') {
+            record.content = processTextValue(record.content, collector, dropFromContent);
+        }
+        else if (Array.isArray(record.content)) {
+            record.content = record.content.map((part) => stripReasoningFromValue(part, collector, dropFromContent));
+        }
+        return value;
+    }
+    return value;
+}
+const extractReasoningAction = (ctx) => {
+    const messages = ensureMessagesArray(ctx.state);
+    if (!messages.length)
+        return;
+    const dropFromContent = ctx.descriptor.options?.dropFromContent !== false;
+    const idPrefixBase = typeof ctx.descriptor.options?.idPrefix === 'string' && ctx.descriptor.options.idPrefix.trim().length
+        ? ctx.descriptor.options.idPrefix.trim()
+        : `${ctx.protocol ?? 'bridge'}_${ctx.stage}`;
+    for (let i = 0; i < messages.length; i++) {
+        const message = messages[i];
+        if (!message || typeof message !== 'object')
+            continue;
+        const reasoningParts = [];
+        if (typeof message.content === 'string') {
+            message.content = processTextValue(message.content, reasoningParts, dropFromContent);
+        }
+        else if (Array.isArray(message.content)) {
+            message.content = message.content.map((part) => stripReasoningFromValue(part, reasoningParts, dropFromContent));
+        }
+        assignReasoning(message, reasoningParts);
+        try {
+            normalizeMessageReasoningTools(message, {
+                idPrefix: `${idPrefixBase}_${i + 1}`
+            });
+        }
+        catch {
+            // best-effort normalization; ignore failures
+        }
+    }
+};
+registerBridgeAction('messages.inject-system-instruction', injectSystemInstructionAction);
+registerBridgeAction('reasoning.extract', extractReasoningAction);
+registerBridgeAction('tools.ensure-response-placeholders', ensureToolResponsePlaceholders);
+const ensureSystemInstructionAction = (ctx) => {
+    const messages = ensureMessagesArray(ctx.state);
+    if (!messages.length) {
+        return;
+    }
+    if (ctx.stage === 'request_outbound') {
+        const originals = [];
+        for (const message of messages) {
+            if (!message || typeof message !== 'object')
+                continue;
+            const role = String(message.role || '').toLowerCase();
+            if (role !== 'system')
+                continue;
+            const text = flattenContentToString(message.content);
+            if (typeof text === 'string' && text.trim().length) {
+                originals.push(text.trim());
+            }
+        }
+        if (!originals.length) {
+            return;
+        }
+        const metadata = ensureMetadataRecord(ctx.state);
+        metadata.systemInstruction = originals.join('\n\n');
+        metadata.originalSystemMessages = originals.slice();
+        return;
+    }
+    if (ctx.stage === 'request_inbound') {
+        const metadata = ctx.state.metadata;
+        const systemInstruction = typeof metadata?.systemInstruction === 'string' && metadata.systemInstruction.trim().length
+            ? metadata.systemInstruction.trim()
+            : undefined;
+        if (!systemInstruction) {
+            return;
+        }
+        const hasSystem = messages.some((message) => {
+            if (!message || typeof message !== 'object')
+                return false;
+            return String(message.role || '').toLowerCase() === 'system';
+        });
+        if (hasSystem) {
+            return;
+        }
+        messages.unshift({
+            role: 'system',
+            content: systemInstruction
+        });
+    }
+};
+const normalizeHistoryAction = (ctx) => {
+    if (ctx.stage !== 'request_outbound') {
+        return;
+    }
+    const messages = ensureMessagesArray(ctx.state);
+    if (!messages.length) {
+        return;
+    }
+    const toolsNode = ctx.state.rawRequest &&
+        typeof ctx.state.rawRequest === 'object' &&
+        Array.isArray(ctx.state.rawRequest.tools)
+        ? ctx.state.rawRequest.tools
+        : undefined;
+    try {
+        const result = convertMessagesToBridgeInput({
+            messages,
+            tools: toolsNode
+        });
+        const metadata = ensureMetadataRecord(ctx.state);
+        metadata.bridgeHistory = result;
+    }
+    catch {
+        // normalization best-effort
+    }
+};
+const ensureOutputFieldsAction = (ctx) => {
+    if (ctx.stage !== 'request_outbound') {
+        return;
+    }
+    const messages = ensureMessagesArray(ctx.state);
+    if (!messages.length) {
+        return;
+    }
+    const fallback = typeof ctx.descriptor.options?.toolFallback === 'string' && ctx.descriptor.options.toolFallback.trim().length
+        ? ctx.descriptor.options.toolFallback.trim()
+        : 'Tool call completed (no output).';
+    for (const message of messages) {
+        if (!message || typeof message !== 'object') {
+            continue;
+        }
+        const role = String(message.role || '').toLowerCase();
+        if (role === 'tool') {
+            let text = flattenContentToString(message.content);
+            if (text === undefined) {
+                text = fallback;
+            }
+            message.content = text;
+            continue;
+        }
+        if (role === 'assistant') {
+            const text = flattenContentToString(message.content);
+            if (text === undefined) {
+                message.content = '';
+            }
+            else if (typeof message.content !== 'string') {
+                message.content = text;
+            }
+        }
+    }
+};
+const ensureToolPlaceholdersAction = (ctx) => {
+    ensureToolResponsePlaceholders(ctx);
+};
+const captureToolResultsAction = (ctx) => {
+    const source = ctx.stage.startsWith('request') ? ctx.state.rawRequest :
+        ctx.stage.startsWith('response') ? ctx.state.rawResponse :
+            undefined;
+    if ((!Array.isArray(ctx.state.capturedToolResults) || ctx.state.capturedToolResults.length === 0) &&
+        source &&
+        typeof source === 'object' &&
+        Array.isArray(source.tool_outputs)) {
+        ctx.state.capturedToolResults = source.tool_outputs.map((entry) => ({
+            tool_call_id: typeof entry?.tool_call_id === 'string' ? entry.tool_call_id : undefined,
+            call_id: typeof entry?.call_id === 'string' ? entry.call_id : undefined,
+            output: entry?.output,
+            name: typeof entry?.name === 'string' ? entry.name : undefined
+        }));
+    }
+    if (ctx.stage === 'request_outbound' &&
+        Array.isArray(ctx.state.capturedToolResults) &&
+        ctx.state.capturedToolResults.length) {
+        const metadata = ensureMetadataRecord(ctx.state);
+        metadata.capturedToolResults = ctx.state.capturedToolResults.map((entry) => ({ ...entry }));
+    }
+};
+const attachReasoningOutputAction = (ctx) => {
+    responsesOutputReasoningAction(ctx);
+};
+registerBridgeAction('messages.ensure-system-instruction', ensureSystemInstructionAction);
+registerBridgeAction('messages.normalize-history', normalizeHistoryAction);
+registerBridgeAction('messages.ensure-output-fields', ensureOutputFieldsAction);
+registerBridgeAction('tools.ensure-placeholders', ensureToolPlaceholdersAction);
+registerBridgeAction('tools.capture-results', captureToolResultsAction);
+registerBridgeAction('reasoning.attach-output', attachReasoningOutputAction);
+const responsesOutputReasoningAction = (ctx) => {
+    if (ctx.stage !== 'response_inbound')
+        return;
+    const raw = ctx.state.rawResponse;
+    if (!raw || typeof raw !== 'object')
+        return;
+    const { textParts, reasoningParts } = extractOutputSegments(raw);
+    if (!textParts.length && !reasoningParts.length)
+        return;
+    const messages = ensureMessagesArray(ctx.state);
+    if (!messages.length) {
+        messages.push({
+            role: 'assistant',
+            content: textParts.join('\n')
+        });
+    }
+    const target = messages.find((message) => {
+        if (!message || typeof message !== 'object')
+            return false;
+        const role = String(message.role || '').toLowerCase();
+        return role === 'assistant';
+    }) ?? messages[0];
+    if (!target || typeof target !== 'object')
+        return;
+    if (textParts.length) {
+        const combinedText = textParts.join('\n');
+        const existing = target.content;
+        if (typeof existing !== 'string' || !existing.trim().length) {
+            target.content = combinedText;
+        }
+    }
+    if (reasoningParts.length) {
+        assignReasoning(target, reasoningParts);
+    }
+    try {
+        normalizeMessageReasoningTools(target, {
+            idPrefix: `${ctx.protocol ?? 'responses'}_${ctx.stage}_output`
+        });
+    }
+    catch {
+        // best-effort normalization
+    }
+};
+registerBridgeAction('responses.output-reasoning', responsesOutputReasoningAction);
+function collectExtraFieldsMap(source, allowed) {
+    const extras = {};
+    for (const [key, value] of Object.entries(source)) {
+        if (allowed && allowed.has(key))
+            continue;
+        extras[key] = value;
+    }
+    if (Object.keys(extras).length === 0) {
+        return undefined;
+    }
+    return extras;
+}
+const metadataExtraFieldsAction = (ctx) => {
+    const allowedKeysRaw = ctx.descriptor.options?.allowedKeys;
+    const allowed = Array.isArray(allowedKeysRaw)
+        ? new Set(allowedKeysRaw
+            .map((key) => (typeof key === 'string' ? key : undefined))
+            .filter((key) => !!key))
+        : undefined;
+    const target = ctx.stage.startsWith('request') ? ctx.state.rawRequest : ctx.state.rawResponse;
+    if (!target || typeof target !== 'object')
+        return;
+    if (ctx.stage.endsWith('inbound')) {
+        const extras = collectExtraFieldsMap(target, allowed);
+        if (!extras)
+            return;
+        const metadata = ensureMetadataRecord(ctx.state);
+        const existing = metadata.extraFields && typeof metadata.extraFields === 'object'
+            ? metadata.extraFields
+            : undefined;
+        metadata.extraFields = existing ? { ...existing, ...extras } : extras;
+        return;
+    }
+    const metadata = ctx.state.metadata;
+    if (!metadata || typeof metadata !== 'object')
+        return;
+    const extras = metadata.extraFields;
+    if (!extras || typeof extras !== 'object')
+        return;
+    const source = extras;
+    for (const [key, value] of Object.entries(source)) {
+        if (target[key] === undefined) {
+            target[key] = value;
+        }
+    }
+};
+const metadataProviderFieldAction = (ctx) => {
+    const field = typeof ctx.descriptor.options?.field === 'string' ? ctx.descriptor.options.field : 'metadata';
+    const targetKey = typeof ctx.descriptor.options?.target === 'string' ? ctx.descriptor.options.target : 'providerMetadata';
+    const payload = ctx.stage.startsWith('request') ? ctx.state.rawRequest :
+        ctx.stage.startsWith('response') ? ctx.state.rawResponse :
+            undefined;
+    if (!payload || typeof payload !== 'object')
+        return;
+    if (ctx.stage.endsWith('inbound')) {
+        const value = payload[field];
+        if (!value || typeof value !== 'object')
+            return;
+        const metadata = ensureMetadataRecord(ctx.state);
+        metadata[targetKey] = value;
+        return;
+    }
+    const metadata = ctx.state.metadata;
+    if (!metadata || typeof metadata !== 'object')
+        return;
+    const provider = metadata[targetKey];
+    if (!provider || typeof provider !== 'object')
+        return;
+    if (payload[field] === undefined) {
+        payload[field] = provider;
+    }
+};
+const metadataProviderSentinelAction = (ctx) => {
+    const sentinel = typeof ctx.descriptor.options?.sentinel === 'string'
+        ? ctx.descriptor.options.sentinel
+        : undefined;
+    if (!sentinel)
+        return;
+    const targetKey = typeof ctx.descriptor.options?.target === 'string'
+        ? ctx.descriptor.options.target
+        : 'providerMetadata';
+    const payload = ctx.stage.startsWith('request') ? ctx.state.rawRequest :
+        ctx.stage.startsWith('response') ? ctx.state.rawResponse :
+            undefined;
+    if (!payload || typeof payload !== 'object')
+        return;
+    if (ctx.stage.endsWith('inbound')) {
+        const rawValue = payload[sentinel];
+        if (rawValue === undefined)
+            return;
+        let provider;
+        if (typeof rawValue === 'string') {
+            try {
+                const parsed = JSON.parse(rawValue);
+                if (parsed && typeof parsed === 'object')
+                    provider = parsed;
+            }
+            catch {
+                provider = undefined;
+            }
+        }
+        else if (rawValue && typeof rawValue === 'object') {
+            provider = rawValue;
+        }
+        delete payload[sentinel];
+        if (!provider)
+            return;
+        const metadata = ensureMetadataRecord(ctx.state);
+        metadata[targetKey] = provider;
+        return;
+    }
+    const metadata = ctx.state.metadata;
+    if (!metadata || typeof metadata !== 'object') {
+        delete payload[sentinel];
+        return;
+    }
+    const provider = metadata[targetKey];
+    if (!provider || typeof provider !== 'object') {
+        delete payload[sentinel];
+        return;
+    }
+    try {
+        payload[sentinel] = JSON.stringify(provider);
+    }
+    catch {
+        payload[sentinel] = provider;
+    }
+};
+registerBridgeAction('metadata.provider-field', metadataProviderFieldAction);
+registerBridgeAction('metadata.provider-sentinel', metadataProviderSentinelAction);
+const metadataSystemSentinelAction = (ctx) => {
+    const sentinel = typeof ctx.descriptor.options?.sentinel === 'string'
+        ? ctx.descriptor.options.sentinel
+        : undefined;
+    const targetKey = typeof ctx.descriptor.options?.target === 'string'
+        ? ctx.descriptor.options.target
+        : 'rawSystem';
+    const stringifyOutbound = ctx.descriptor.options?.stringify !== false;
+    if (!sentinel)
+        return;
+    const payload = ctx.stage.startsWith('request') ? ctx.state.rawRequest :
+        ctx.stage.startsWith('response') ? ctx.state.rawResponse :
+            undefined;
+    if (!payload || typeof payload !== 'object')
+        return;
+    if (ctx.stage.endsWith('inbound')) {
+        const rawValue = payload[sentinel];
+        if (rawValue === undefined)
+            return;
+        let parsed = rawValue;
+        if (typeof rawValue === 'string') {
+            try {
+                parsed = JSON.parse(rawValue);
+            }
+            catch {
+                parsed = rawValue;
+            }
+        }
+        delete payload[sentinel];
+        const metadata = ensureMetadataRecord(ctx.state);
+        metadata[targetKey] = parsed;
+        return;
+    }
+    const metadata = ctx.state.metadata;
+    if (!metadata || typeof metadata !== 'object') {
+        delete payload[sentinel];
+        return;
+    }
+    const value = metadata[targetKey];
+    if (value === undefined) {
+        delete payload[sentinel];
+        return;
+    }
+    if (stringifyOutbound) {
+        try {
+            payload[sentinel] = JSON.stringify(value);
+        }
+        catch {
+            payload[sentinel] = value;
+        }
+        return;
+    }
+    payload[sentinel] = value;
+};
+registerBridgeAction('metadata.system-sentinel', metadataSystemSentinelAction);