@jsonstudio/llms 0.4.3 → 0.4.5

package/dist/conversion/shared/{responses-conversation-store.d.ts → bridge-conversation-store.d.ts}

@@ -1,5 +1,5 @@
-import type { ResponsesRequestContext } from './responses-request-adapter.js';
-declare class ResponsesConversationStore {
+import type { ResponsesRequestContext } from './bridge-request-adapter.js';
+declare class BridgeConversationStore {
     private requestMap;
     private responseIndex;
     captureRequestContext(args: {
@@ -21,21 +21,21 @@ declare class ResponsesConversationStore {
     private cleanupEntry;
     private prune;
 }
-export declare const responsesConversationStore: ResponsesConversationStore;
-export declare function captureResponsesRequestContext(args: {
+export declare const bridgeConversationStore: BridgeConversationStore;
+export declare function captureBridgeRequestContext(args: {
     requestId: string;
     payload: Record<string, unknown>;
     context: ResponsesRequestContext;
 }): void;
-export declare function recordResponsesResponse(args: {
+export declare function recordBridgeResponse(args: {
     requestId: string;
     response: Record<string, unknown>;
 }): void;
-export declare function resumeResponsesConversation(responseId: string, submitPayload: Record<string, unknown>, options?: {
+export declare function resumeBridgeConversation(responseId: string, submitPayload: Record<string, unknown>, options?: {
     requestId?: string;
 }): {
     payload: Record<string, unknown>;
     meta: Record<string, unknown>;
 };
-export declare function clearResponsesConversationByRequestId(requestId: string): void;
+export declare function clearBridgeConversationByRequestId(requestId: string): void;
 export {};

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

@@ -0,0 +1,279 @@
+const TTL_MS = 1000 * 60 * 30; // 30 minutes safety window
+function cloneDeep(value) {
+    try {
+        if (typeof globalThis.structuredClone === 'function') {
+            return globalThis.structuredClone(value);
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    return JSON.parse(JSON.stringify(value ?? null));
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+function coerceInputArray(input) {
+    if (!Array.isArray(input)) {
+        return [];
+    }
+    return cloneDeep(input);
+}
+function coerceTools(tools) {
+    if (!Array.isArray(tools)) {
+        return undefined;
+    }
+    return cloneDeep(tools);
+}
+function pickPersistedFields(payload) {
+    const fields = [
+        'model',
+        'instructions',
+        'metadata',
+        'include',
+        'store',
+        'tool_choice',
+        'parallel_tool_calls',
+        'response_format',
+        'temperature',
+        'top_p',
+        'max_output_tokens',
+        'max_tokens',
+        'stop',
+        'user',
+        'modal',
+        'truncation_strategy',
+        'previous_response_id',
+        'reasoning',
+        'attachments',
+        'input_audio',
+        'output_audio'
+    ];
+    const result = {};
+    for (const key of fields) {
+        if (payload[key] !== undefined) {
+            result[key] = cloneDeep(payload[key]);
+        }
+    }
+    return result;
+}
+function normalizeOutputItemToInput(item) {
+    const type = typeof item.type === 'string' ? item.type : '';
+    if (type === 'message' || type === 'reasoning') {
+        const role = typeof item.role === 'string' ? item.role : 'assistant';
+        const content = Array.isArray(item.content) ? cloneDeep(item.content) : (typeof item.text === 'string' ? [{ type: 'text', text: item.text }] : []);
+        return {
+            type: 'message',
+            role,
+            content,
+            message: { role, content }
+        };
+    }
+    if (type === 'function_call') {
+        const callId = typeof item.call_id === 'string' ? item.call_id : (typeof item.id === 'string' ? item.id : undefined);
+        return {
+            type: 'function_call',
+            role: 'assistant',
+            id: typeof item.id === 'string' ? item.id : undefined,
+            call_id: callId,
+            name: typeof item.name === 'string' ? item.name : undefined,
+            arguments: item.arguments,
+            function: isRecord(item.function)
+                ? cloneDeep(item.function)
+                : (typeof item.name === 'string'
+                    ? { name: item.name, arguments: item.arguments }
+                    : undefined)
+        };
+    }
+    return null;
+}
+function convertOutputToInputItems(response) {
+    const output = Array.isArray(response.output) ? response.output : [];
+    const items = [];
+    for (const entry of output) {
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const mapped = normalizeOutputItemToInput(entry);
+        if (mapped)
+            items.push(mapped);
+    }
+    return items;
+}
+function normalizeSubmittedToolOutputs(toolOutputs) {
+    const items = [];
+    const submitted = [];
+    toolOutputs.forEach((entry, index) => {
+        if (!entry || typeof entry !== 'object')
+            return;
+        const rec = entry;
+        const rawId = typeof rec.tool_call_id === 'string'
+            ? rec.tool_call_id
+            : typeof rec.call_id === 'string'
+                ? rec.call_id
+                : typeof rec.id === 'string'
+                    ? rec.id
+                    : undefined;
+        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
+            : (() => {
+                try {
+                    return JSON.stringify(outputValue ?? null);
+                }
+                catch {
+                    return String(outputValue ?? '');
+                }
+            })();
+        items.push({
+            type: 'function_call_output',
+            id: callId,
+            call_id: callId,
+            output: normalizedOutput
+        });
+        submitted.push({ callId, originalId: rawId ?? callId, outputText: normalizedOutput });
+    });
+    return { items, submitted };
+}
+class BridgeConversationStore {
+    requestMap = new Map();
+    responseIndex = new Map();
+    captureRequestContext(args) {
+        const { requestId, payload, context } = args;
+        if (!requestId || !payload)
+            return;
+        this.prune();
+        const entry = {
+            requestId,
+            basePayload: pickPersistedFields(payload),
+            input: coerceInputArray(context.input),
+            tools: coerceTools(context.toolsRaw || (Array.isArray(payload.tools) ? payload.tools : undefined)),
+            createdAt: Date.now(),
+            updatedAt: Date.now()
+        };
+        if (typeof payload.model === 'string' && payload.model.trim()) {
+            entry.basePayload.model = payload.model;
+        }
+        if (typeof payload.stream === 'boolean') {
+            entry.basePayload.stream = payload.stream;
+        }
+        if (entry.tools) {
+            entry.basePayload.tools = entry.tools;
+        }
+        this.requestMap.set(requestId, entry);
+    }
+    recordResponse(args) {
+        const entry = this.requestMap.get(args.requestId);
+        if (!entry)
+            return;
+        const response = args.response;
+        const responseId = typeof response.id === 'string' ? response.id : undefined;
+        if (!responseId)
+            return;
+        const assistantBlocks = convertOutputToInputItems(response);
+        if (assistantBlocks.length) {
+            entry.input.push(...assistantBlocks);
+        }
+        entry.lastResponseId = responseId;
+        entry.updatedAt = Date.now();
+        this.responseIndex.set(responseId, entry);
+    }
+    resumeConversation(responseId, submitPayload, options) {
+        if (typeof responseId !== 'string' || !responseId.trim()) {
+            throw new Error('Bridge conversation requires valid response_id');
+        }
+        this.prune();
+        const entry = this.responseIndex.get(responseId);
+        if (!entry) {
+            throw new Error('Bridge conversation expired or not found');
+        }
+        const toolOutputs = Array.isArray(submitPayload.tool_outputs)
+            ? submitPayload.tool_outputs
+            : [];
+        if (!toolOutputs.length) {
+            throw new Error('tool_outputs array is required when submitting tool results');
+        }
+        const mergedInput = coerceInputArray(entry.input);
+        const normalizedOutputs = normalizeSubmittedToolOutputs(toolOutputs);
+        mergedInput.push(...normalizedOutputs.items);
+        const payload = cloneDeep(entry.basePayload);
+        payload.input = mergedInput;
+        payload.stream = true;
+        payload.previous_response_id = responseId;
+        if (Array.isArray(entry.tools) && entry.tools.length) {
+            payload.tools = cloneDeep(entry.tools);
+        }
+        if (typeof submitPayload.model === 'string' && submitPayload.model.trim()) {
+            payload.model = submitPayload.model.trim();
+        }
+        if (submitPayload.metadata && isRecord(submitPayload.metadata)) {
+            payload.metadata = { ...payload.metadata, ...cloneDeep(submitPayload.metadata) };
+        }
+        delete payload.tool_outputs;
+        delete payload.response_id;
+        this.cleanupEntry(entry, responseId);
+        return {
+            payload,
+            meta: {
+                restoredFromResponseId: responseId,
+                previousRequestId: entry.requestId,
+                toolOutputs: toolOutputs.length,
+                toolOutputsDetailed: normalizedOutputs.submitted,
+                requestId: options?.requestId
+            }
+        };
+    }
+    clearRequest(requestId) {
+        const entry = this.requestMap.get(requestId);
+        if (!entry)
+            return;
+        this.requestMap.delete(requestId);
+        if (entry.lastResponseId) {
+            this.responseIndex.delete(entry.lastResponseId);
+        }
+    }
+    cleanupEntry(entry, responseId) {
+        this.responseIndex.delete(responseId);
+        this.requestMap.delete(entry.requestId);
+    }
+    prune() {
+        const now = Date.now();
+        for (const [requestId, entry] of this.requestMap.entries()) {
+            if (now - entry.updatedAt > TTL_MS) {
+                this.requestMap.delete(requestId);
+                if (entry.lastResponseId) {
+                    this.responseIndex.delete(entry.lastResponseId);
+                }
+            }
+        }
+        for (const [respId, entry] of this.responseIndex.entries()) {
+            if (!this.requestMap.has(entry.requestId)) {
+                this.responseIndex.delete(respId);
+            }
+        }
+    }
+}
+export const bridgeConversationStore = new BridgeConversationStore();
+export function captureBridgeRequestContext(args) {
+    try {
+        bridgeConversationStore.captureRequestContext(args);
+    }
+    catch {
+        /* ignore capture failures */
+    }
+}
+export function recordBridgeResponse(args) {
+    try {
+        bridgeConversationStore.recordResponse(args);
+    }
+    catch {
+        /* ignore */
+    }
+}
+export function resumeBridgeConversation(responseId, submitPayload, options) {
+    return bridgeConversationStore.resumeConversation(responseId, submitPayload, options);
+}
+export function clearBridgeConversationByRequestId(requestId) {
+    bridgeConversationStore.clearRequest(requestId);
+}

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

@@ -0,0 +1,42 @@
+function sanitizeCore(value) {
+    return value
+        .replace(/[^A-Za-z0-9_-]/g, '_')
+        .replace(/_{2,}/g, '_')
+        .replace(/^_+/, '')
+        .replace(/_+$/, '');
+}
+function stripPrefix(value) {
+    if (typeof value !== 'string')
+        return null;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return null;
+    let sanitized = sanitizeCore(trimmed);
+    if (!sanitized)
+        return null;
+    if (/^fc[_-]/i.test(sanitized)) {
+        sanitized = sanitized.replace(/^fc[_-]?/i, '');
+    }
+    else if (/^call[_-]/i.test(sanitized)) {
+        sanitized = sanitized.replace(/^call[_-]?/i, '');
+    }
+    if (!sanitized) {
+        sanitized = Math.random().toString(36).slice(2, 10);
+    }
+    return `fc_${sanitized}`;
+}
+function normalizeWithFallback(options) {
+    const normalized = stripPrefix(options.callId);
+    if (normalized)
+        return normalized;
+    const fallbackNormalized = stripPrefix(options.fallback);
+    if (fallbackNormalized)
+        return fallbackNormalized;
+    return `fc_${Math.random().toString(36).slice(2, 10)}`;
+}
+export function normalizeFunctionCallId(options) {
+    return normalizeWithFallback(options);
+}
+export function normalizeFunctionCallOutputId(options) {
+    return normalizeWithFallback(options);
+}

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

@@ -0,0 +1 @@
+export declare function ensureBridgeInstructions(payload: Record<string, unknown>): string | undefined;

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

@@ -0,0 +1,113 @@
+function collectTextFromBlocks(blocks) {
+    const parts = [];
+    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') && typeof block.text === 'string') {
+            const text = block.text.trim();
+            if (text)
+                parts.push(text);
+            continue;
+        }
+        if (type === 'message' && Array.isArray(block.content)) {
+            const nested = collectTextFromBlocks(block.content);
+            if (nested)
+                parts.push(nested);
+            continue;
+        }
+        if (typeof block.content === 'string') {
+            const text = block.content.trim();
+            if (text)
+                parts.push(text);
+            continue;
+        }
+        if (Array.isArray(block.content)) {
+            const nested = collectTextFromBlocks(block.content);
+            if (nested)
+                parts.push(nested);
+            continue;
+        }
+        if (typeof block.text === 'string') {
+            const text = block.text.trim();
+            if (text)
+                parts.push(text);
+        }
+    }
+    return parts.join('\n');
+}
+function extractSystemInstruction(entry) {
+    if (!entry || typeof entry !== 'object')
+        return null;
+    const roleSource = entry.role ?? entry.message?.role;
+    const role = typeof roleSource === 'string' ? roleSource.toLowerCase() : '';
+    if (role !== 'system')
+        return null;
+    const collected = [];
+    if (Array.isArray(entry.content)) {
+        const text = collectTextFromBlocks(entry.content);
+        if (text.trim())
+            collected.push(text.trim());
+    }
+    else if (typeof entry.content === 'string') {
+        const text = entry.content.trim();
+        if (text)
+            collected.push(text);
+    }
+    if (typeof entry.text === 'string') {
+        const text = entry.text.trim();
+        if (text)
+            collected.push(text);
+    }
+    const message = entry.message;
+    if (message && typeof message === 'object') {
+        if (Array.isArray(message.content)) {
+            const text = collectTextFromBlocks(message.content);
+            if (text.trim())
+                collected.push(text.trim());
+        }
+        else if (typeof message.content === 'string') {
+            const text = message.content.trim();
+            if (text)
+                collected.push(text);
+        }
+        if (typeof message.text === 'string') {
+            const text = String(message.text).trim();
+            if (text)
+                collected.push(text);
+        }
+    }
+    const merged = collected.join('\n').trim();
+    return merged ? merged : null;
+}
+export function ensureBridgeInstructions(payload) {
+    let instructions = typeof payload.instructions === 'string' ? payload.instructions : '';
+    const hasClientInstruction = typeof payload.instructions === 'string' && payload.instructions.length > 0;
+    const input = Array.isArray(payload.input) ? payload.input : undefined;
+    if (input && input.length) {
+        for (let i = 0; i < input.length; i += 1) {
+            const entry = input[i];
+            const roleSource = entry?.role ?? entry?.message?.role;
+            const role = typeof roleSource === 'string' ? roleSource.toLowerCase() : '';
+            if (role === 'system') {
+                const text = extractSystemInstruction(entry);
+                input.splice(i, 1);
+                i -= 1;
+                if (text && text.trim()) {
+                    if (!hasClientInstruction && !instructions) {
+                        instructions = text.trim();
+                    }
+                }
+                continue;
+            }
+        }
+    }
+    if (instructions) {
+        payload.instructions = instructions;
+        return instructions;
+    }
+    if (typeof payload.instructions !== 'undefined') {
+        delete payload.instructions;
+    }
+    return undefined;
+}

package/dist/conversion/shared/bridge-message-types.d.ts

@@ -0,0 +1,39 @@
+export type BridgeContentPart = {
+    type: string;
+    text?: string;
+    content?: unknown;
+};
+export type BridgeInputItem = {
+    type: string;
+    role?: string;
+    content?: Array<BridgeContentPart> | null;
+    name?: string;
+    arguments?: unknown;
+    call_id?: string;
+    output?: unknown;
+    function?: {
+        name?: string;
+        arguments?: unknown;
+    };
+    message?: {
+        role?: string;
+        content?: Array<BridgeContentPart>;
+    };
+    id?: string;
+    tool_call_id?: string;
+    tool_use_id?: string;
+    text?: string;
+};
+export type BridgeToolDefinition = {
+    type: string;
+    name?: string;
+    description?: string;
+    strict?: boolean;
+    parameters?: unknown;
+    function?: {
+        name?: string;
+        description?: string;
+        strict?: boolean;
+        parameters?: unknown;
+    };
+};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,22 @@
+import type { BridgeInputItem } from './bridge-message-types.js';
+export declare function coerceBridgeRole(role: unknown): string;
+export declare function serializeToolArguments(argsStringOrObj: unknown, _functionName: string | undefined, _tools: unknown): string;
+export declare function serializeToolOutput(entry: BridgeInputItem): string | null;
+export interface BridgeInputBuildOptions {
+    messages: Array<Record<string, unknown>>;
+    tools?: Array<Record<string, unknown>> | undefined;
+}
+export interface BridgeInputBuildResult {
+    input: BridgeInputItem[];
+    combinedSystemInstruction?: string;
+    latestUserInstruction?: string;
+    originalSystemMessages: string[];
+}
+export declare function convertMessagesToBridgeInput(options: BridgeInputBuildOptions): BridgeInputBuildResult;
+export interface BridgeInputToChatOptions {
+    input?: BridgeInputItem[];
+    tools?: Array<Record<string, unknown>>;
+    normalizeFunctionName?: (raw: unknown) => string | undefined;
+    toolResultFallbackText?: string;
+}
+export declare function convertBridgeInputToChatMessages(options: BridgeInputToChatOptions): Array<Record<string, unknown>>;