@jsonstudio/rcc 0.90.364 → 0.90.429

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

@@ -1,529 +0,0 @@
-import { recordStage } from '../pipeline/stages/utils.js';
-import { recordHubPolicyObservation } from '../policy/policy-engine.js';
-import { ChatFormatAdapter } from '../format-adapters/chat-format-adapter.js';
-import { ResponsesFormatAdapter } from '../format-adapters/responses-format-adapter.js';
-import { AnthropicFormatAdapter } from '../format-adapters/anthropic-format-adapter.js';
-import { GeminiFormatAdapter } from '../format-adapters/gemini-format-adapter.js';
-import { OpenAIChatResponseMapper, ResponsesResponseMapper, AnthropicResponseMapper, GeminiResponseMapper } from './response-mappers.js';
-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 { runRespProcessStage3ServerToolOrchestration } from '../pipeline/stages/resp_process/resp_process_stage3_servertool_orchestration/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 { measureHubStage } from '../pipeline/hub-stage-timing.js';
-import { recordResponsesResponse } from '../../shared/responses-conversation-store.js';
-import { ProviderProtocolError } from '../../provider-protocol-error.js';
-import { readRuntimeMetadata } from '../../runtime-metadata.js';
-import { commitClockReservation, resolveClockConfig } from '../../../servertool/clock/task-store.js';
-import { detectProviderResponseShapeWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-servertool-orchestration-semantics.js';
-import { saveChatProcessSessionActualUsage } from '../process/chat-process-session-usage.js';
-const PROVIDER_RESPONSE_REGISTRY = {
-    'openai-chat': {
-        createFormatAdapter: () => new ChatFormatAdapter(),
-        createMapper: () => new OpenAIChatResponseMapper()
-    },
-    'openai-responses': {
-        createFormatAdapter: () => new ResponsesFormatAdapter(),
-        createMapper: () => new ResponsesResponseMapper()
-    },
-    'anthropic-messages': {
-        createFormatAdapter: () => new AnthropicFormatAdapter(),
-        createMapper: () => new AnthropicResponseMapper()
-    },
-    'gemini-chat': {
-        createFormatAdapter: () => new GeminiFormatAdapter(),
-        createMapper: () => new GeminiResponseMapper()
-    }
-};
-function isServerToolFollowup(context) {
-    const rt = readRuntimeMetadata(context);
-    const raw = rt?.serverToolFollowup;
-    if (raw === true) {
-        return true;
-    }
-    if (typeof raw === 'string') {
-        const v = raw.trim().toLowerCase();
-        return v === '1' || v === 'true';
-    }
-    return false;
-}
-function resolveClientProtocol(entryEndpoint) {
-    const lowered = (entryEndpoint || '').toLowerCase();
-    if (lowered.includes('/v1/responses'))
-        return 'openai-responses';
-    if (lowered.includes('/v1/messages'))
-        return 'anthropic-messages';
-    return 'openai-chat';
-}
-function isToolSurfaceShadowEnabled() {
-    const raw = String(process.env.ROUTECODEX_HUB_TOOL_SURFACE_MODE || '').trim().toLowerCase();
-    if (!raw)
-        return false;
-    if (raw === 'off' || raw === '0' || raw === 'false')
-        return false;
-    return raw === 'observe' || raw === 'shadow' || raw === 'enforce';
-}
-function isJsonRecord(value) {
-    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
-}
-function coerceClockReservation(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
-        return null;
-    }
-    const rec = value;
-    const reservationId = typeof rec.reservationId === 'string' ? rec.reservationId.trim() : '';
-    const sessionId = typeof rec.sessionId === 'string' ? rec.sessionId.trim() : '';
-    const taskIdsRaw = Array.isArray(rec.taskIds) ? rec.taskIds : [];
-    const taskIds = taskIdsRaw
-        .filter((t) => typeof t === 'string' && t.trim().length)
-        .map((t) => String(t).trim());
-    const reservedAtMs = typeof rec.reservedAtMs === 'number' && Number.isFinite(rec.reservedAtMs)
-        ? Math.floor(rec.reservedAtMs)
-        : Date.now();
-    if (!reservationId || !sessionId || taskIds.length === 0) {
-        return null;
-    }
-    return { reservationId, sessionId, taskIds, reservedAtMs };
-}
-async function maybeCommitClockReservationFromContext(context) {
-    try {
-        const rt = readRuntimeMetadata(context);
-        const clockConfig = resolveClockConfig(rt?.clock);
-        if (!clockConfig) {
-            return;
-        }
-        const reservation = coerceClockReservation(context.__clockReservation);
-        if (!reservation) {
-            return;
-        }
-        await commitClockReservation(reservation, clockConfig);
-    }
-    catch {
-        // best-effort: never break response conversion due to clock persistence errors
-    }
-}
-function inferProviderTypeFromProtocol(protocol) {
-    const p = typeof protocol === 'string' ? protocol.trim().toLowerCase() : '';
-    if (!p)
-        return undefined;
-    if (p === 'openai-chat')
-        return 'openai';
-    if (p === 'openai-responses')
-        return 'responses';
-    if (p === 'anthropic-messages')
-        return 'anthropic';
-    if (p === 'gemini-chat')
-        return 'gemini';
-    return undefined;
-}
-function isCanonicalChatCompletion(payload) {
-    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
-        return false;
-    }
-    const obj = payload;
-    const choices = Array.isArray(obj.choices) ? obj.choices : [];
-    if (!choices.length)
-        return false;
-    const first = choices[0] && typeof choices[0] === 'object' && !Array.isArray(choices[0]) ? choices[0] : null;
-    if (!first)
-        return false;
-    const msg = first.message;
-    return Boolean(msg && typeof msg === 'object' && !Array.isArray(msg));
-}
-async function coerceClientPayloadToCanonicalChatCompletionOrThrow(options) {
-    if (isCanonicalChatCompletion(options.payload)) {
-        return options.payload;
-    }
-    const detected = detectProviderResponseShapeWithNative(options.payload);
-    if (detected === 'unknown') {
-        const protocol = options.adapterContext?.providerProtocol;
-        throw new ProviderProtocolError(`[hub_response] Non-canonical response payload at ${options.scope}`, {
-            code: 'MALFORMED_RESPONSE',
-            protocol,
-            providerType: inferProviderTypeFromProtocol(protocol),
-            details: {
-                detected,
-                payloadType: typeof options.payload,
-                payloadKeys: options.payload && typeof options.payload === 'object' && !Array.isArray(options.payload)
-                    ? Object.keys(options.payload).slice(0, 20)
-                    : undefined
-            }
-        });
-    }
-    const plan = PROVIDER_RESPONSE_REGISTRY[detected];
-    const mapper = plan.createMapper();
-    const coerced = await mapper.toChatCompletion({ payload: options.payload }, options.adapterContext, { requestSemantics: options.requestSemantics });
-    if (isCanonicalChatCompletion(coerced)) {
-        return coerced;
-    }
-    const protocol = options.adapterContext?.providerProtocol;
-    throw new ProviderProtocolError(`[hub_response] Failed to canonicalize response payload at ${options.scope}`, {
-        code: 'MALFORMED_RESPONSE',
-        protocol,
-        providerType: inferProviderTypeFromProtocol(protocol),
-        details: { detected }
-    });
-}
-function summarizeToolCallsFromProviderResponse(payload) {
-    try {
-        if (!isJsonRecord(payload))
-            return {};
-        const obj = payload;
-        // openai-chat
-        if (Array.isArray(obj.choices)) {
-            const msg = obj.choices?.[0]?.message;
-            const tcs = Array.isArray(msg?.tool_calls) ? msg.tool_calls : [];
-            const names = tcs
-                .map((tc) => String(tc?.function?.name || '').trim())
-                .filter((s) => s.length)
-                .slice(0, 10);
-            return { toolCallCount: tcs.length, toolNames: names.length ? names : undefined };
-        }
-        // openai-responses
-        if (Array.isArray(obj.output)) {
-            const out = obj.output;
-            const fnCalls = out.filter((it) => it && typeof it === 'object' && String(it.type || '').toLowerCase() === 'function_call');
-            const names = fnCalls
-                .map((it) => String(it?.name || '').trim())
-                .filter((s) => s.length)
-                .slice(0, 10);
-            return { toolCallCount: fnCalls.length, toolNames: names.length ? names : undefined };
-        }
-        // anthropic-messages
-        if (Array.isArray(obj.content)) {
-            const blocks = obj.content;
-            const uses = blocks.filter((b) => b && typeof b === 'object' && String(b.type || '').toLowerCase() === 'tool_use');
-            const names = uses
-                .map((b) => String(b?.name || '').trim())
-                .filter((s) => s.length)
-                .slice(0, 10);
-            return { toolCallCount: uses.length, toolNames: names.length ? names : undefined };
-        }
-        return {};
-    }
-    catch {
-        return {};
-    }
-}
-function stripInternalPolicyDebugFields(payload) {
-    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
-        return;
-    }
-    const target = payload;
-    // These are internal debug/transport markers that must not leak across hub boundaries.
-    // They also break hub policy allowlists (Phase 0/1 observation) and confuse tool-surface detection.
-    delete target._transformed;
-    delete target._originalFormat;
-    delete target._targetFormat;
-    delete target.__responses_output_text_meta;
-    delete target.__responses_reasoning;
-    delete target.__responses_payload_snapshot;
-    delete target.__responses_passthrough;
-    delete target.anthropicToolNameMap;
-}
-function supportsSseProtocol(protocol) {
-    return protocol === 'openai-chat' || protocol === 'openai-responses' || protocol === 'anthropic-messages' || protocol === 'gemini-chat';
-}
-function extractDisplayModel(context) {
-    const candidates = [
-        context.originalModelId,
-        context.clientModelId,
-        context.modelId
-    ];
-    for (const candidate of candidates) {
-        if (typeof candidate === 'string' && candidate.trim()) {
-            return candidate.trim();
-        }
-    }
-    return undefined;
-}
-function extractClientFacingRequestId(context) {
-    const contextAny = context;
-    const candidates = [contextAny.clientRequestId, contextAny.groupRequestId, context.requestId];
-    for (const candidate of candidates) {
-        if (typeof candidate === 'string' && candidate.trim()) {
-            return candidate.trim();
-        }
-    }
-    return undefined;
-}
-function applyModelOverride(payload, model) {
-    if (!model || !payload || typeof payload !== 'object') {
-        return;
-    }
-    try {
-        payload.model = model;
-    }
-    catch {
-        /* ignore */
-    }
-}
-function resolveChatReasoningMode(entryEndpoint) {
-    const lowered = (entryEndpoint || '').toLowerCase();
-    if (lowered.includes('/v1/chat/completions')) {
-        return 'keep';
-    }
-    return 'keep';
-}
-export async function convertProviderResponse(options) {
-    const requestId = options.context.requestId || 'unknown';
-    const isFollowup = isServerToolFollowup(options.context);
-    // ServerTool followups are internal hops. They must return canonical OpenAI-chat-like payloads
-    // to re-enter the hub chat process deterministically (tools harvesting, governance, etc.).
-    // Client protocol remapping happens only on the outermost request.
-    const clientProtocol = isFollowup ? 'openai-chat' : resolveClientProtocol(options.entryEndpoint);
-    // 对于由 server-side 工具触发的内部跳转（二跳/三跳），统一禁用 SSE 聚合输出，
-    // 始终返回完整的 ChatCompletion JSON，便于在 llms 内部直接解析，而不是拿到
-    // __sse_responses 可读流。
-    const wantsStream = isFollowup ? false : options.wantsStream;
-    const displayModel = extractDisplayModel(options.context);
-    const clientFacingRequestId = extractClientFacingRequestId(options.context) ?? options.context.requestId;
-    const plan = PROVIDER_RESPONSE_REGISTRY[options.providerProtocol];
-    if (!plan) {
-        throw new Error(`Unknown provider protocol: ${options.providerProtocol}`);
-    }
-    const inboundStage1 = await measureHubStage(requestId, 'resp_inbound.stage1_sse_decode', () => runRespInboundStage1SseDecode({
-        providerProtocol: options.providerProtocol,
-        payload: options.providerResponse,
-        adapterContext: options.context,
-        wantsStream,
-        stageRecorder: options.stageRecorder
-    }), {
-        mapCompletedDetails: (value) => ({
-            decodedFromSse: value.decodedFromSse,
-            wantsStream,
-            providerProtocol: options.providerProtocol
-        })
-    });
-    // Hard order guarantee: provider -> compat -> inbound(parse/map) -> chat_process -> outbound -> client.
-    // Transport-level SSE decode stays before compat to materialize a JSON provider payload.
-    const compatPayload = await measureHubStage(requestId, 'resp_inbound.stage1_compat', () => runRespInboundStageCompatResponse({
-        payload: inboundStage1.payload,
-        adapterContext: options.context,
-        stageRecorder: options.stageRecorder
-    }), {
-        mapCompletedDetails: () => ({
-            providerProtocol: options.providerProtocol
-        })
-    });
-    stripInternalPolicyDebugFields(compatPayload);
-    const mapper = plan.createMapper();
-    const formatEnvelope = await measureHubStage(requestId, 'resp_inbound.stage2_format_parse', () => runRespInboundStage2FormatParse({
-        adapterContext: options.context,
-        payload: compatPayload,
-        stageRecorder: options.stageRecorder
-    }), {
-        mapCompletedDetails: (value) => ({
-            protocol: value.protocol,
-            direction: value.direction,
-            providerProtocol: options.providerProtocol
-        })
-    });
-    // Phase 2 (shadow): response tool surface mismatch detection (provider inbound).
-    // Only records diffs; does not rewrite payload.
-    try {
-        if (options.stageRecorder && isToolSurfaceShadowEnabled()) {
-            const detected = detectProviderResponseShapeWithNative(formatEnvelope.payload);
-            if (detected !== 'unknown' && detected !== options.providerProtocol) {
-                const summary = summarizeToolCallsFromProviderResponse(formatEnvelope.payload);
-                options.stageRecorder.record('hub_toolsurface.shadow.provider_inbound', {
-                    kind: 'provider_inbound',
-                    expectedProtocol: options.providerProtocol,
-                    detectedProtocol: detected,
-                    ...(summary.toolCallCount !== undefined ? { toolCallCount: summary.toolCallCount } : {}),
-                    ...(summary.toolNames ? { toolNames: summary.toolNames } : {})
-                });
-            }
-        }
-    }
-    catch {
-        // never break response conversion
-    }
-    // Phase 0/1: observe provider inbound payload violations (best-effort; no rewrites here).
-    try {
-        if (formatEnvelope.payload && typeof formatEnvelope.payload === 'object' && !Array.isArray(formatEnvelope.payload)) {
-            recordHubPolicyObservation({
-                phase: 'provider_inbound',
-                providerProtocol: options.providerProtocol,
-                payload: formatEnvelope.payload,
-                stageRecorder: options.stageRecorder,
-                requestId: options.context.requestId
-            });
-        }
-    }
-    catch {
-        // never break response conversion
-    }
-    const chatResponse = await measureHubStage(requestId, 'resp_inbound.stage3_semantic_map', () => runRespInboundStage3SemanticMap({
-        adapterContext: options.context,
-        formatEnvelope,
-        mapper,
-        requestSemantics: options.requestSemantics,
-        stageRecorder: options.stageRecorder
-    }), {
-        mapCompletedDetails: (value) => ({
-            hasChoices: Array.isArray(value?.choices),
-            providerProtocol: options.providerProtocol
-        })
-    });
-    // 记录语义映射后的 ChatCompletion，便于回放 server-side 工具流程。
-    recordStage(options.stageRecorder, 'chat_process.resp.stage4.semantic_map_to_chat.chat', chatResponse);
-    // 检查是否需要进行 ServerTool 编排
-    // 使用新的 ChatEnvelope 级别的 servertool 实现
-    const orchestration = await measureHubStage(requestId, 'resp_process.stage3_servertool_orchestration', () => runRespProcessStage3ServerToolOrchestration({
-        payload: chatResponse,
-        adapterContext: options.context,
-        requestId: options.context.requestId,
-        entryEndpoint: options.entryEndpoint,
-        providerProtocol: options.providerProtocol,
-        stageRecorder: options.stageRecorder,
-        providerInvoker: options.providerInvoker,
-        reenterPipeline: options.reenterPipeline,
-        clientInjectDispatch: options.clientInjectDispatch
-    }), {
-        mapCompletedDetails: (value) => ({
-            executed: value.executed,
-            flowId: value.flowId,
-            skipReason: value.skipReason
-        })
-    });
-    let effectiveChatResponse = orchestration.payload;
-    // Hard gate: response-side chat_process requires an OpenAI-chat-like surface (choices[].message).
-    // ServerTool followups must never replace the canonical chat completion with a client-protocol shape.
-    effectiveChatResponse = await coerceClientPayloadToCanonicalChatCompletionOrThrow({
-        payload: effectiveChatResponse,
-        adapterContext: options.context,
-        requestSemantics: options.requestSemantics,
-        scope: 'chat_process.response.entry'
-    });
-    // 如果没有执行 servertool，继续原来的处理流程
-    const governanceResult = await measureHubStage(requestId, 'resp_process.stage1_tool_governance', () => runRespProcessStage1ToolGovernance({
-        payload: effectiveChatResponse,
-        entryEndpoint: options.entryEndpoint,
-        requestId: options.context.requestId,
-        clientProtocol,
-        stageRecorder: options.stageRecorder
-    }), {
-        mapCompletedDetails: (value) => ({
-            clientProtocol,
-            hasPayload: Boolean(value.governedPayload)
-        })
-    });
-    const finalizeResult = await measureHubStage(requestId, 'resp_process.stage2_finalize', () => runRespProcessStage2Finalize({
-        payload: governanceResult.governedPayload,
-        originalPayload: effectiveChatResponse,
-        skipServerToolStrip: isFollowup,
-        entryEndpoint: options.entryEndpoint,
-        requestId: options.context.requestId,
-        wantsStream,
-        reasoningMode: resolveChatReasoningMode(options.entryEndpoint),
-        stageRecorder: options.stageRecorder
-    }), {
-        mapCompletedDetails: (value) => ({
-            wantsStream,
-            hasProcessedRequest: Boolean(value.processedRequest),
-            model: typeof value.finalizedPayload?.model === 'string' ? value.finalizedPayload.model : undefined
-        })
-    });
-    applyModelOverride(finalizeResult.finalizedPayload, displayModel);
-    const clientPayload = await measureHubStage(requestId, 'resp_outbound.stage1_client_remap', () => runRespOutboundStage1ClientRemap({
-        payload: finalizeResult.finalizedPayload,
-        clientProtocol,
-        requestId: clientFacingRequestId,
-        adapterContext: options.context,
-        requestSemantics: options.requestSemantics,
-        stageRecorder: options.stageRecorder
-    }), {
-        mapCompletedDetails: () => ({
-            clientProtocol
-        })
-    });
-    applyModelOverride(clientPayload, displayModel);
-    stripInternalPolicyDebugFields(clientPayload);
-    if (clientProtocol === 'openai-responses') {
-        try {
-            recordResponsesResponse({
-                requestId: options.context.requestId,
-                response: clientPayload
-            });
-        }
-        catch {
-            // ignore conversation capture errors
-        }
-    }
-    // Phase 2 (shadow): response tool surface mismatch detection (client outbound).
-    try {
-        if (options.stageRecorder && isToolSurfaceShadowEnabled()) {
-            const detected = detectProviderResponseShapeWithNative(clientPayload);
-            if (detected !== 'unknown' && detected !== clientProtocol) {
-                const summary = summarizeToolCallsFromProviderResponse(clientPayload);
-                options.stageRecorder.record('hub_toolsurface.shadow.client_outbound', {
-                    kind: 'client_outbound',
-                    expectedProtocol: clientProtocol,
-                    detectedProtocol: detected,
-                    ...(summary.toolCallCount !== undefined ? { toolCallCount: summary.toolCallCount } : {}),
-                    ...(summary.toolNames ? { toolNames: summary.toolNames } : {})
-                });
-            }
-        }
-    }
-    catch {
-        // never break response conversion
-    }
-    // Phase 0/1: observe client outbound payload violations (best-effort; no rewrites here).
-    try {
-        if (clientPayload && typeof clientPayload === 'object' && !Array.isArray(clientPayload)) {
-            recordHubPolicyObservation({
-                phase: 'client_outbound',
-                providerProtocol: clientProtocol,
-                payload: clientPayload,
-                stageRecorder: options.stageRecorder,
-                requestId: options.context.requestId
-            });
-        }
-    }
-    catch {
-        // never break response conversion
-    }
-    const outbound = await measureHubStage(requestId, 'resp_outbound.stage2_sse_stream', () => runRespOutboundStage2SseStream({
-        clientPayload,
-        clientProtocol,
-        requestId: clientFacingRequestId,
-        wantsStream,
-        stageRecorder: options.stageRecorder
-    }), {
-        mapCompletedDetails: (value) => ({
-            wantsStream,
-            hasStream: Boolean(value.stream),
-            hasBody: Boolean(value.body)
-        })
-    });
-    // Commit scheduled-task delivery only after a successful client payload/stream is prepared.
-    await maybeCommitClockReservationFromContext(options.context);
-    try {
-        const usage = clientPayload && typeof clientPayload === 'object' && !Array.isArray(clientPayload)
-            ? clientPayload.usage
-            : undefined;
-        saveChatProcessSessionActualUsage({
-            context: options.context,
-            usage
-        });
-    }
-    catch {
-        // best-effort: usage persistence must not break response delivery
-    }
-    if (outbound.stream) {
-        const usage = clientPayload && typeof clientPayload === 'object' && !Array.isArray(clientPayload)
-            ? clientPayload.usage
-            : undefined;
-        const body = usage !== undefined
-            ? { usage }
-            : undefined;
-        return { __sse_responses: outbound.stream, body, format: clientProtocol };
-    }
-    return { body: clientPayload, format: clientProtocol };
-}

package/vendor/@jsonstudio/llms/dist/conversion/hub/response/response-mappers.d.ts

@@ -1,24 +0,0 @@
-import type { FormatEnvelope } from '../types/format-envelope.js';
-import type { AdapterContext } from '../types/chat-envelope.js';
-import type { JsonObject } from '../types/json.js';
-import type { ChatSemantics } from '../types/chat-envelope.js';
-export type ChatCompletionLike = JsonObject;
-export interface ResponseMapper {
-    toChatCompletion(format: FormatEnvelope, ctx: AdapterContext, options?: {
-        requestSemantics?: ChatSemantics | JsonObject;
-    }): Promise<ChatCompletionLike> | ChatCompletionLike;
-}
-export declare class OpenAIChatResponseMapper implements ResponseMapper {
-    toChatCompletion(format: FormatEnvelope, _ctx: AdapterContext): ChatCompletionLike;
-}
-export declare class ResponsesResponseMapper implements ResponseMapper {
-    toChatCompletion(format: FormatEnvelope, _ctx: AdapterContext): ChatCompletionLike;
-}
-export declare class AnthropicResponseMapper implements ResponseMapper {
-    toChatCompletion(format: FormatEnvelope, _ctx: AdapterContext, options?: {
-        requestSemantics?: ChatSemantics | JsonObject;
-    }): ChatCompletionLike;
-}
-export declare class GeminiResponseMapper implements ResponseMapper {
-    toChatCompletion(format: FormatEnvelope, _ctx: AdapterContext): ChatCompletionLike;
-}

package/vendor/@jsonstudio/llms/dist/conversion/hub/response/response-mappers.js

@@ -1,73 +0,0 @@
-import { buildOpenAIChatFromGeminiResponse } from '../../codecs/gemini-openai-codec.js';
-import { buildChatResponseFromResponses } from '../../shared/responses-response-utils.js';
-import { buildOpenAIChatFromAnthropicMessage } from './response-runtime.js';
-import { resolveAliasMapFromRespSemanticsWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
-function injectResponsesReasoningExtension(payload) {
-    const choices = Array.isArray(payload.choices) ? payload.choices : [];
-    const primary = choices[0] && typeof choices[0] === 'object' ? choices[0] : undefined;
-    const message = primary && typeof primary.message === 'object' ? primary.message : undefined;
-    if (!message)
-        return;
-    const extension = payload.__responses_reasoning;
-    if (extension && typeof extension === 'object' && !Array.isArray(extension)) {
-        const extContent = Array.isArray(extension.content)
-            ? extension.content
-                .map((entry) => {
-                if (!entry || typeof entry !== 'object' || Array.isArray(entry))
-                    return null;
-                const node = entry;
-                const text = typeof node.text === 'string' ? node.text.trim() : '';
-                if (!text.length)
-                    return null;
-                return { type: 'reasoning_text', text };
-            })
-                .filter((entry) => Boolean(entry))
-            : undefined;
-        const extEncrypted = typeof extension.encrypted_content === 'string'
-            ? String(extension.encrypted_content).trim()
-            : '';
-        if ((Array.isArray(extContent) && extContent.length) || extEncrypted.length) {
-            message.reasoning = {
-                ...(Array.isArray(extContent) && extContent.length ? { content: extContent } : {}),
-                ...(extEncrypted.length ? { encrypted_content: extEncrypted } : {})
-            };
-            if (!(message.reasoning_content && String(message.reasoning_content).trim().length) && Array.isArray(extContent) && extContent.length) {
-                message.reasoning_content = extContent.map((entry) => entry.text).join('\n');
-            }
-            return;
-        }
-    }
-    const reasoningText = typeof message.reasoning_content === 'string' && message.reasoning_content.trim().length
-        ? String(message.reasoning_content).trim()
-        : undefined;
-    if (!reasoningText)
-        return;
-    message.reasoning = {
-        content: [{ type: 'reasoning_text', text: reasoningText }]
-    };
-}
-export class OpenAIChatResponseMapper {
-    toChatCompletion(format, _ctx) {
-        const payload = (format.payload ?? {});
-        if (payload && typeof payload === 'object') {
-            injectResponsesReasoningExtension(payload);
-        }
-        return payload;
-    }
-}
-export class ResponsesResponseMapper {
-    toChatCompletion(format, _ctx) {
-        return buildChatResponseFromResponses(format.payload ?? {});
-    }
-}
-export class AnthropicResponseMapper {
-    toChatCompletion(format, _ctx, options) {
-        const aliasMap = resolveAliasMapFromRespSemanticsWithNative(options?.requestSemantics);
-        return buildOpenAIChatFromAnthropicMessage(format.payload ?? {}, { aliasMap });
-    }
-}
-export class GeminiResponseMapper {
-    toChatCompletion(format, _ctx) {
-        return buildOpenAIChatFromGeminiResponse(format.payload ?? {});
-    }
-}

package/vendor/@jsonstudio/llms/dist/conversion/hub/response/response-runtime.d.ts

@@ -1,9 +0,0 @@
-import type { JsonObject } from '../types/json.js';
-type ToolAliasMap = Record<string, string>;
-interface AnthropicResponseOptions {
-    aliasMap?: ToolAliasMap;
-    includeToolCallIds?: boolean;
-}
-export declare function buildOpenAIChatFromAnthropicMessage(payload: JsonObject, options?: AnthropicResponseOptions): JsonObject;
-export declare function buildAnthropicResponseFromChat(chatResponse: JsonObject, options?: AnthropicResponseOptions): JsonObject;
-export {};