@jsonstudio/llms 0.6.1172 → 0.6.1397

package/dist/conversion/hub/pipeline/hub-pipeline/execute-chat-process-entry.js

@@ -0,0 +1,366 @@
+import { jsonClone } from '../../types/json.js';
+import { ensureRuntimeMetadata, readRuntimeMetadata } from '../../../shared/runtime-metadata.js';
+import { computeRequestTokens } from '../../../../router/virtual-router/token-estimator.js';
+import { recordHubPolicyObservation, applyHubProviderOutboundPolicy } from '../../policy/policy-engine.js';
+import { applyProviderOutboundToolSurface } from '../../tool-surface/tool-surface-engine.js';
+import { extractSessionIdentifiersFromMetadata } from '../session-identifiers.js';
+import { runReqProcessStage1ToolGovernance } from '../stages/req_process/req_process_stage1_tool_governance/index.js';
+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';
+import { buildAdapterContext, maybeCreateStageRecorder, resolveOutboundStreamIntent, applyOutboundStreamPreference } from './adapter-context.js';
+import { assertNoMappableSemanticsInMetadata } from './semantic-gate.js';
+import { convertProcessNodeResult } from './node-results.js';
+import { injectServerToolRuntimeConfig } from './servertool-runtime-config.js';
+function asJsonObject(value) {
+    if (!value || typeof value !== 'object') {
+        throw new Error('Responses pipeline requires JSON object payload');
+    }
+    return value;
+}
+function readResponsesResumeFromSemantics(request) {
+    try {
+        const semantics = request?.semantics;
+        const node = semantics && typeof semantics === 'object' && !Array.isArray(semantics) ? semantics.responses : undefined;
+        const resume = node && typeof node === 'object' && !Array.isArray(node) ? node.resume : undefined;
+        return resume && typeof resume === 'object' && !Array.isArray(resume) ? resume : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function coerceStandardizedRequestFromPayload(payload, normalized) {
+    const model = typeof payload.model === 'string' && payload.model.trim().length ? payload.model.trim() : '';
+    if (!model) {
+        throw new Error('[HubPipeline] outbound stage requires payload.model');
+    }
+    const messages = Array.isArray(payload.messages) ? payload.messages : null;
+    if (!messages) {
+        throw new Error('[HubPipeline] outbound stage requires payload.messages[]');
+    }
+    const tools = Array.isArray(payload.tools) ? payload.tools : undefined;
+    const parameters = payload.parameters && typeof payload.parameters === 'object' && !Array.isArray(payload.parameters)
+        ? payload.parameters
+        : {};
+    const semanticsFromPayload = payload.semantics && typeof payload.semantics === 'object' && !Array.isArray(payload.semantics)
+        ? jsonClone(payload.semantics)
+        : undefined;
+    const metadataFromPayload = payload.metadata && typeof payload.metadata === 'object' && !Array.isArray(payload.metadata)
+        ? payload.metadata
+        : undefined;
+    const standardizedRequest = {
+        model,
+        messages,
+        ...(tools ? { tools } : {}),
+        parameters,
+        metadata: {
+            originalEndpoint: normalized.entryEndpoint,
+            ...(metadataFromPayload ? metadataFromPayload : {}),
+            requestId: normalized.id,
+            stream: normalized.stream,
+            processMode: normalized.processMode,
+            ...(normalized.routeHint ? { routeHint: normalized.routeHint } : {})
+        },
+        ...(semanticsFromPayload ? { semantics: semanticsFromPayload } : {})
+    };
+    // Ensure followup/chat_process entry can still preserve mappable semantics
+    // without injecting them into metadata.
+    try {
+        const semantics = standardizedRequest.semantics && typeof standardizedRequest.semantics === 'object'
+            ? standardizedRequest.semantics
+            : (standardizedRequest.semantics = {});
+        if (!semantics.tools || typeof semantics.tools !== 'object' || Array.isArray(semantics.tools)) {
+            semantics.tools = {};
+        }
+        const toolsNode = semantics.tools;
+        if (Array.isArray(payload.tools) && payload.tools.length && toolsNode.clientToolsRaw === undefined) {
+            toolsNode.clientToolsRaw = jsonClone(payload.tools);
+        }
+    }
+    catch {
+        // best-effort
+    }
+    const rawPayload = {
+        model,
+        messages,
+        ...(tools ? { tools } : {}),
+        ...(parameters && Object.keys(parameters).length ? { parameters } : {})
+    };
+    return { standardizedRequest, rawPayload };
+}
+export async function executeChatProcessEntryPipeline(options) {
+    const { config, routerEngine, normalized } = options;
+    const hooks = options.resolveProtocolHooks(normalized.providerProtocol);
+    if (!hooks) {
+        throw new Error(`Unsupported provider protocol for hub pipeline: ${normalized.providerProtocol}`);
+    }
+    const nodeResults = [];
+    nodeResults.push({
+        id: 'req_inbound',
+        success: true,
+        metadata: {
+            node: 'req_inbound',
+            skipped: true,
+            reason: 'stage=outbound',
+            dataProcessed: {}
+        }
+    });
+    const rawPayloadInput = asJsonObject(normalized.payload);
+    const { standardizedRequest: standardizedRequestBase, rawPayload } = coerceStandardizedRequestFromPayload(rawPayloadInput, normalized);
+    const metaBase = {
+        ...(normalized.metadata ?? {})
+    };
+    injectServerToolRuntimeConfig(config, metaBase);
+    normalized.metadata = metaBase;
+    const standardizedRequest = standardizedRequestBase;
+    try {
+        const resumeMeta = metaBase && typeof metaBase.responsesResume === 'object' && metaBase.responsesResume
+            ? metaBase.responsesResume
+            : undefined;
+        if (resumeMeta) {
+            standardizedRequest.semantics = standardizedRequest.semantics ?? {};
+            const semantics = standardizedRequest.semantics;
+            if (!semantics.responses || typeof semantics.responses !== 'object' || Array.isArray(semantics.responses)) {
+                semantics.responses = {};
+            }
+            const responsesNode = semantics.responses;
+            if (responsesNode.resume === undefined) {
+                responsesNode.resume = jsonClone(resumeMeta);
+            }
+            delete metaBase.responsesResume;
+        }
+    }
+    catch {
+        // best-effort
+    }
+    try {
+        const rt = readRuntimeMetadata(metaBase);
+        const mode = String(rt?.applyPatchToolMode || '').trim().toLowerCase();
+        if (mode === 'freeform' || mode === 'schema') {
+            standardizedRequest.metadata.applyPatchToolMode = mode;
+        }
+    }
+    catch {
+        // ignore
+    }
+    const adapterContext = buildAdapterContext(normalized);
+    const stageRecorder = maybeCreateStageRecorder(adapterContext, normalized.entryEndpoint, {
+        disableSnapshots: normalized.disableSnapshots === true
+    });
+    let processedRequest;
+    if (normalized.processMode !== 'passthrough') {
+        assertNoMappableSemanticsInMetadata(metaBase, 'chat_process.request.entry');
+        const processResult = await runReqProcessStage1ToolGovernance({
+            request: standardizedRequest,
+            rawPayload,
+            metadata: metaBase,
+            entryEndpoint: normalized.entryEndpoint,
+            requestId: normalized.id,
+            stageRecorder
+        });
+        processedRequest = processResult.processedRequest;
+        try {
+            const reservation = processedRequest?.metadata?.__clockReservation;
+            if (reservation && typeof reservation === 'object') {
+                metaBase.__clockReservation = reservation;
+            }
+        }
+        catch {
+            // best-effort
+        }
+        if (processResult.nodeResult) {
+            nodeResults.push(convertProcessNodeResult('chat_process.req.stage4.tool_governance', processResult.nodeResult));
+        }
+    }
+    let workingRequest = processedRequest ?? standardizedRequest;
+    try {
+        const estimatedTokens = computeRequestTokens(workingRequest, '');
+        if (typeof estimatedTokens === 'number' && Number.isFinite(estimatedTokens) && estimatedTokens > 0) {
+            normalized.metadata = normalized.metadata || {};
+            normalized.metadata.estimatedInputTokens = estimatedTokens;
+        }
+    }
+    catch {
+        // ignore
+    }
+    const normalizedMeta = normalized.metadata;
+    const responsesResume = readResponsesResumeFromSemantics(workingRequest);
+    const stdMetadata = workingRequest?.metadata;
+    const hasImageAttachment = (stdMetadata?.hasImageAttachment === true || stdMetadata?.hasImageAttachment === 'true') ||
+        (normalizedMeta?.hasImageAttachment === true || normalizedMeta?.hasImageAttachment === 'true');
+    const serverToolRequired = stdMetadata?.webSearchEnabled === true || stdMetadata?.serverToolRequired === true;
+    const sessionIdentifiers = extractSessionIdentifiersFromMetadata(normalized.metadata);
+    if (sessionIdentifiers.sessionId && normalized.metadata && typeof normalized.metadata === 'object') {
+        normalized.metadata.sessionId = sessionIdentifiers.sessionId;
+    }
+    if (sessionIdentifiers.conversationId && normalized.metadata && typeof normalized.metadata === 'object') {
+        normalized.metadata.conversationId = sessionIdentifiers.conversationId;
+    }
+    const disableStickyRoutes = readRuntimeMetadata(normalized.metadata)?.disableStickyRoutes === true;
+    const shadowCompareForcedProviderKey = normalizedMeta && typeof normalizedMeta.__shadowCompareForcedProviderKey === 'string'
+        ? String(normalizedMeta.__shadowCompareForcedProviderKey)
+        : '';
+    const disabledProviderKeyAliases = normalizedMeta && Array.isArray(normalizedMeta.disabledProviderKeyAliases)
+        ? normalizedMeta.disabledProviderKeyAliases
+        : null;
+    const metadataInput = {
+        requestId: normalized.id,
+        entryEndpoint: normalized.entryEndpoint,
+        processMode: normalized.processMode,
+        stream: normalized.stream,
+        direction: normalized.direction,
+        providerProtocol: normalized.providerProtocol,
+        routeHint: normalized.routeHint,
+        stage: normalized.stage,
+        responsesResume: responsesResume,
+        ...(disableStickyRoutes ? { disableStickyRoutes: true } : {}),
+        ...(serverToolRequired ? { serverToolRequired: true } : {}),
+        ...(sessionIdentifiers.sessionId ? { sessionId: sessionIdentifiers.sessionId } : {}),
+        ...(sessionIdentifiers.conversationId ? { conversationId: sessionIdentifiers.conversationId } : {}),
+        ...(shadowCompareForcedProviderKey.trim().length
+            ? { __shadowCompareForcedProviderKey: shadowCompareForcedProviderKey.trim() }
+            : {}),
+        ...(disabledProviderKeyAliases && disabledProviderKeyAliases.length
+            ? { disabledProviderKeyAliases: disabledProviderKeyAliases }
+            : {})
+    };
+    const routing = runReqProcessStage2RouteSelect({
+        routerEngine,
+        request: workingRequest,
+        metadataInput,
+        normalizedMetadata: normalized.metadata,
+        stageRecorder
+    });
+    const stopMessageState = routerEngine.getStopMessageState(metadataInput);
+    if (stopMessageState && normalized.metadata && typeof normalized.metadata === 'object') {
+        const rt = ensureRuntimeMetadata(normalized.metadata);
+        rt.stopMessageState = stopMessageState;
+    }
+    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 {
+        // ignore
+    }
+    const outboundStream = resolveOutboundStreamIntent(routing.target?.streaming);
+    workingRequest = applyOutboundStreamPreference(workingRequest, outboundStream);
+    const outboundAdapterContext = 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 ? options.resolveProtocolHooks(outboundProtocol) : hooks;
+    if (!outboundHooks) {
+        throw new Error(`[HubPipeline] Unsupported provider protocol for hub pipeline: ${outboundProtocol}`);
+    }
+    const outboundSemanticMapper = protocolSwitch ? outboundHooks.createSemanticMapper() : hooks.createSemanticMapper();
+    const outboundFormatAdapter = protocolSwitch ? outboundHooks.createFormatAdapter() : hooks.createFormatAdapter();
+    const outboundContextMetadataKey = protocolSwitch ? outboundHooks.contextMetadataKey : hooks.contextMetadataKey;
+    const outboundContextSnapshot = undefined;
+    const outboundRecorder = maybeCreateStageRecorder(outboundAdapterContext, normalized.entryEndpoint, {
+        disableSnapshots: normalized.disableSnapshots === true
+    });
+    const outboundStart = Date.now();
+    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
+    });
+    const effectivePolicy = normalized.policyOverride ?? config.policy;
+    recordHubPolicyObservation({
+        policy: effectivePolicy,
+        providerProtocol: outboundProtocol,
+        payload: formattedPayload,
+        stageRecorder: outboundRecorder,
+        requestId: normalized.id
+    });
+    let providerPayload = applyHubProviderOutboundPolicy({
+        policy: effectivePolicy,
+        providerProtocol: outboundProtocol,
+        payload: formattedPayload,
+        stageRecorder: outboundRecorder,
+        requestId: normalized.id
+    });
+    providerPayload = applyProviderOutboundToolSurface({
+        config: config.toolSurface,
+        providerProtocol: outboundProtocol,
+        payload: providerPayload,
+        stageRecorder: outboundRecorder,
+        requestId: normalized.id
+    });
+    recordHubPolicyObservation({
+        policy: effectivePolicy,
+        providerProtocol: outboundProtocol,
+        payload: providerPayload,
+        stageRecorder: outboundRecorder,
+        requestId: normalized.id
+    });
+    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 capturedChatRequest = {
+        model: workingRequest.model,
+        messages: jsonClone(workingRequest.messages),
+        tools: workingRequest.tools ? jsonClone(workingRequest.tools) : workingRequest.tools,
+        parameters: workingRequest.parameters
+            ? jsonClone(workingRequest.parameters)
+            : workingRequest.parameters
+    };
+    const metadata = {
+        ...normalized.metadata,
+        ...(hasImageAttachment ? { hasImageAttachment: true } : {}),
+        capturedChatRequest,
+        entryEndpoint: normalized.entryEndpoint,
+        providerProtocol: outboundProtocol,
+        stream: normalized.stream,
+        processMode: normalized.processMode,
+        routeHint: normalized.routeHint,
+        target: routing.target,
+        ...(typeof outboundStream === 'boolean' ? { providerStream: outboundStream } : {})
+    };
+    return {
+        requestId: normalized.id,
+        providerPayload,
+        standardizedRequest,
+        processedRequest,
+        routingDecision: routing.decision,
+        routingDiagnostics: routing.diagnostics,
+        target: routing.target,
+        metadata,
+        nodeResults
+    };
+}

package/dist/conversion/hub/pipeline/hub-pipeline/execute-request-stage.d.ts

@@ -0,0 +1,9 @@
+import type { VirtualRouterEngine } from '../../../../router/virtual-router/engine.js';
+import type { HubPipelineConfig, HubPipelineResult, NormalizedRequest, ProviderProtocol, RequestStageHooks } from './types.js';
+export declare function executeRequestStagePipeline<TContext = Record<string, unknown>>(options: {
+    config: HubPipelineConfig;
+    routerEngine: VirtualRouterEngine;
+    normalized: NormalizedRequest;
+    hooks: RequestStageHooks<TContext>;
+    resolveProtocolHooks: (protocol: ProviderProtocol) => RequestStageHooks<Record<string, unknown>> | undefined;
+}): Promise<HubPipelineResult>;