@jsonstudio/rcc 0.89.3 → 0.89.164

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/compat/compat-profile-store.js

@@ -0,0 +1,76 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { fileURLToPath } from 'node:url';
+const builtinDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../compat/profiles');
+const USER_COMPAT_DIR = (process.env.ROUTECODEX_COMPAT_DIR && process.env.ROUTECODEX_COMPAT_DIR.trim()) ||
+    path.join(os.homedir(), '.routecodex', 'compat');
+let profileMap = null;
+function normalizeProfiles(profiles) {
+    const map = new Map();
+    for (const profile of profiles) {
+        if (!profile || typeof profile !== 'object') {
+            continue;
+        }
+        const id = typeof profile.id === 'string' ? profile.id.trim() : '';
+        if (!id) {
+            continue;
+        }
+        map.set(id, {
+            ...profile,
+            id
+        });
+    }
+    return map;
+}
+function loadProfilesFromDir(dir) {
+    try {
+        if (!fs.existsSync(dir)) {
+            return [];
+        }
+        const entries = fs.readdirSync(dir);
+        const configs = [];
+        for (const entry of entries) {
+            if (!entry.endsWith('.json')) {
+                continue;
+            }
+            const file = path.join(dir, entry);
+            try {
+                const text = fs.readFileSync(file, 'utf8');
+                const json = JSON.parse(text);
+                if (!json.id) {
+                    json.id = entry.replace(/\.json$/i, '');
+                }
+                configs.push(json);
+            }
+            catch (error) {
+                console.warn(`[compat] Failed to load ${file}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        return configs;
+    }
+    catch {
+        return [];
+    }
+}
+function buildProfileMap() {
+    const merged = new Map();
+    const builtinProfiles = normalizeProfiles(loadProfilesFromDir(builtinDir));
+    for (const [key, value] of builtinProfiles.entries()) {
+        merged.set(key, value);
+    }
+    const userProfiles = normalizeProfiles(loadProfilesFromDir(USER_COMPAT_DIR));
+    for (const [key, value] of userProfiles.entries()) {
+        merged.set(key, value);
+    }
+    return merged;
+}
+export function getCompatProfile(profileId) {
+    if (!profileId || !profileId.trim()) {
+        return null;
+    }
+    if (!profileMap) {
+        profileMap = buildProfileMap();
+    }
+    return profileMap.get(profileId.trim()) ?? null;
+}

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/compat/compat-types.d.ts

@@ -0,0 +1,62 @@
+import type { JsonObject, JsonValue } from '../../types/json.js';
+export type CompatDirection = 'request' | 'response';
+export interface CompatProfileConfig {
+    id: string;
+    protocol: string;
+    direction?: CompatDirection;
+    mappings?: MappingInstruction[];
+    filters?: FilterInstruction[];
+    request?: CompatStageConfig;
+    response?: CompatStageConfig;
+}
+export interface CompatStageConfig {
+    mappings?: MappingInstruction[];
+    filters?: FilterInstruction[];
+}
+export type MappingInstruction = {
+    action: 'remove';
+    path: string;
+} | {
+    action: 'rename';
+    from: string;
+    to: string;
+} | {
+    action: 'set';
+    path: string;
+    value: JsonValue;
+} | {
+    action: 'stringify';
+    path: string;
+    fallback?: JsonValue;
+} | {
+    action: 'set_default';
+    path: string;
+    value?: JsonValue;
+    valueSource?: 'timestamp_seconds' | 'chat_completion_id';
+} | {
+    action: 'normalize_tool_choice';
+    path?: string;
+    objectReplacement?: string;
+} | {
+    action: 'inject_instruction';
+    sourcePath: string;
+    targetPath?: string;
+    role?: string;
+    contentType?: string;
+    stripHtml?: boolean;
+    maxLengthEnv?: string[];
+} | {
+    action: 'parse_json';
+    path: string;
+    fallback?: JsonValue;
+} | {
+    action: 'convert_responses_output_to_choices';
+};
+export type FilterInstruction = {
+    action: 'rate_limit_text';
+    needle: string;
+};
+export interface CompatApplicationResult {
+    payload: JsonObject;
+    appliedProfile?: string;
+}

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/compat/compat-types.js

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

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/hub-pipeline.d.ts

@@ -44,6 +44,7 @@ export interface HubPipelineResult {
 export declare class HubPipeline {
     private readonly routerEngine;
     private config;
+    private unsubscribeProviderErrors?;
     constructor(config: HubPipelineConfig);
     updateVirtualRouterConfig(nextConfig: VirtualRouterConfig): void;
     private executeRequestStagePipeline;
@@ -55,6 +56,7 @@ export declare class HubPipeline {
     private buildAdapterContext;
     private maybeCreateStageRecorder;
     private asJsonObject;
+    private pickRawRequestBody;
     private normalizeRequest;
     private convertProcessNodeResult;
     private materializePayload;

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/hub-pipeline.js

@@ -1,5 +1,6 @@
 import { Readable } from 'node:stream';
 import { VirtualRouterEngine } from '../../../router/virtual-router/engine.js';
+import { providerErrorCenter } from '../../../router/virtual-router/error-center.js';
 import { defaultSseCodecRegistry } from '../../../sse/index.js';
 import { ResponsesFormatAdapter } from '../format-adapters/responses-format-adapter.js';
 import { ResponsesSemanticMapper } from '../semantic-mappers/responses-mapper.js';
@@ -18,13 +19,28 @@ import { runReqProcessStage1ToolGovernance } from './stages/req_process/req_proc
 import { runReqProcessStage2RouteSelect } from './stages/req_process/req_process_stage2_route_select/index.js';
 import { runReqOutboundStage1SemanticMap } from './stages/req_outbound/req_outbound_stage1_semantic_map/index.js';
 import { runReqOutboundStage2FormatBuild } from './stages/req_outbound/req_outbound_stage2_format_build/index.js';
+import { runReqOutboundStage3Compat } from './stages/req_outbound/req_outbound_stage3_compat/index.js';
 export class HubPipeline {
     routerEngine;
     config;
+    unsubscribeProviderErrors;
     constructor(config) {
         this.config = config;
         this.routerEngine = new VirtualRouterEngine();
         this.routerEngine.initialize(config.virtualRouter);
+        try {
+            this.unsubscribeProviderErrors = providerErrorCenter.subscribe((event) => {
+                try {
+                    this.routerEngine.handleProviderError(event);
+                }
+                catch {
+                    // ignore subscriber errors
+                }
+            });
+        }
+        catch {
+            this.unsubscribeProviderErrors = undefined;
+        }
     }
     updateVirtualRouterConfig(nextConfig) {
         if (!nextConfig || typeof nextConfig !== 'object') {
@@ -91,6 +107,10 @@ export class HubPipeline {
             }
         }
         const workingRequest = processedRequest ?? standardizedRequest;
+        const normalizedMeta = normalized.metadata;
+        const responsesResume = normalizedMeta && typeof normalizedMeta.responsesResume === 'object'
+            ? normalizedMeta.responsesResume
+            : undefined;
         const metadataInput = {
             requestId: normalized.id,
             entryEndpoint: normalized.entryEndpoint,
@@ -99,7 +119,8 @@ export class HubPipeline {
             direction: normalized.direction,
             providerProtocol: normalized.providerProtocol,
             routeHint: normalized.routeHint,
-            stage: normalized.stage
+            stage: normalized.stage,
+            responsesResume: responsesResume
         };
         const routing = runReqProcessStage2RouteSelect({
             routerEngine: this.routerEngine,
@@ -108,7 +129,23 @@ export class HubPipeline {
             normalizedMetadata: normalized.metadata,
             stageRecorder: inboundRecorder
         });
+        // Emit virtual router hit log for debugging (orange [virtual-router] ...)
+        try {
+            const routeName = routing.decision?.routeName;
+            const providerKey = routing.target?.providerKey;
+            const modelId = workingRequest.model;
+            const logger = (normalized.metadata && normalized.metadata.logger);
+            if (logger && typeof logger.logVirtualRouterHit === 'function' && routeName && providerKey) {
+                logger.logVirtualRouterHit(routeName, providerKey, typeof modelId === 'string' ? modelId : undefined);
+            }
+        }
+        catch {
+            // logging must not break routing
+        }
         const outboundAdapterContext = this.buildAdapterContext(normalized, routing.target);
+        if (routing.target?.compatibilityProfile) {
+            outboundAdapterContext.compatibilityProfile = routing.target.compatibilityProfile;
+        }
         const outboundProtocol = outboundAdapterContext.providerProtocol;
         const protocolSwitch = outboundProtocol !== normalized.providerProtocol;
         const outboundHooks = protocolSwitch ? this.resolveProtocolHooks(outboundProtocol) : hooks;
@@ -122,35 +159,66 @@ export class HubPipeline {
         const outboundEndpoint = resolveEndpointForProviderProtocol(outboundAdapterContext.providerProtocol);
         const outboundRecorder = this.maybeCreateStageRecorder(outboundAdapterContext, outboundEndpoint);
         const outboundStart = Date.now();
-        const outboundStage1 = await runReqOutboundStage1SemanticMap({
-            request: workingRequest,
-            adapterContext: outboundAdapterContext,
-            semanticMapper: outboundSemanticMapper,
-            contextSnapshot: outboundContextSnapshot,
-            contextMetadataKey: outboundContextMetadataKey,
-            stageRecorder: outboundRecorder
-        });
-        const providerPayload = await runReqOutboundStage2FormatBuild({
-            formatEnvelope: outboundStage1.formatEnvelope,
-            adapterContext: outboundAdapterContext,
-            formatAdapter: outboundFormatAdapter,
-            stageRecorder: outboundRecorder
-        });
-        const outboundEnd = Date.now();
-        nodeResults.push({
-            id: 'req_outbound',
-            success: true,
-            metadata: {
-                node: 'req_outbound',
-                executionTime: outboundEnd - outboundStart,
-                startTime: outboundStart,
-                endTime: outboundEnd,
-                dataProcessed: {
-                    messages: workingRequest.messages.length,
-                    tools: workingRequest.tools?.length ?? 0
+        const isResponsesSubmit = normalized.entryEndpoint === '/v1/responses.submit_tool_outputs' &&
+            outboundProtocol === 'openai-responses';
+        let providerPayload;
+        if (isResponsesSubmit) {
+            providerPayload =
+                this.pickRawRequestBody(normalized.metadata) ?? normalized.payload;
+            const outboundEnd = Date.now();
+            nodeResults.push({
+                id: 'req_outbound',
+                success: true,
+                metadata: {
+                    node: 'req_outbound',
+                    executionTime: outboundEnd - outboundStart,
+                    startTime: outboundStart,
+                    endTime: outboundEnd,
+                    dataProcessed: {
+                        messages: 0,
+                        tools: 0
+                    },
+                    bypass: 'responses-submit-passthrough'
                 }
-            }
-        });
+            });
+        }
+        else {
+            const outboundStage1 = await runReqOutboundStage1SemanticMap({
+                request: workingRequest,
+                adapterContext: outboundAdapterContext,
+                semanticMapper: outboundSemanticMapper,
+                contextSnapshot: outboundContextSnapshot,
+                contextMetadataKey: outboundContextMetadataKey,
+                stageRecorder: outboundRecorder
+            });
+            let formattedPayload = await runReqOutboundStage2FormatBuild({
+                formatEnvelope: outboundStage1.formatEnvelope,
+                adapterContext: outboundAdapterContext,
+                formatAdapter: outboundFormatAdapter,
+                stageRecorder: outboundRecorder
+            });
+            formattedPayload = await runReqOutboundStage3Compat({
+                payload: formattedPayload,
+                adapterContext: outboundAdapterContext,
+                stageRecorder: outboundRecorder
+            });
+            providerPayload = formattedPayload;
+            const outboundEnd = Date.now();
+            nodeResults.push({
+                id: 'req_outbound',
+                success: true,
+                metadata: {
+                    node: 'req_outbound',
+                    executionTime: outboundEnd - outboundStart,
+                    startTime: outboundStart,
+                    endTime: outboundEnd,
+                    dataProcessed: {
+                        messages: workingRequest.messages.length,
+                        tools: workingRequest.tools?.length ?? 0
+                    }
+                }
+            });
+        }
         const metadata = {
             ...normalized.metadata,
             entryEndpoint: normalized.entryEndpoint,
@@ -271,6 +339,9 @@ export class HubPipeline {
         if (typeof metadata.assignedModelId === 'string') {
             adapterContext.modelId = metadata.assignedModelId;
         }
+        if (target?.compatibilityProfile && typeof target.compatibilityProfile === 'string') {
+            adapterContext.compatibilityProfile = target.compatibilityProfile;
+        }
         return adapterContext;
     }
     maybeCreateStageRecorder(context, endpoint) {
@@ -292,6 +363,16 @@ export class HubPipeline {
         }
         return value;
     }
+    pickRawRequestBody(metadata) {
+        if (!metadata || typeof metadata !== 'object') {
+            return undefined;
+        }
+        const raw = metadata.__raw_request_body;
+        if (!raw || typeof raw !== 'object') {
+            return undefined;
+        }
+        return raw;
+    }
     async normalizeRequest(request) {
         if (!request || typeof request !== 'object') {
             throw new Error('HubPipeline requires request payload');

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage3_compat/index.d.ts

@@ -0,0 +1,14 @@
+import type { AdapterContext } from '../../../../types/chat-envelope.js';
+import type { StageRecorder } from '../../../../format-adapters/index.js';
+import type { JsonObject } from '../../../../types/json.js';
+export type ProviderPayload = JsonObject;
+export declare function runReqOutboundStage3Compat(options: {
+    payload: ProviderPayload;
+    adapterContext: AdapterContext;
+    stageRecorder?: StageRecorder;
+}): Promise<ProviderPayload>;
+export declare function runRespInboundStageCompatResponse(options: {
+    payload: ProviderPayload;
+    adapterContext: AdapterContext;
+    stageRecorder?: StageRecorder;
+}): ProviderPayload;

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage3_compat/index.js

@@ -0,0 +1,23 @@
+import { applyRequestCompat, applyResponseCompat } from '../../../compat/compat-engine.js';
+function pickCompatProfile(adapterContext) {
+    const candidate = adapterContext.compatibilityProfile;
+    return typeof candidate === 'string' && candidate.trim() ? candidate.trim() : undefined;
+}
+export async function runReqOutboundStage3Compat(options) {
+    const profile = pickCompatProfile(options.adapterContext);
+    const result = applyRequestCompat(profile, options.payload);
+    options.stageRecorder?.record('req_outbound_stage3_compat', {
+        applied: Boolean(result.appliedProfile),
+        profile: result.appliedProfile || profile || 'passthrough'
+    });
+    return result.payload;
+}
+export function runRespInboundStageCompatResponse(options) {
+    const profile = pickCompatProfile(options.adapterContext);
+    const result = applyResponseCompat(profile, options.payload);
+    options.stageRecorder?.record('resp_inbound_stage_compat', {
+        applied: Boolean(result.appliedProfile),
+        profile: result.appliedProfile || profile || 'passthrough'
+    });
+    return result.payload;
+}

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/stages/resp_outbound/resp_outbound_stage1_client_remap/index.js

@@ -15,6 +15,7 @@ export function runRespOutboundStage1ClientRemap(options) {
         clientPayload = buildResponsesPayloadFromChat(options.payload, {
             requestId: options.requestId
         });
+        mergeOriginalResponsesPayload(clientPayload, options.adapterContext);
     }
     recordStage(options.stageRecorder, 'resp_outbound_stage1_client_remap', clientPayload);
     return clientPayload;
@@ -41,3 +42,36 @@ function resolveAliasMapFromContext(adapterContext) {
     }
     return Object.keys(map).length ? map : undefined;
 }
+function mergeOriginalResponsesPayload(payload, adapterContext) {
+    if (!adapterContext) {
+        return;
+    }
+    const raw = adapterContext.__raw_responses_payload;
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        return;
+    }
+    try {
+        if (payload.required_action == null && raw.required_action != null) {
+            payload.required_action = JSON.parse(JSON.stringify(raw.required_action));
+        }
+    }
+    catch {
+        /* ignore clone errors */
+    }
+    const rawStatus = typeof raw.status === 'string' ? raw.status : undefined;
+    if (rawStatus === 'requires_action') {
+        payload.status = 'requires_action';
+    }
+    // 如果桥接后的 payload 没有 usage，而原始 Responses 载荷带有 usage，则回填原始 usage，
+    // 确保 token usage 不在工具/桥接路径中丢失。
+    const payloadUsage = payload.usage;
+    const rawUsage = raw.usage;
+    if ((payloadUsage == null || typeof payloadUsage !== 'object') && rawUsage && typeof rawUsage === 'object') {
+        try {
+            payload.usage = JSON.parse(JSON.stringify(rawUsage));
+        }
+        catch {
+            payload.usage = rawUsage;
+        }
+    }
+}

package/node_modules/@jsonstudio/llms/dist/conversion/hub/process/chat-process.js

@@ -44,7 +44,10 @@ async function applyRequestToolGovernance(request, context) {
         model: request.model,
         profile: providerProtocol,
         stream: inboundStreamIntent,
-        toolFilterHints: metadataToolHints
+        toolFilterHints: metadataToolHints,
+        rawPayload: context.metadata?.__raw_request_body && typeof context.metadata.__raw_request_body === 'object'
+            ? context.metadata.__raw_request_body
+            : undefined
     });
     const governed = normalizeRecord(governedPayload);
     const providerStreamIntent = typeof governed.stream === 'boolean' ? governed.stream : undefined;

package/node_modules/@jsonstudio/llms/dist/conversion/hub/response/provider-response.js

@@ -6,10 +6,12 @@ import { OpenAIChatResponseMapper, ResponsesResponseMapper, AnthropicResponseMap
 import { runRespInboundStage1SseDecode } from '../pipeline/stages/resp_inbound/resp_inbound_stage1_sse_decode/index.js';
 import { runRespInboundStage2FormatParse } from '../pipeline/stages/resp_inbound/resp_inbound_stage2_format_parse/index.js';
 import { runRespInboundStage3SemanticMap } from '../pipeline/stages/resp_inbound/resp_inbound_stage3_semantic_map/index.js';
+import { runRespInboundStageCompatResponse } from '../pipeline/stages/req_outbound/req_outbound_stage3_compat/index.js';
 import { runRespProcessStage1ToolGovernance } from '../pipeline/stages/resp_process/resp_process_stage1_tool_governance/index.js';
 import { runRespProcessStage2Finalize } from '../pipeline/stages/resp_process/resp_process_stage2_finalize/index.js';
 import { runRespOutboundStage1ClientRemap } from '../pipeline/stages/resp_outbound/resp_outbound_stage1_client_remap/index.js';
 import { runRespOutboundStage2SseStream } from '../pipeline/stages/resp_outbound/resp_outbound_stage2_sse_stream/index.js';
+import { recordResponsesResponse } from '../../shared/responses-conversation-store.js';
 function resolveChatReasoningMode(entryEndpoint) {
     const envRaw = (process.env.ROUTECODEX_CHAT_REASONING_MODE || process.env.RCC_CHAT_REASONING_MODE || '').trim().toLowerCase();
     const map = {
@@ -105,6 +107,30 @@ export async function convertProviderResponse(options) {
         formatAdapter,
         stageRecorder: options.stageRecorder
     });
+    if (options.providerProtocol === 'openai-responses') {
+        try {
+            recordResponsesResponse({
+                requestId: options.context.requestId,
+                response: formatEnvelope.payload
+            });
+        }
+        catch {
+            // ignore conversation capture errors
+        }
+        if (formatEnvelope.payload && typeof formatEnvelope.payload === 'object') {
+            try {
+                options.context.__raw_responses_payload = JSON.parse(JSON.stringify(formatEnvelope.payload));
+            }
+            catch {
+                /* best-effort clone */
+            }
+        }
+    }
+    formatEnvelope.payload = runRespInboundStageCompatResponse({
+        payload: formatEnvelope.payload,
+        adapterContext: options.context,
+        stageRecorder: options.stageRecorder
+    });
     const chatResponse = await runRespInboundStage3SemanticMap({
         adapterContext: options.context,
         formatEnvelope,

package/node_modules/@jsonstudio/llms/dist/conversion/responses/responses-openai-bridge.d.ts

@@ -48,6 +48,7 @@ export declare function buildResponsesRequestFromChat(payload: Record<string, un
     bridgeHistory?: BridgeInputBuildResult;
     systemInstruction?: string;
 }): BuildResponsesRequestResult;
+export declare function ensureResponsesApplyPatchArguments(input?: BridgeInputItem[]): void;
 export declare function buildResponsesPayloadFromChat(payload: unknown, context?: ResponsesRequestContext): Record<string, unknown> | unknown;
 export declare function extractRequestIdFromResponse(response: any): string | undefined;
 export { buildChatResponseFromResponses } from '../shared/responses-response-utils.js';

package/node_modules/@jsonstudio/llms/dist/conversion/responses/responses-openai-bridge.js

@@ -18,6 +18,7 @@ function isObject(v) {
 // --- Public bridge functions ---
 export function captureResponsesContext(payload, dto) {
     const preservedInput = cloneBridgeEntries(payload.input);
+    ensureResponsesApplyPatchArguments(preservedInput);
     ensureBridgeInstructions(payload);
     const context = {
         requestId: dto?.route?.requestId,
@@ -298,6 +299,76 @@ export function buildResponsesRequestFromChat(payload, ctx, extras) {
     ensureBridgeInstructions(out);
     return { request: out, originalSystemMessages };
 }
+export function ensureResponsesApplyPatchArguments(input) {
+    if (!Array.isArray(input) || !input.length) {
+        return;
+    }
+    for (const entry of input) {
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const type = typeof entry.type === 'string' ? entry.type.toLowerCase() : '';
+        if (type !== 'function_call')
+            continue;
+        const name = (typeof entry.name === 'string' && entry.name.trim()) ||
+            (entry.function && typeof entry.function === 'object' && typeof entry.function.name === 'string' && entry.function.name.trim()) ||
+            '';
+        if (name !== 'apply_patch')
+            continue;
+        let normalized;
+        try {
+            normalized = normalizeApplyPatchArguments(entry.arguments ?? entry.function?.arguments);
+        }
+        catch {
+            // best-effort: do not fail the whole request due to a malformed historical tool call
+            normalized = undefined;
+        }
+        if (normalized === undefined) {
+            continue;
+        }
+        entry.arguments = normalized;
+        if (entry.function && typeof entry.function === 'object') {
+            entry.function.arguments = normalized;
+        }
+    }
+}
+function normalizeApplyPatchArguments(source) {
+    let parsed;
+    if (typeof source === 'string' && source.trim()) {
+        try {
+            parsed = JSON.parse(source);
+        }
+        catch {
+            parsed = { patch: source };
+        }
+    }
+    else if (source && typeof source === 'object') {
+        parsed = { ...source };
+    }
+    else if (source === undefined) {
+        parsed = {};
+    }
+    else {
+        return typeof source === 'string' ? source : undefined;
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        return typeof source === 'string' ? source : undefined;
+    }
+    const patchText = typeof parsed.patch === 'string' && parsed.patch.trim().length
+        ? parsed.patch
+        : typeof parsed.input === 'string' && parsed.input.trim().length
+            ? parsed.input
+            : undefined;
+    if (patchText) {
+        parsed.patch = patchText;
+        parsed.input = patchText;
+    }
+    try {
+        return JSON.stringify(parsed);
+    }
+    catch {
+        return typeof source === 'string' ? source : undefined;
+    }
+}
 function readToolCallIdStyleFromContext(ctx) {
     if (!ctx) {
         return undefined;

package/node_modules/@jsonstudio/llms/dist/conversion/shared/responses-conversation-store.d.ts

@@ -0,0 +1,35 @@
+type AnyRecord = Record<string, unknown>;
+interface CaptureContextArgs {
+    requestId?: string;
+    payload: AnyRecord;
+    context: AnyRecord;
+}
+interface RecordResponseArgs {
+    requestId?: string;
+    response: AnyRecord;
+}
+interface ResumeOptions {
+    requestId?: string;
+}
+interface ResumeResult {
+    payload: AnyRecord;
+    meta: AnyRecord;
+}
+declare class ResponsesConversationStore {
+    private requestMap;
+    private responseIndex;
+    rebindRequestId(oldId: string | undefined, newId: string | undefined): void;
+    captureRequestContext(args: CaptureContextArgs): void;
+    recordResponse(args: RecordResponseArgs): void;
+    resumeConversation(responseId: string, submitPayload: AnyRecord, options?: ResumeOptions): ResumeResult;
+    clearRequest(requestId?: string): void;
+    private cleanupEntry;
+    private prune;
+}
+declare const store: ResponsesConversationStore;
+export declare function captureResponsesRequestContext(args: CaptureContextArgs): void;
+export declare function recordResponsesResponse(args: RecordResponseArgs): void;
+export declare function resumeResponsesConversation(responseId: string, submitPayload: AnyRecord, options?: ResumeOptions): ResumeResult;
+export declare function clearResponsesConversationByRequestId(requestId?: string): void;
+export declare function rebindResponsesConversationRequestId(oldId?: string, newId?: string): void;
+export { store as responsesConversationStore };