@jsonstudio/rcc 0.90.352 → 0.90.367

package/vendor/llmswitch-core/dist/conversion/pipeline/index.js

@@ -0,0 +1,103 @@
+import { ConversionMetaBag } from './meta/meta-bag.js';
+export class PipelineValidationError extends Error {
+    stage;
+    errors;
+    constructor(stage, errors) {
+        super(errors[0]?.message ?? `Validation failed during ${stage}`);
+        this.name = 'PipelineValidationError';
+        this.stage = stage;
+        this.errors = errors;
+    }
+}
+function normalizeContext(hooks, ctx) {
+    return {
+        profileId: ctx?.profileId ?? hooks.id,
+        providerProtocol: ctx?.providerProtocol ?? hooks.protocol,
+        targetProtocol: ctx?.targetProtocol ?? ctx?.providerProtocol ?? hooks.protocol,
+        entryEndpoint: ctx?.entryEndpoint,
+        requestId: ctx?.requestId,
+        stream: ctx?.stream,
+        metadata: ctx?.metadata ?? {}
+    };
+}
+function ingestMeta(target, incoming) {
+    if (!incoming) {
+        return;
+    }
+    target.ingest(incoming);
+}
+export class ProtocolConversionPipeline {
+    hooks;
+    constructor(hooks) {
+        if (!hooks?.inbound?.parse) {
+            throw new Error('ProtocolConversionPipeline requires an inbound.parse hook');
+        }
+        if (!hooks?.outbound?.serialize) {
+            throw new Error('ProtocolConversionPipeline requires an outbound.serialize hook');
+        }
+        this.hooks = hooks;
+    }
+    async convertInbound(options) {
+        const context = normalizeContext(this.hooks, options.context);
+        const meta = new ConversionMetaBag(options.meta);
+        await this.runValidation('inbound.preValidate', this.hooks.inbound.preValidate, {
+            wire: options.payload,
+            meta,
+            context
+        });
+        const parseResult = await this.hooks.inbound.parse({
+            wire: options.payload,
+            meta,
+            context
+        });
+        ingestMeta(meta, parseResult.meta);
+        const canonical = parseResult.canonical;
+        if (!canonical) {
+            throw new Error('ProtocolConversionPipeline inbound.parse returned an empty canonical payload');
+        }
+        if (this.hooks.inbound.cleanup) {
+            await this.hooks.inbound.cleanup({
+                canonical,
+                meta,
+                context
+            });
+        }
+        return { canonical, meta, context };
+    }
+    async convertOutbound(options) {
+        const context = normalizeContext(this.hooks, options.context);
+        const meta = new ConversionMetaBag(options.meta);
+        if (this.hooks.outbound.augment) {
+            await this.hooks.outbound.augment({
+                canonical: options.canonical,
+                meta,
+                context
+            });
+        }
+        const serialized = await this.hooks.outbound.serialize({
+            canonical: options.canonical,
+            meta,
+            context
+        });
+        ingestMeta(meta, serialized.meta);
+        await this.runValidation('outbound.postValidate', this.hooks.outbound.postValidate, {
+            wire: serialized.payload,
+            meta,
+            context
+        });
+        return { payload: serialized.payload, meta, context };
+    }
+    async runValidation(stage, hook, args) {
+        if (!hook) {
+            return;
+        }
+        const result = await hook(args);
+        if (!result) {
+            return;
+        }
+        const errors = result.errors ?? [];
+        if (result.ok === false || errors.length > 0) {
+            throw new PipelineValidationError(stage, errors.length ? errors : [{ message: 'Unknown validation error' }]);
+        }
+    }
+}

package/vendor/llmswitch-core/dist/conversion/pipeline/meta/meta-bag.d.ts

@@ -0,0 +1,20 @@
+import { type JsonValue } from '../../hub/types/json.js';
+export type ConversionMetaValue = JsonValue;
+export type ConversionMetaRecord = Record<string, ConversionMetaValue>;
+export type ConversionMetaEntries = Iterable<[string, ConversionMetaValue]>;
+export type ConversionMetaInput = ConversionMetaBag | ConversionMetaRecord | ConversionMetaEntries | undefined;
+export declare class ConversionMetaBag {
+    private readonly store;
+    constructor(initial?: ConversionMetaInput);
+    static from(input?: ConversionMetaInput): ConversionMetaBag;
+    keys(): string[];
+    has(key: string): boolean;
+    get<T extends ConversionMetaValue>(key: string): T | undefined;
+    set(key: string, value: ConversionMetaValue | undefined): void;
+    consume<T extends ConversionMetaValue>(key: string): T | undefined;
+    ingest(input?: ConversionMetaInput): void;
+    entries(): ConversionMetaEntries;
+    snapshot(): ConversionMetaRecord;
+    toJSON(): ConversionMetaRecord;
+    clone(): ConversionMetaBag;
+}

package/vendor/llmswitch-core/dist/conversion/pipeline/meta/meta-bag.js

@@ -0,0 +1,81 @@
+import { jsonClone } from '../../hub/types/json.js';
+function cloneValue(value) {
+    return jsonClone(value);
+}
+function entriesFromInput(input) {
+    if (!input) {
+        return undefined;
+    }
+    if (input instanceof ConversionMetaBag) {
+        return input.entries();
+    }
+    if (typeof input[Symbol.iterator] === 'function') {
+        return input;
+    }
+    return Object.entries(input);
+}
+export class ConversionMetaBag {
+    store = new Map();
+    constructor(initial) {
+        if (initial) {
+            this.ingest(initial);
+        }
+    }
+    static from(input) {
+        return new ConversionMetaBag(input);
+    }
+    keys() {
+        return Array.from(this.store.keys());
+    }
+    has(key) {
+        return this.store.has(key);
+    }
+    get(key) {
+        const value = this.store.get(key);
+        return value;
+    }
+    set(key, value) {
+        if (value === undefined) {
+            this.store.delete(key);
+            return;
+        }
+        this.store.set(key, cloneValue(value));
+    }
+    consume(key) {
+        const value = this.get(key);
+        if (value !== undefined) {
+            this.store.delete(key);
+        }
+        return value;
+    }
+    ingest(input) {
+        const incoming = entriesFromInput(input);
+        if (!incoming) {
+            return;
+        }
+        for (const [key, value] of incoming) {
+            if (value === undefined) {
+                this.store.delete(key);
+            }
+            else {
+                this.store.set(key, cloneValue(value));
+            }
+        }
+    }
+    entries() {
+        return this.store.entries();
+    }
+    snapshot() {
+        const out = {};
+        for (const [key, value] of this.store.entries()) {
+            out[key] = cloneValue(value);
+        }
+        return out;
+    }
+    toJSON() {
+        return this.snapshot();
+    }
+    clone() {
+        return new ConversionMetaBag(this.entries());
+    }
+}

package/vendor/llmswitch-core/dist/conversion/pipeline/schema/canonical-chat.d.ts

@@ -0,0 +1,18 @@
+import type { ProcessedRequest, StandardizedRequest } from '../../hub/types/standardized.js';
+import type { ChatCompletionLike } from '../../hub/response/response-mappers.js';
+/**
+ * Canonical request payload used by the Chat Process. The structure already
+ * exists inside the hub pipeline (`StandardizedRequest`), so v2 codecs can
+ * simply reuse it to avoid redefining similar shapes.
+ */
+export type CanonicalChatRequest = StandardizedRequest;
+/**
+ * Processed requests (after tool governance/reranking) are also exposed so the
+ * outbound side can make decisions that depend on process metadata.
+ */
+export type CanonicalProcessedRequest = ProcessedRequest;
+/**
+ * Canonical response payloads follow the OpenAI ChatCompletion-like structure
+ * that the existing format adapters emit.
+ */
+export type CanonicalChatResponse = ChatCompletionLike;

package/vendor/llmswitch-core/dist/conversion/pipeline/schema/canonical-chat.js

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

package/vendor/llmswitch-core/dist/conversion/pipeline/schema/index.d.ts

@@ -0,0 +1 @@
+export * from './canonical-chat.js';

package/vendor/llmswitch-core/dist/conversion/pipeline/schema/index.js

@@ -0,0 +1 @@
+export * from './canonical-chat.js';

package/vendor/llmswitch-core/dist/conversion/protocol-field-allowlists.d.ts

@@ -0,0 +1,7 @@
+export declare const OPENAI_CHAT_ALLOWED_FIELDS: readonly string[];
+export declare const ANTHROPIC_ALLOWED_FIELDS: readonly string[];
+export declare const OPENAI_RESPONSES_ALLOWED_FIELDS: readonly string[];
+export declare const GEMINI_ALLOWED_FIELDS: readonly string[];
+export declare const OPENAI_RESPONSES_PARAMETERS_WRAPPER_ALLOW_KEYS: readonly string[];
+export declare const OPENAI_CHAT_PARAMETERS_WRAPPER_ALLOW_KEYS: readonly string[];
+export declare const ANTHROPIC_PARAMETERS_WRAPPER_ALLOW_KEYS: readonly string[];

package/vendor/llmswitch-core/dist/conversion/protocol-field-allowlists.js

@@ -0,0 +1,9 @@
+import { resolveHubProtocolAllowlistsWithNative } from '../router/virtual-router/engine-selection/native-hub-bridge-policy-semantics.js';
+const allowlists = resolveHubProtocolAllowlistsWithNative();
+export const OPENAI_CHAT_ALLOWED_FIELDS = Object.freeze([...allowlists.openaiChatAllowedFields]);
+export const ANTHROPIC_ALLOWED_FIELDS = Object.freeze([...allowlists.anthropicAllowedFields]);
+export const OPENAI_RESPONSES_ALLOWED_FIELDS = Object.freeze([...allowlists.openaiResponsesAllowedFields]);
+export const GEMINI_ALLOWED_FIELDS = Object.freeze([...allowlists.geminiAllowedFields]);
+export const OPENAI_RESPONSES_PARAMETERS_WRAPPER_ALLOW_KEYS = Object.freeze([...allowlists.openaiResponsesParametersWrapperAllowKeys]);
+export const OPENAI_CHAT_PARAMETERS_WRAPPER_ALLOW_KEYS = Object.freeze([...allowlists.openaiChatParametersWrapperAllowKeys]);
+export const ANTHROPIC_PARAMETERS_WRAPPER_ALLOW_KEYS = Object.freeze([...allowlists.anthropicParametersWrapperAllowKeys]);

package/vendor/llmswitch-core/dist/conversion/protocol-state.d.ts

@@ -0,0 +1,4 @@
+import type { ChatEnvelope } from './hub/types/chat-envelope.js';
+import { type JsonObject } from './hub/types/json.js';
+export declare function ensureProtocolState(metadata: ChatEnvelope['metadata'], protocol: string): JsonObject;
+export declare function getProtocolState(metadata: ChatEnvelope['metadata'] | undefined, protocol: string): JsonObject | undefined;

package/vendor/llmswitch-core/dist/conversion/protocol-state.js

@@ -0,0 +1,27 @@
+import { isJsonObject } from './hub/types/json.js';
+import { ensureProtocolStateWithNative, getProtocolStateWithNative } from '../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+const PROTOCOL_STATE_KEY = 'protocolState';
+export function ensureProtocolState(metadata, protocol) {
+    const native = ensureProtocolStateWithNative(metadata, protocol);
+    for (const key of Object.keys(metadata)) {
+        if (!Object.prototype.hasOwnProperty.call(native.metadata, key)) {
+            delete metadata[key];
+        }
+    }
+    Object.assign(metadata, native.metadata);
+    if (!metadata[PROTOCOL_STATE_KEY] || !isJsonObject(metadata[PROTOCOL_STATE_KEY])) {
+        metadata[PROTOCOL_STATE_KEY] = {};
+    }
+    const container = metadata[PROTOCOL_STATE_KEY];
+    if (!isJsonObject(container[protocol])) {
+        container[protocol] = native.node;
+    }
+    return container[protocol];
+}
+export function getProtocolState(metadata, protocol) {
+    if (!metadata) {
+        return undefined;
+    }
+    const node = getProtocolStateWithNative(metadata, protocol);
+    return node && isJsonObject(node) ? node : undefined;
+}

package/vendor/llmswitch-core/dist/conversion/provider-protocol-error.d.ts

@@ -0,0 +1,17 @@
+export type ProviderProtocolErrorCode = 'TOOL_PROTOCOL_ERROR' | 'SSE_DECODE_ERROR' | 'HTTP_502' | 'MALFORMED_RESPONSE' | 'MALFORMED_REQUEST' | 'SERVERTOOL_FOLLOWUP_FAILED' | 'SERVERTOOL_EMPTY_FOLLOWUP' | 'SERVERTOOL_TIMEOUT' | 'SERVERTOOL_HANDLER_FAILED';
+export type ProviderErrorCategory = 'EXTERNAL_ERROR' | 'TOOL_ERROR' | 'INTERNAL_ERROR';
+export interface ProviderProtocolErrorOptions {
+    code: ProviderProtocolErrorCode;
+    protocol?: string;
+    providerType?: string;
+    category?: ProviderErrorCategory;
+    details?: Record<string, unknown>;
+}
+export declare class ProviderProtocolError extends Error {
+    readonly code: ProviderProtocolErrorCode;
+    readonly protocol?: string;
+    readonly providerType?: string;
+    readonly category: ProviderErrorCategory;
+    readonly details?: Record<string, unknown>;
+    constructor(message: string, options: ProviderProtocolErrorOptions);
+}

package/vendor/llmswitch-core/dist/conversion/provider-protocol-error.js

@@ -0,0 +1,25 @@
+import { buildProviderProtocolErrorWithNative } from '../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+export class ProviderProtocolError extends Error {
+    code;
+    protocol;
+    providerType;
+    category;
+    details;
+    constructor(message, options) {
+        super(message);
+        this.name = 'ProviderProtocolError';
+        const native = buildProviderProtocolErrorWithNative({
+            message,
+            code: options.code,
+            protocol: options.protocol,
+            providerType: options.providerType,
+            category: options.category,
+            details: options.details
+        });
+        this.code = options.code;
+        this.protocol = typeof native.protocol === 'string' ? native.protocol : options.protocol;
+        this.providerType = typeof native.providerType === 'string' ? native.providerType : options.providerType;
+        this.category = native.category || options.category || 'EXTERNAL_ERROR';
+        this.details = native.details ?? options.details;
+    }
+}

package/vendor/llmswitch-core/dist/conversion/responses/responses-host-policy.d.ts

@@ -0,0 +1,6 @@
+import type { ResponsesRequestContext } from './responses-openai-bridge.js';
+export interface ResponsesHostPolicyResult {
+    shouldStripHostManagedFields: boolean;
+    targetProtocol: string;
+}
+export declare function evaluateResponsesHostPolicy(context?: ResponsesRequestContext, targetProtocol?: string): ResponsesHostPolicyResult;

package/vendor/llmswitch-core/dist/conversion/responses/responses-host-policy.js

@@ -0,0 +1,4 @@
+import { evaluateResponsesHostPolicyWithNative } from '../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
+export function evaluateResponsesHostPolicy(context, targetProtocol) {
+    return evaluateResponsesHostPolicyWithNative(context, targetProtocol);
+}

package/vendor/llmswitch-core/dist/conversion/responses/responses-openai-bridge/response-payload.d.ts

@@ -0,0 +1,3 @@
+import type { ResponsesRequestContext } from './types.js';
+export declare function buildResponsesPayloadFromChat(payload: unknown, context?: ResponsesRequestContext): Record<string, unknown> | unknown;
+export declare function extractRequestIdFromResponse(response: any): string | undefined;

package/vendor/llmswitch-core/dist/conversion/responses/responses-openai-bridge/response-payload.js

@@ -0,0 +1,190 @@
+import { evaluateResponsesHostPolicy } from '../responses-host-policy.js';
+import { normalizeMessageReasoningTools } from '../../shared/reasoning-tool-normalizer.js';
+import { createBridgeActionState, runBridgeActionPipeline } from '../../bridge-actions.js';
+import { resolveBridgePolicy, resolvePolicyActions } from '../../bridge-policies.js';
+import { consumeResponsesPayloadSnapshot, consumeResponsesPassthrough } from '../../shared/responses-reasoning-registry.js';
+import { stripInternalToolingMetadata } from '../../shared/responses-tool-utils.js';
+import { ProviderProtocolError } from '../../provider-protocol-error.js';
+import { buildResponsesPayloadFromChatWithNative, normalizeResponsesToolCallArgumentsForClientWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
+import { normalizeChatResponseReasoningToolsWithNative } from '../../../router/virtual-router/engine-selection/native-hub-bridge-action-semantics.js';
+function normalizeResponsesToolCallArgumentsForClient(responsesPayload, context) {
+    const toolsRaw = Array.isArray(context?.toolsRaw) ? context?.toolsRaw : [];
+    if (!toolsRaw.length) {
+        return;
+    }
+    const normalized = normalizeResponsesToolCallArgumentsForClientWithNative(responsesPayload, toolsRaw);
+    for (const key of Object.keys(responsesPayload)) {
+        if (!Object.prototype.hasOwnProperty.call(normalized, key)) {
+            delete responsesPayload[key];
+        }
+    }
+    Object.assign(responsesPayload, normalized);
+}
+function unwrapData(value) {
+    let current = value;
+    const seen = new Set();
+    while (current && typeof current === 'object' && !Array.isArray(current) && !seen.has(current)) {
+        seen.add(current);
+        if ('choices' in current || 'message' in current)
+            break;
+        if ('data' in current && typeof current.data === 'object') {
+            current = current.data;
+            continue;
+        }
+        break;
+    }
+    return current;
+}
+function resolveSnapshotLookupKey(response, context) {
+    if (typeof response?.request_id === 'string') {
+        return response.request_id;
+    }
+    if (typeof context?.requestId === 'string') {
+        return context.requestId;
+    }
+    if (typeof response?.id === 'string') {
+        return response.id;
+    }
+    return undefined;
+}
+function shouldStripHostManagedFields(context) {
+    const result = evaluateResponsesHostPolicy(context, typeof context?.targetProtocol === 'string' ? context?.targetProtocol : undefined);
+    return result.shouldStripHostManagedFields;
+}
+function collectRetentionContext(context) {
+    const stripHostManagedFields = shouldStripHostManagedFields(context);
+    return {
+        metadata: context?.metadata,
+        stripHostManagedFields
+    };
+}
+function readInlineRetentionPayload(response, key) {
+    const candidate = response[key];
+    return candidate && typeof candidate === 'object' && !Array.isArray(candidate)
+        ? candidate
+        : undefined;
+}
+export function buildResponsesPayloadFromChat(payload, context) {
+    if (!payload || typeof payload !== 'object')
+        return payload;
+    const response = unwrapData(payload);
+    if (!response || typeof response !== 'object')
+        return payload;
+    if (response.object === 'response' && Array.isArray(response.output)) {
+        return response;
+    }
+    const snapshotLookupKey = resolveSnapshotLookupKey(response, context);
+    const snapshotPayload = snapshotLookupKey ? consumeResponsesPayloadSnapshot(snapshotLookupKey) : undefined;
+    const passthroughPayload = snapshotLookupKey ? consumeResponsesPassthrough(snapshotLookupKey) : undefined;
+    const sourceForRetention = (passthroughPayload && typeof passthroughPayload === 'object' ? passthroughPayload : undefined) ??
+        readInlineRetentionPayload(response, '__responses_passthrough') ??
+        (snapshotPayload && typeof snapshotPayload === 'object' ? snapshotPayload : undefined) ??
+        readInlineRetentionPayload(response, '__responses_payload_snapshot');
+    const retentionContext = collectRetentionContext(context);
+    const hasChoicesArray = Array.isArray(response.choices);
+    const choicesLength = hasChoicesArray ? response.choices.length : 0;
+    if (!hasChoicesArray || choicesLength === 0) {
+        const rawStatus = response.status;
+        const statusCode = typeof rawStatus === 'string' && rawStatus.trim().length
+            ? rawStatus.trim()
+            : typeof rawStatus === 'number'
+                ? String(rawStatus)
+                : undefined;
+        const message = typeof response.msg === 'string' && response.msg.trim().length
+            ? response.msg.trim()
+            : typeof response.message === 'string' && response.message.trim().length
+                ? response.message.trim()
+                : 'Upstream returned non-standard Chat completion payload (missing choices).';
+        const mergedFallback = buildResponsesPayloadFromChatWithNative(response, {
+            requestId: context?.requestId,
+            toolsRaw: Array.isArray(context?.toolsRaw) ? context?.toolsRaw : [],
+            metadata: retentionContext.metadata,
+            stripHostManagedFields: retentionContext.stripHostManagedFields,
+            sourceForRetention: sourceForRetention
+        });
+        if (mergedFallback.metadata) {
+            stripInternalToolingMetadata(mergedFallback.metadata);
+        }
+        return mergedFallback;
+    }
+    const canonical = normalizeChatResponseReasoningToolsWithNative(response);
+    const choices = Array.isArray(canonical?.choices) ? canonical.choices : [];
+    const primaryChoice = choices[0] && typeof choices[0] === 'object' ? choices[0] : undefined;
+    const message = primaryChoice && typeof primaryChoice.message === 'object' ? primaryChoice.message : undefined;
+    if (!message) {
+        throw new ProviderProtocolError('Responses bridge could not locate assistant message in Chat completion', {
+            code: 'MALFORMED_RESPONSE',
+            protocol: 'openai-chat',
+            providerType: 'openai',
+            details: {
+                context: 'buildResponsesPayloadFromChat',
+                choicesLength: choices.length,
+                requestId: context?.requestId
+            }
+        });
+    }
+    if (message) {
+        try {
+            const bridgePolicy = resolveBridgePolicy({ protocol: 'openai-responses', moduleType: 'openai-responses' });
+            const policyActions = resolvePolicyActions(bridgePolicy, 'response_outbound');
+            if (policyActions?.length) {
+                const actionState = createBridgeActionState({ messages: [message] });
+                runBridgeActionPipeline({
+                    stage: 'response_outbound',
+                    actions: policyActions,
+                    protocol: bridgePolicy?.protocol ?? 'openai-responses',
+                    moduleType: bridgePolicy?.moduleType ?? 'openai-responses',
+                    requestId: context?.requestId,
+                    state: actionState
+                });
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error
+                ? error.message
+                : typeof error === 'string'
+                    ? error
+                    : 'unknown_error';
+            try {
+                // eslint-disable-next-line no-console
+                console.error(`\x1b[31m[responses-bridge][response_outbound] bridge action pipeline failed requestId=${context?.requestId ?? 'unknown'} error=${errorMessage}\x1b[0m`);
+            }
+            catch {
+                // ignore logging failures
+            }
+        }
+    }
+    if (message) {
+        try {
+            normalizeMessageReasoningTools(message, {
+                idPrefix: `responses_reasoning_${context?.requestId ?? 'canonical'}`
+            });
+        }
+        catch {
+            // best-effort reasoning normalization
+        }
+    }
+    const nativeBuilt = buildResponsesPayloadFromChatWithNative(response, {
+        requestId: context?.requestId,
+        toolsRaw: Array.isArray(context?.toolsRaw) ? context?.toolsRaw : [],
+        metadata: retentionContext.metadata,
+        stripHostManagedFields: retentionContext.stripHostManagedFields,
+        sourceForRetention: sourceForRetention
+    });
+    const out = {
+        ...nativeBuilt
+    };
+    normalizeResponsesToolCallArgumentsForClient(out, context);
+    if (out.metadata) {
+        stripInternalToolingMetadata(out.metadata);
+    }
+    return out;
+}
+export function extractRequestIdFromResponse(response) {
+    if (response && typeof response === 'object' && 'metadata' in response && response.metadata && typeof response.metadata === 'object') {
+        const meta = response.metadata;
+        if (typeof meta.requestId === 'string')
+            return meta.requestId;
+    }
+    return undefined;
+}

package/vendor/llmswitch-core/dist/conversion/responses/responses-openai-bridge/types.d.ts

@@ -0,0 +1,35 @@
+import type { BridgeInputItem, BridgeToolDefinition } from '../../types/bridge-message-types.js';
+import type { ChatToolDefinition } from '../../hub/types/chat-envelope.js';
+import type { JsonObject } from '../../hub/types/json.js';
+import type { ToolCallIdStyle } from '../../shared/responses-tool-utils.js';
+export type Unknown = Record<string, unknown>;
+export interface ResponsesRequestContext extends Unknown {
+    requestId?: string;
+    targetProtocol?: string;
+    originalSystemMessages?: string[];
+    input?: BridgeInputItem[];
+    metadata?: JsonObject;
+    isChatPayload?: boolean;
+    isResponsesPayload?: boolean;
+    historyMessages?: Array<{
+        role: string;
+        content: string;
+    }>;
+    currentMessage?: {
+        role: string;
+        content: string;
+    } | null;
+    toolsRaw?: BridgeToolDefinition[];
+    toolsNormalized?: Array<Record<string, unknown>>;
+    parameters?: Record<string, unknown>;
+    systemInstruction?: string;
+    toolCallIdStyle?: ToolCallIdStyle;
+}
+export interface BuildChatRequestResult {
+    request: Record<string, unknown>;
+    toolsNormalized?: ChatToolDefinition[];
+}
+export interface BuildResponsesRequestResult {
+    request: Record<string, unknown>;
+    originalSystemMessages?: string[];
+}

package/vendor/llmswitch-core/dist/conversion/responses/responses-openai-bridge/types.js

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

package/vendor/llmswitch-core/dist/conversion/responses/responses-openai-bridge.d.ts

@@ -0,0 +1,15 @@
+import type { BridgeInputBuildResult } from '../bridge-message-utils.js';
+import type { BuildChatRequestResult, BuildResponsesRequestResult, ResponsesRequestContext } from './responses-openai-bridge/types.js';
+export type { BuildChatRequestResult, BuildResponsesRequestResult, ResponsesRequestContext } from './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;
+export declare function buildResponsesRequestFromChat(payload: Record<string, unknown>, ctx?: ResponsesRequestContext, extras?: {
+    bridgeHistory?: BridgeInputBuildResult;
+    systemInstruction?: string;
+}): BuildResponsesRequestResult;
+export { buildResponsesPayloadFromChat, extractRequestIdFromResponse } from './responses-openai-bridge/response-payload.js';
+export { buildChatResponseFromResponses } from '../shared/responses-response-utils.js';