@jsonstudio/rcc 0.90.352 → 0.90.367

package/vendor/llmswitch-core/dist/conversion/shared/responses-conversation-store.js

@@ -0,0 +1,195 @@
+import { ProviderProtocolError } from '../provider-protocol-error.js';
+import { convertResponsesOutputToInputItemsWithNative, pickResponsesPersistedFieldsWithNative, prepareResponsesConversationEntryWithNative, resumeResponsesConversationPayloadWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+const TTL_MS = 1000 * 60 * 30; // 30min
+function isRecord(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+function pickPersistedFields(payload) {
+    return pickResponsesPersistedFieldsWithNative(payload);
+}
+function convertOutputToInputItems(response) {
+    return convertResponsesOutputToInputItemsWithNative(response);
+}
+function assertResponsesConversationStoreNativeAvailable() {
+    if (typeof pickResponsesPersistedFieldsWithNative !== 'function' ||
+        typeof convertResponsesOutputToInputItemsWithNative !== 'function' ||
+        typeof prepareResponsesConversationEntryWithNative !== 'function' ||
+        typeof resumeResponsesConversationPayloadWithNative !== 'function') {
+        throw new Error('[responses-conversation-store] native bindings unavailable');
+    }
+}
+class ResponsesConversationStore {
+    requestMap = new Map();
+    responseIndex = new Map();
+    rebindRequestId(oldId, newId) {
+        if (!oldId || !newId || oldId === newId) {
+            return;
+        }
+        const entry = this.requestMap.get(oldId);
+        if (!entry) {
+            return;
+        }
+        this.requestMap.delete(oldId);
+        entry.requestId = newId;
+        this.requestMap.set(newId, entry);
+    }
+    captureRequestContext(args) {
+        const { requestId, payload, context } = args;
+        if (!requestId || !payload)
+            return;
+        this.prune();
+        assertResponsesConversationStoreNativeAvailable();
+        const prepared = prepareResponsesConversationEntryWithNative(payload, context);
+        const entry = {
+            requestId,
+            basePayload: isRecord(prepared.basePayload) ? prepared.basePayload : pickPersistedFields(payload),
+            input: Array.isArray(prepared.input) ? prepared.input : [],
+            tools: Array.isArray(prepared.tools) ? prepared.tools : undefined,
+            createdAt: Date.now(),
+            updatedAt: Date.now()
+        };
+        this.requestMap.set(requestId, entry);
+    }
+    recordResponse(args) {
+        const entry = args.requestId ? this.requestMap.get(args.requestId) : undefined;
+        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 ProviderProtocolError('Responses conversation requires valid response_id', {
+                code: 'MALFORMED_REQUEST',
+                protocol: 'openai-responses',
+                providerType: 'responses',
+                details: {
+                    context: 'responses-conversation-store.resumeConversation',
+                    reason: 'missing_or_empty_response_id'
+                }
+            });
+        }
+        this.prune();
+        const entry = this.responseIndex.get(responseId);
+        if (!entry) {
+            throw new ProviderProtocolError('Responses conversation expired or not found', {
+                code: 'MALFORMED_REQUEST',
+                protocol: 'openai-responses',
+                providerType: 'responses',
+                details: {
+                    context: 'responses-conversation-store.resumeConversation',
+                    reason: 'expired_or_unknown_response_id',
+                    responseId
+                }
+            });
+        }
+        const toolOutputs = Array.isArray(submitPayload.tool_outputs) ? submitPayload.tool_outputs : [];
+        if (!toolOutputs.length) {
+            throw new ProviderProtocolError('tool_outputs array is required when submitting Responses tool results', {
+                code: 'MALFORMED_REQUEST',
+                protocol: 'openai-responses',
+                providerType: 'responses',
+                details: {
+                    context: 'responses-conversation-store.resumeConversation',
+                    reason: 'missing_tool_outputs',
+                    responseId
+                }
+            });
+        }
+        assertResponsesConversationStoreNativeAvailable();
+        const resumed = resumeResponsesConversationPayloadWithNative({
+            requestId: entry.requestId,
+            basePayload: entry.basePayload,
+            input: entry.input,
+            tools: entry.tools
+        }, responseId, submitPayload, options?.requestId);
+        this.cleanupEntry(entry, responseId);
+        return {
+            payload: resumed.payload,
+            meta: resumed.meta
+        };
+    }
+    clearRequest(requestId) {
+        if (!requestId)
+            return;
+        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);
+            }
+        }
+    }
+}
+const store = new ResponsesConversationStore();
+const RESPONSES_DEBUG = (process.env.ROUTECODEX_RESPONSES_DEBUG || '').trim() === '1';
+export function captureResponsesRequestContext(args) {
+    try {
+        if (RESPONSES_DEBUG) {
+            console.log('[responses-store] capture', args.requestId);
+        }
+        store.captureRequestContext(args);
+    }
+    catch {
+        /* ignore capture failures */
+    }
+}
+export function recordResponsesResponse(args) {
+    try {
+        if (RESPONSES_DEBUG) {
+            console.log('[responses-store] record', args.requestId, args.response?.id);
+        }
+        store.recordResponse(args);
+    }
+    catch {
+        /* ignore */
+    }
+}
+export function resumeResponsesConversation(responseId, submitPayload, options) {
+    if (RESPONSES_DEBUG) {
+        console.log('[responses-store] resume', responseId);
+    }
+    return store.resumeConversation(responseId, submitPayload, options);
+}
+export function clearResponsesConversationByRequestId(requestId) {
+    if (RESPONSES_DEBUG && requestId) {
+        console.log('[responses-store] clear', requestId);
+    }
+    store.clearRequest(requestId);
+}
+export function rebindResponsesConversationRequestId(oldId, newId) {
+    if (RESPONSES_DEBUG && oldId && newId) {
+        console.log('[responses-store] rebind', oldId, '->', newId);
+    }
+    store.rebindRequestId(oldId, newId);
+}
+export { store as responsesConversationStore };

package/vendor/llmswitch-core/dist/conversion/shared/responses-output-builder.d.ts

@@ -0,0 +1,13 @@
+import type { ResponsesOutputItem } from '../../sse/types/index.js';
+export interface BuildResponsesOutputOptions {
+    response: Record<string, unknown>;
+    message?: Record<string, unknown>;
+}
+export interface BuildResponsesOutputResult {
+    outputItems: ResponsesOutputItem[];
+    outputText?: string;
+    status: string;
+    requiredAction?: Record<string, unknown>;
+    usage?: unknown;
+}
+export declare function buildResponsesOutputFromChat(options: BuildResponsesOutputOptions): BuildResponsesOutputResult;

package/vendor/llmswitch-core/dist/conversion/shared/responses-output-builder.js

@@ -0,0 +1,32 @@
+import { buildResponsesPayloadFromChatWithNative } from '../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
+export function buildResponsesOutputFromChat(options) {
+    const built = buildResponsesPayloadFromChatWithNative({
+        id: options.response.id,
+        created_at: options.response.created_at,
+        created: options.response.created,
+        model: options.response.model,
+        usage: options.response.usage,
+        request_id: options.response.request_id,
+        tool_outputs: options.response.tool_outputs,
+        __responses_reasoning: options.response.__responses_reasoning,
+        __responses_output_text_meta: options.response.__responses_output_text_meta,
+        choices: [
+            {
+                message: options.message ?? null
+            }
+        ]
+    }, {
+        requestId: typeof options.response.request_id === 'string'
+            ? options.response.request_id
+            : (typeof options.response.id === 'string' ? options.response.id : undefined)
+    });
+    return {
+        outputItems: Array.isArray(built.output) ? built.output : [],
+        outputText: typeof built.output_text === 'string' ? built.output_text : undefined,
+        status: typeof built.status === 'string' ? built.status : 'completed',
+        requiredAction: built.required_action && typeof built.required_action === 'object' && !Array.isArray(built.required_action)
+            ? built.required_action
+            : undefined,
+        usage: built.usage
+    };
+}

package/vendor/llmswitch-core/dist/conversion/shared/responses-reasoning-registry.d.ts

@@ -0,0 +1,24 @@
+export interface ResponsesOutputTextMeta {
+    hasField: boolean;
+    value?: string;
+    raw?: string;
+}
+export interface ResponsesReasoningPayload {
+    summary?: Array<{
+        type: 'summary_text';
+        text: string;
+    }>;
+    content?: Array<{
+        type: 'reasoning_text' | 'text';
+        text: string;
+    }>;
+    encrypted_content?: string | null;
+}
+export declare function registerResponsesReasoning(id: unknown, reasoning: ResponsesReasoningPayload | undefined): void;
+export declare function consumeResponsesReasoning(id: unknown): ResponsesReasoningPayload | undefined;
+export declare function registerResponsesOutputTextMeta(id: unknown, meta: ResponsesOutputTextMeta | undefined): void;
+export declare function consumeResponsesOutputTextMeta(id: unknown): ResponsesOutputTextMeta | undefined;
+export declare function registerResponsesPayloadSnapshot(id: unknown, snapshot: Record<string, unknown> | undefined): void;
+export declare function consumeResponsesPayloadSnapshot(id: unknown): Record<string, unknown> | undefined;
+export declare function registerResponsesPassthrough(id: unknown, payload: Record<string, unknown> | undefined): void;
+export declare function consumeResponsesPassthrough(id: unknown): Record<string, unknown> | undefined;

package/vendor/llmswitch-core/dist/conversion/shared/responses-reasoning-registry.js

@@ -0,0 +1,185 @@
+import { parseLenientJsonishWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+const registry = new Map();
+function collapseReasoningSegments(segments) {
+    const cleaned = segments.map((text) => text.trim()).filter((text) => text.length > 0);
+    const merged = [];
+    for (const entry of cleaned) {
+        if (merged.length === 0) {
+            merged.push(entry);
+            continue;
+        }
+        const last = merged[merged.length - 1];
+        if (entry === last) {
+            continue;
+        }
+        if (entry.startsWith(last)) {
+            merged[merged.length - 1] = entry;
+            continue;
+        }
+        if (last.startsWith(entry)) {
+            continue;
+        }
+        merged.push(entry);
+    }
+    return merged;
+}
+function ensureEntry(id) {
+    let entry = registry.get(id);
+    if (!entry) {
+        entry = {};
+        registry.set(id, entry);
+    }
+    return entry;
+}
+function pruneEntry(id) {
+    const entry = registry.get(id);
+    if (!entry)
+        return;
+    if (!entry.reasoning && !entry.outputText && !entry.payloadSnapshot && !entry.passthroughPayload) {
+        registry.delete(id);
+    }
+}
+function cloneSnapshot(snapshot) {
+    try {
+        const structuredCloneImpl = globalThis.structuredClone;
+        if (typeof structuredCloneImpl === 'function') {
+            return structuredCloneImpl(snapshot);
+        }
+    }
+    catch {
+        /* ignore structuredClone failures */
+    }
+    try {
+        const serialized = JSON.stringify(snapshot);
+        const parsed = parseLenientJsonishWithNative(serialized);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            return parsed;
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function registerResponsesReasoning(id, reasoning) {
+    if (typeof id !== 'string')
+        return;
+    if (!reasoning)
+        return;
+    const summaryRaw = Array.isArray(reasoning.summary)
+        ? reasoning.summary
+            .map((item) => String(item.text ?? '').trim())
+            .filter((text) => text.length > 0)
+        : [];
+    const summaryCollapsed = summaryRaw.length
+        ? collapseReasoningSegments(summaryRaw).map((text) => ({ type: 'summary_text', text }))
+        : undefined;
+    const contentRaw = Array.isArray(reasoning.content)
+        ? reasoning.content
+            .map((item) => String(item.text ?? '').trim())
+            .filter((text) => text.length > 0)
+        : [];
+    const contentCollapsed = contentRaw.length
+        ? collapseReasoningSegments(contentRaw).map((text) => ({
+            type: 'reasoning_text',
+            text
+        }))
+        : undefined;
+    const hasSummary = Array.isArray(summaryCollapsed) && summaryCollapsed.length > 0;
+    const hasContent = Array.isArray(contentCollapsed) && contentCollapsed.length > 0;
+    const hasEncrypted = reasoning.encrypted_content !== undefined;
+    if (!hasSummary && !hasContent && !hasEncrypted)
+        return;
+    const entry = ensureEntry(id);
+    entry.reasoning = {
+        summary: hasSummary ? summaryCollapsed : undefined,
+        content: hasContent ? contentCollapsed : undefined,
+        encrypted_content: reasoning.encrypted_content
+    };
+}
+export function consumeResponsesReasoning(id) {
+    if (typeof id !== 'string')
+        return undefined;
+    const entry = registry.get(id);
+    if (!entry?.reasoning)
+        return undefined;
+    const value = {
+        summary: entry.reasoning.summary ? [...entry.reasoning.summary] : undefined,
+        content: entry.reasoning.content ? [...entry.reasoning.content] : undefined,
+        encrypted_content: entry.reasoning.encrypted_content
+    };
+    entry.reasoning = undefined;
+    pruneEntry(id);
+    return value;
+}
+export function registerResponsesOutputTextMeta(id, meta) {
+    if (typeof id !== 'string')
+        return;
+    if (!meta)
+        return;
+    const entry = ensureEntry(id);
+    entry.outputText = {
+        hasField: Boolean(meta.hasField),
+        value: typeof meta.value === 'string' ? meta.value : undefined,
+        raw: typeof meta.raw === 'string' ? meta.raw : undefined
+    };
+}
+export function consumeResponsesOutputTextMeta(id) {
+    if (typeof id !== 'string')
+        return undefined;
+    const entry = registry.get(id);
+    if (!entry?.outputText)
+        return undefined;
+    const value = {
+        hasField: Boolean(entry.outputText.hasField),
+        value: entry.outputText.value,
+        raw: entry.outputText.raw
+    };
+    entry.outputText = undefined;
+    pruneEntry(id);
+    return value;
+}
+export function registerResponsesPayloadSnapshot(id, snapshot) {
+    if (typeof id !== 'string')
+        return;
+    if (!snapshot || typeof snapshot !== 'object')
+        return;
+    const clone = cloneSnapshot(snapshot);
+    if (!clone)
+        return;
+    const entry = ensureEntry(id);
+    entry.payloadSnapshot = clone;
+}
+export function consumeResponsesPayloadSnapshot(id) {
+    if (typeof id !== 'string')
+        return undefined;
+    const entry = registry.get(id);
+    if (!entry?.payloadSnapshot)
+        return undefined;
+    const clone = cloneSnapshot(entry.payloadSnapshot) ?? entry.payloadSnapshot;
+    entry.payloadSnapshot = undefined;
+    pruneEntry(id);
+    return clone;
+}
+export function registerResponsesPassthrough(id, payload) {
+    if (typeof id !== 'string')
+        return;
+    if (!payload || typeof payload !== 'object')
+        return;
+    const clone = cloneSnapshot(payload);
+    if (!clone)
+        return;
+    const entry = ensureEntry(id);
+    entry.passthroughPayload = clone;
+}
+export function consumeResponsesPassthrough(id) {
+    if (typeof id !== 'string')
+        return undefined;
+    const entry = registry.get(id);
+    if (!entry?.passthroughPayload)
+        return undefined;
+    const clone = cloneSnapshot(entry.passthroughPayload) ?? entry.passthroughPayload;
+    entry.passthroughPayload = undefined;
+    pruneEntry(id);
+    return clone;
+}

package/vendor/llmswitch-core/dist/conversion/shared/responses-request-adapter.d.ts

@@ -0,0 +1,7 @@
+import type { BuildChatRequestResult, ResponsesRequestContext } from '../responses/responses-openai-bridge/types.js';
+export declare function captureResponsesContext(payload: Record<string, unknown>, dto?: {
+    route?: {
+        requestId?: string;
+    };
+}): ResponsesRequestContext;
+export declare function buildChatRequestFromResponses(payload: Record<string, unknown>, context: ResponsesRequestContext): BuildChatRequestResult;

package/vendor/llmswitch-core/dist/conversion/shared/responses-request-adapter.js

@@ -0,0 +1,14 @@
+import { buildChatRequestFromResponses as buildChatRequestFromResponsesImpl, captureResponsesContext as captureResponsesContextImpl } from '../responses/responses-openai-bridge.js';
+import { normalizeProviderProtocolTokenWithNative } from '../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+function assertResponsesNativeBoundary() {
+    // Keep adapter as a thin boundary while forcing native capability presence.
+    normalizeProviderProtocolTokenWithNative('openai-responses');
+}
+export function captureResponsesContext(payload, dto) {
+    assertResponsesNativeBoundary();
+    return captureResponsesContextImpl(payload, dto);
+}
+export function buildChatRequestFromResponses(payload, context) {
+    assertResponsesNativeBoundary();
+    return buildChatRequestFromResponsesImpl(payload, context);
+}

package/vendor/llmswitch-core/dist/conversion/shared/responses-response-utils.d.ts

@@ -0,0 +1,3 @@
+export declare function collectToolCallsFromResponses(response: Record<string, unknown>): Array<Record<string, unknown>>;
+export declare function resolveFinishReason(response: Record<string, unknown>, toolCalls: Array<Record<string, unknown>>): string;
+export declare function buildChatResponseFromResponses(payload: unknown): Record<string, unknown> | unknown;