@jsonstudio/llms 0.6.1397 → 0.6.1402

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

@@ -1,366 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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>;