@jsonstudio/llms 0.4.2

package/dist/conversion/shared/payload-budget.js

@@ -0,0 +1,248 @@
+// Resolve payload budget (bytes) for a given model from host app config, with safety headroom.
+// Search order:
+//  1) env ROUTECODEX_CONTEXT_BUDGET_BYTES (direct override)
+//  2) config/merged-config*.json (most recent) -> virtualrouter.providers.*.models[model].maxContext
+//  3) config/config.json -> virtualrouter.providers.*.models[model].maxContext
+//  4) default 200_000 bytes
+// Safety headroom: 10% (env RCC_CONTEXT_BUDGET_SAFETY to override; default 0.1)
+import { UnifiedConfig } from '../../config-unified/unified-config.js';
+function isObject(v) { return !!v && typeof v === 'object' && !Array.isArray(v); }
+function listMergedConfigsSync(configDir) {
+    try {
+        const fs = require('fs');
+        const path = require('path');
+        const ents = fs.readdirSync(configDir);
+        const files = ents.filter((n) => /merged-config.*\.json$/i.test(n)).map((n) => path.join(configDir, n));
+        files.sort((a, b) => {
+            try {
+                const sa = fs.statSync(a);
+                const sb = fs.statSync(b);
+                return (sb.mtimeMs || 0) - (sa.mtimeMs || 0);
+            }
+            catch {
+                return 0;
+            }
+        });
+        return files;
+    }
+    catch {
+        return [];
+    }
+}
+function readJsonSync(file) {
+    try {
+        const fs = require('fs');
+        const buf = fs.readFileSync(file, 'utf-8');
+        return JSON.parse(buf);
+    }
+    catch {
+        return null;
+    }
+}
+function findMaxContextInConfig(cfg, modelId) {
+    try {
+        const vr = cfg.virtualrouter;
+        if (!vr || typeof vr !== 'object')
+            return null;
+        const providers = vr.providers;
+        if (!providers || typeof providers !== 'object')
+            return null;
+        for (const provKey of Object.keys(providers)) {
+            const prov = providers[provKey];
+            if (!prov || typeof prov !== 'object')
+                continue;
+            const models = prov.models;
+            if (!models || typeof models !== 'object')
+                continue;
+            if (Object.prototype.hasOwnProperty.call(models, modelId)) {
+                const item = models[modelId];
+                const v = (item && typeof item === 'object') ? item.maxContext : undefined;
+                const n = Number(v);
+                if (Number.isFinite(n) && n > 0)
+                    return n;
+            }
+        }
+    }
+    catch { /* ignore */ }
+    return null;
+}
+export function resolveBudgetForModelSync(modelId) {
+    try {
+        const viaFacade = UnifiedConfig.getContextBudgetForModel(modelId);
+        if (viaFacade && typeof viaFacade.allowedBytes === 'number')
+            return viaFacade;
+    }
+    catch { /* ignore facade errors and fallback */ }
+    const envDirect = Number(process?.env?.ROUTECODEX_CONTEXT_BUDGET_BYTES || process?.env?.RCC_CONTEXT_BUDGET_BYTES || '');
+    const envSafety = (() => { const v = Number(process?.env?.RCC_CONTEXT_BUDGET_SAFETY ?? 'NaN'); return (Number.isFinite(v) && v >= 0 && v < 1) ? v : NaN; })();
+    if (Number.isFinite(envDirect) && envDirect > 0) {
+        const safety = Number.isFinite(envSafety) ? envSafety : 0.1;
+        const allowed = Math.floor(envDirect * (1 - safety));
+        return { maxBytes: envDirect, safetyRatio: safety, allowedBytes: allowed, source: 'env' };
+    }
+    const path = require('path');
+    const cwd = (typeof process !== 'undefined' && process && typeof process.cwd === 'function') ? process.cwd() : '';
+    const configDir = cwd ? path.join(cwd, 'config') : 'config';
+    // Modules default context budget (fallback)
+    let modulesDefault = null;
+    let modulesSafety = null;
+    try {
+        const file = path.join(configDir, 'modules.json');
+        const cfg = readJsonSync(file);
+        if (cfg && isObject(cfg.modules) && isObject(cfg.modules.virtualrouter) && isObject(cfg.modules.virtualrouter.config)) {
+            const vr = cfg.modules.virtualrouter.config;
+            if (isObject(vr.contextBudget)) {
+                const ctx = vr.contextBudget;
+                const d = Number(ctx.defaultMaxContextBytes);
+                if (Number.isFinite(d) && d > 0)
+                    modulesDefault = d;
+                const s = Number(ctx.safetyRatio);
+                if (Number.isFinite(s) && s >= 0 && s < 1)
+                    modulesSafety = s;
+            }
+        }
+    }
+    catch { /* ignore */ }
+    try {
+        const mergedFiles = listMergedConfigsSync(configDir);
+        for (const file of mergedFiles) {
+            const cfg = readJsonSync(file);
+            if (cfg) {
+                const v = findMaxContextInConfig(cfg, modelId);
+                if (v && v > 0) {
+                    const safety = Number.isFinite(envSafety) ? envSafety : (modulesSafety ?? 0.1);
+                    const allowed = Math.floor(v * (1 - safety));
+                    return { maxBytes: v, safetyRatio: safety, allowedBytes: allowed, source: `merged:${path.basename(file)}` };
+                }
+            }
+        }
+    }
+    catch { /* ignore */ }
+    try {
+        const file = path.join(configDir, 'config.json');
+        const cfg = readJsonSync(file);
+        if (cfg) {
+            const v = findMaxContextInConfig(cfg, modelId);
+            if (v && v > 0) {
+                const safety = Number.isFinite(envSafety) ? envSafety : (modulesSafety ?? 0.1);
+                const allowed = Math.floor(v * (1 - safety));
+                return { maxBytes: v, safetyRatio: safety, allowedBytes: allowed, source: 'config.json' };
+            }
+        }
+    }
+    catch { /* ignore */ }
+    // Fallback to modules default, then hard default
+    const def = modulesDefault && modulesDefault > 0 ? modulesDefault : 200_000;
+    const safety = Number.isFinite(envSafety) ? envSafety : (modulesSafety ?? 0.1);
+    return { maxBytes: def, safetyRatio: safety, allowedBytes: Math.floor(def * (1 - safety)), source: (modulesDefault ? 'modules.json' : 'default') };
+}
+export const resolveBudgetForModel = async (modelId) => resolveBudgetForModelSync(modelId);
+// Apply payload budget enforcement to an OpenAI Chat-shaped request object in-place.
+// Strategy (deterministic, minimal):
+// 1) Truncate the first system message to RCC_SYSTEM_TEXT_LIMIT (default 8192 chars).
+// 2) Remove assistant messages that have no tool_calls and empty/whitespace content.
+// 3) Iteratively clamp tool role message content down to fit allowedBytes.
+// 4) If仍超限，轻度收紧 assistant 文本（不移除，仅截断）。
+export function enforceChatBudget(chat, modelId) {
+    try {
+        if (!chat || typeof chat !== 'object')
+            return chat;
+        const messages = Array.isArray(chat.messages) ? chat.messages : [];
+        if (!messages.length)
+            return chat;
+        const budget = resolveBudgetForModelSync(modelId || 'unknown');
+        const allowed = Math.max(1024, Number(budget.allowedBytes || 200000));
+        const sysLimit = (() => {
+            const raw = process?.env?.RCC_SYSTEM_TEXT_LIMIT;
+            const n = Number(raw);
+            return Number.isFinite(n) && n >= 0 ? n : 8192;
+        })();
+        const size = (obj) => {
+            try {
+                return Buffer.byteLength(JSON.stringify(obj), 'utf8');
+            }
+            catch {
+                return 0;
+            }
+        };
+        const clamp = (s, n) => {
+            if (typeof s !== 'string')
+                return s;
+            if (n === 0)
+                return '';
+            return s.length > n ? (s.slice(0, n) + '...(truncated)') : s;
+        };
+        // 1) System message truncation
+        try {
+            if (sysLimit >= 0 && messages.length) {
+                const first = messages[0];
+                if (first && String(first.role || '').toLowerCase() === 'system' && typeof first.content === 'string') {
+                    first.content = clamp(first.content, sysLimit);
+                }
+            }
+        }
+        catch { /* ignore */ }
+        // 2) Remove empty assistant without tool_calls
+        try {
+            const kept = [];
+            for (const m of messages) {
+                if (!m || typeof m !== 'object') {
+                    kept.push(m);
+                    continue;
+                }
+                const role = String(m.role || '').toLowerCase();
+                if (role === 'assistant' && (!Array.isArray(m.tool_calls) || m.tool_calls.length === 0)) {
+                    const text = typeof m.content === 'string' ? m.content.trim() : '';
+                    if (!text) {
+                        continue;
+                    }
+                }
+                kept.push(m);
+            }
+            chat.messages = kept;
+        }
+        catch { /* ignore */ }
+        if (size(chat) <= allowed)
+            return chat;
+        // 3) Clamp tool messages iteratively
+        const passes = [4000, 1500, 400, 100];
+        for (const limit of passes) {
+            for (const m of chat.messages) {
+                try {
+                    if (!m || typeof m !== 'object')
+                        continue;
+                    if (String(m.role || '').toLowerCase() !== 'tool')
+                        continue;
+                    if (typeof m.content === 'string')
+                        m.content = clamp(m.content, limit);
+                }
+                catch { /* ignore */ }
+            }
+            if (size(chat) <= allowed)
+                return chat;
+        }
+        // 4) Lightly clamp assistant text if still above budget
+        for (const limit of [8000, 4000, 1500]) {
+            for (const m of chat.messages) {
+                try {
+                    if (!m || typeof m !== 'object')
+                        continue;
+                    if (String(m.role || '').toLowerCase() !== 'assistant')
+                        continue;
+                    if (Array.isArray(m.tool_calls) && m.tool_calls.length > 0)
+                        continue; // do not clamp assistant with tools here
+                    if (typeof m.content === 'string')
+                        m.content = clamp(m.content, limit);
+                    else if (Array.isArray(m.content)) {
+                        m.content = m.content.map((p) => (p && typeof p.text === 'string') ? { ...p, text: clamp(p.text, limit) } : p);
+                    }
+                }
+                catch { /* ignore */ }
+            }
+            if (size(chat) <= allowed)
+                break;
+        }
+    }
+    catch { /* ignore budget errors */ }
+    return chat;
+}

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

@@ -0,0 +1,5 @@
+export interface ReasoningItem {
+    type: 'reasoning';
+    content: string;
+}
+export declare function mapReasoningContentToResponsesOutput(reasoningContent: any): ReasoningItem[];

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

@@ -0,0 +1,8 @@
+export function mapReasoningContentToResponsesOutput(reasoningContent) {
+    if (!reasoningContent)
+        return [];
+    const text = Array.isArray(reasoningContent)
+        ? reasoningContent.map((r) => (typeof r?.text === 'string' ? r.text : '')).filter(Boolean).join('\n')
+        : (typeof reasoningContent?.text === 'string' ? reasoningContent.text : '');
+    return text ? [{ type: 'reasoning', content: text }] : [];
+}

package/dist/conversion/shared/responses-conversation-store.d.ts

@@ -0,0 +1,41 @@
+import type { ResponsesRequestContext } from './responses-request-adapter.js';
+declare class ResponsesConversationStore {
+    private requestMap;
+    private responseIndex;
+    captureRequestContext(args: {
+        requestId: string;
+        payload: Record<string, unknown>;
+        context: ResponsesRequestContext;
+    }): void;
+    recordResponse(args: {
+        requestId: string;
+        response: Record<string, unknown>;
+    }): void;
+    resumeConversation(responseId: string, submitPayload: Record<string, unknown>, options?: {
+        requestId?: string;
+    }): {
+        payload: Record<string, unknown>;
+        meta: Record<string, unknown>;
+    };
+    clearRequest(requestId: string): void;
+    private cleanupEntry;
+    private prune;
+}
+export declare const responsesConversationStore: ResponsesConversationStore;
+export declare function captureResponsesRequestContext(args: {
+    requestId: string;
+    payload: Record<string, unknown>;
+    context: ResponsesRequestContext;
+}): void;
+export declare function recordResponsesResponse(args: {
+    requestId: string;
+    response: Record<string, unknown>;
+}): void;
+export declare function resumeResponsesConversation(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 {};

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

@@ -0,0 +1,285 @@
+import { normalizeFunctionCallOutputId } from './responses-id-utils.js';
+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;
+        if (!rawId || !rawId.trim())
+            return;
+        const callId = rawId.trim();
+        const outputValue = rec.output ?? null;
+        const normalizedOutput = typeof outputValue === 'string'
+            ? outputValue
+            : (() => {
+                try {
+                    return JSON.stringify(outputValue ?? null);
+                }
+                catch {
+                    return String(outputValue ?? '');
+                }
+            })();
+        const identifier = normalizeFunctionCallOutputId({
+            callId,
+            fallback: `fc_resume_${index}`
+        });
+        items.push({
+            type: 'function_call_output',
+            id: identifier,
+            call_id: identifier,
+            output: normalizedOutput
+        });
+        submitted.push({ callId: identifier, originalId: callId, outputText: normalizedOutput });
+    });
+    return { items, submitted };
+}
+class ResponsesConversationStore {
+    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('Responses conversation requires valid response_id');
+        }
+        this.prune();
+        const entry = this.responseIndex.get(responseId);
+        if (!entry) {
+            throw new Error('Responses 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 Responses 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 responsesConversationStore = new ResponsesConversationStore();
+export function captureResponsesRequestContext(args) {
+    try {
+        responsesConversationStore.captureRequestContext(args);
+    }
+    catch {
+        /* ignore capture failures */
+    }
+}
+export function recordResponsesResponse(args) {
+    try {
+        responsesConversationStore.recordResponse(args);
+    }
+    catch {
+        /* ignore */
+    }
+}
+export function resumeResponsesConversation(responseId, submitPayload, options) {
+    return responsesConversationStore.resumeConversation(responseId, submitPayload, options);
+}
+export function clearResponsesConversationByRequestId(requestId) {
+    responsesConversationStore.clearRequest(requestId);
+}

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

@@ -0,0 +1,7 @@
+type NormalizeOptions = {
+    callId?: string;
+    fallback?: string;
+};
+export declare function normalizeFunctionCallId(options: NormalizeOptions): string;
+export declare function normalizeFunctionCallOutputId(options: NormalizeOptions): string;
+export {};

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

@@ -0,0 +1,29 @@
+function stripPrefix(value) {
+    if (typeof value !== 'string')
+        return null;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return null;
+    if (/^fc[_-]/i.test(trimmed)) {
+        return `fc_${trimmed.replace(/^fc[_-]?/i, '')}`;
+    }
+    if (/^call[_-]/i.test(trimmed)) {
+        return `fc_${trimmed.replace(/^call[_-]?/i, '')}`;
+    }
+    return `fc_${trimmed}`;
+}
+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/responses-instructions.d.ts

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