@jsonstudio/llms 0.6.954 → 0.6.1164

package/dist/conversion/hub/pipeline/hub-pipeline.d.ts

@@ -4,6 +4,7 @@ import type { JsonObject } from '../types/json.js';
 import type { VirtualRouterConfig, RoutingDecision, RoutingDiagnostics, TargetMetadata, VirtualRouterHealthStore, ProviderQuotaView } from '../../../router/virtual-router/types.js';
 import { type HubProcessNodeResult } from '../process/chat-process.js';
 import { type HubPolicyConfig } from '../policy/policy-engine.js';
+import { type HubToolSurfaceConfig } from '../tool-surface/tool-surface-engine.js';
 export interface HubPipelineConfig {
     virtualRouter: VirtualRouterConfig;
     /**
@@ -11,6 +12,12 @@ export interface HubPipelineConfig {
      * Must remain config-driven and default to off.
      */
     policy?: HubPolicyConfig;
+    /**
+     * Optional: tool surface rollout controls.
+     * - shadow: compute & record diffs, do not modify outbound payload
+     * - enforce: rewrite outbound payload to match canonical tool surface
+     */
+    toolSurface?: HubToolSurfaceConfig;
     /**
      * 可选：供 VirtualRouterEngine 使用的健康状态持久化存储。
      * 当提供时，VirtualRouterEngine 将在初始化时恢复上一次快照，并在 cooldown/熔断变化时调用 persistSnapshot。
@@ -79,6 +86,8 @@ export declare class HubPipeline {
     dispose(): void;
     private executeRequestStagePipeline;
     private resolveClientProtocol;
+    private coerceStandardizedRequestFromPayload;
+    private executeChatProcessEntryPipeline;
     execute(request: HubPipelineRequest): Promise<HubPipelineResult>;
     private captureAnthropicAliasMap;
     private shouldCaptureAnthropicAlias;

package/dist/conversion/hub/pipeline/hub-pipeline.js

@@ -26,6 +26,54 @@ import { extractSessionIdentifiersFromMetadata } from './session-identifiers.js'
 import { computeRequestTokens } from '../../../router/virtual-router/token-estimator.js';
 import { isCompactionRequest } from '../../shared/compaction-detect.js';
 import { applyHubProviderOutboundPolicy, recordHubPolicyObservation, setHubPolicyRuntimePolicy } from '../policy/policy-engine.js';
+import { applyProviderOutboundToolSurface } from '../tool-surface/tool-surface-engine.js';
+import { applyHubOperations } from '../ops/operations.js';
+function isTruthyEnv(value) {
+    const v = typeof value === 'string' ? value.trim().toLowerCase() : '';
+    return v === '1' || v === 'true' || v === 'yes' || v === 'on';
+}
+function resolveApplyPatchToolModeFromEnv() {
+    const rawMode = String(process.env.RCC_APPLY_PATCH_TOOL_MODE || process.env.ROUTECODEX_APPLY_PATCH_TOOL_MODE || '')
+        .trim()
+        .toLowerCase();
+    if (rawMode === 'freeform')
+        return 'freeform';
+    if (rawMode === 'schema' || rawMode === 'json_schema')
+        return 'schema';
+    const freeformFlag = process.env.RCC_APPLY_PATCH_FREEFORM || process.env.ROUTECODEX_APPLY_PATCH_FREEFORM;
+    if (isTruthyEnv(freeformFlag))
+        return 'freeform';
+    return undefined;
+}
+function resolveApplyPatchToolModeFromTools(toolsRaw) {
+    if (!Array.isArray(toolsRaw) || toolsRaw.length === 0) {
+        return undefined;
+    }
+    for (const entry of toolsRaw) {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry))
+            continue;
+        const record = entry;
+        const type = typeof record.type === 'string' ? record.type.trim().toLowerCase() : '';
+        if (type && type !== 'function')
+            continue;
+        const fn = record.function && typeof record.function === 'object' && !Array.isArray(record.function)
+            ? record.function
+            : undefined;
+        const name = typeof fn?.name === 'string' ? fn.name.trim().toLowerCase() : '';
+        if (name !== 'apply_patch')
+            continue;
+        const format = typeof record.format === 'string'
+            ? record.format.trim().toLowerCase()
+            : typeof fn?.format === 'string'
+                ? String(fn.format).trim().toLowerCase()
+                : '';
+        if (format === 'freeform')
+            return 'freeform';
+        // If apply_patch is present without explicit freeform marker, default to schema mode.
+        return 'schema';
+    }
+    return undefined;
+}
 function extractHubPolicyOverride(metadata) {
     const raw = metadata ? metadata.__hubPolicyOverride : undefined;
     if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
@@ -42,6 +90,22 @@ function extractHubPolicyOverride(metadata) {
         ...(sampleRate !== undefined ? { sampleRate } : {})
     };
 }
+function extractHubShadowCompareConfig(metadata) {
+    const raw = metadata ? metadata.__hubShadowCompare : undefined;
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        return undefined;
+    }
+    const obj = raw;
+    const modeCandidate = typeof obj.baselineMode === 'string'
+        ? obj.baselineMode.trim().toLowerCase()
+        : typeof obj.mode === 'string'
+            ? obj.mode.trim().toLowerCase()
+            : '';
+    if (modeCandidate !== 'off' && modeCandidate !== 'observe' && modeCandidate !== 'enforce') {
+        return undefined;
+    }
+    return { baselineMode: modeCandidate };
+}
 export class HubPipeline {
     routerEngine;
     config;
@@ -120,6 +184,11 @@ export class HubPipeline {
         // not the governed/augmented tools.
         try {
             const toolsRaw = Array.isArray(rawRequest?.tools) ? rawRequest.tools : null;
+            const applyPatchToolMode = resolveApplyPatchToolModeFromEnv() ?? resolveApplyPatchToolModeFromTools(toolsRaw);
+            if (applyPatchToolMode) {
+                normalized.metadata = normalized.metadata || {};
+                normalized.metadata.applyPatchToolMode = applyPatchToolMode;
+            }
             if (toolsRaw && toolsRaw.length > 0) {
                 normalized.metadata = normalized.metadata || {};
                 normalized.metadata.clientToolsRaw = jsonClone(toolsRaw);
@@ -133,6 +202,7 @@ export class HubPipeline {
             normalized.metadata.compactionRequest = true;
         }
         const effectivePolicy = normalized.policyOverride ?? this.config.policy;
+        const shadowCompareBaselineMode = normalized.shadowCompare?.baselineMode;
         const inboundAdapterContext = this.buildAdapterContext(normalized);
         const inboundRecorder = this.maybeCreateStageRecorder(inboundAdapterContext, normalized.entryEndpoint, {
             disableSnapshots: normalized.disableSnapshots === true
@@ -166,6 +236,15 @@ export class HubPipeline {
             stageRecorder: inboundRecorder
         });
         const standardizedRequest = inboundStage2.standardizedRequest;
+        try {
+            const mode = String(normalized.metadata?.applyPatchToolMode || '').trim().toLowerCase();
+            if (mode === 'freeform' || mode === 'schema') {
+                standardizedRequest.metadata.applyPatchToolMode = mode;
+            }
+        }
+        catch {
+            // best-effort: do not block request handling due to metadata propagation failures
+        }
         const inboundEnd = Date.now();
         const nodeResults = [];
         nodeResults.push({
@@ -195,6 +274,10 @@ export class HubPipeline {
         if (execCommandGuard) {
             metaBase.execCommandGuard = execCommandGuard;
         }
+        const clockConfig = this.config.virtualRouter?.clock;
+        if (clockConfig) {
+            metaBase.clock = clockConfig;
+        }
         normalized.metadata = metaBase;
         let processedRequest;
         if (normalized.processMode !== 'passthrough') {
@@ -207,11 +290,22 @@ export class HubPipeline {
                 stageRecorder: inboundRecorder
             });
             processedRequest = processResult.processedRequest;
+            // Surface request-side clock reservation into pipeline metadata so response conversion
+            // can commit delivery only after a successful response is produced.
+            try {
+                const reservation = processedRequest?.metadata?.__clockReservation;
+                if (reservation && typeof reservation === 'object') {
+                    metaBase.__clockReservation = reservation;
+                }
+            }
+            catch {
+                // best-effort: do not block request handling due to metadata propagation failures
+            }
             if (processResult.nodeResult) {
                 nodeResults.push(this.convertProcessNodeResult('req_process_stage1_tool_governance', processResult.nodeResult));
             }
         }
-        const workingRequest = processedRequest ?? standardizedRequest;
+        let workingRequest = processedRequest ?? standardizedRequest;
         // 使用与 VirtualRouter 一致的 tiktoken 计数逻辑，对标准化请求进行一次
         // 上下文 token 估算，供后续 usage 归一化与统计使用。
         try {
@@ -267,6 +361,12 @@ export class HubPipeline {
         const stopMessageState = this.routerEngine.getStopMessageState(metadataInput);
         if (stopMessageState && normalized.metadata && typeof normalized.metadata === 'object') {
             normalized.metadata.stopMessageState = stopMessageState;
+            // Phase 4: model stopMessage as an operation-derived request metadata signal.
+            // Response-side servertools can read it from AdapterContext, while request-side
+            // diagnostics can read it from StandardizedRequest.metadata.
+            workingRequest = applyHubOperations(workingRequest, [
+                { op: 'set_request_metadata_fields', fields: { stopMessageState } }
+            ]);
         }
         // Emit virtual router hit log for debugging (orange [virtual-router] ...)
         try {
@@ -282,7 +382,7 @@ export class HubPipeline {
             // logging must not break routing
         }
         const outboundStream = this.resolveOutboundStreamIntent(routing.target?.streaming);
-        this.applyOutboundStreamPreference(workingRequest, outboundStream);
+        workingRequest = this.applyOutboundStreamPreference(workingRequest, outboundStream);
         const outboundAdapterContext = this.buildAdapterContext(normalized, routing.target);
         if (routing.target?.compatibilityProfile) {
             outboundAdapterContext.compatibilityProfile = routing.target.compatibilityProfile;
@@ -324,6 +424,43 @@ export class HubPipeline {
             adapterContext: outboundAdapterContext,
             stageRecorder: outboundRecorder
         });
+        let shadowBaselineProviderPayload;
+        if (shadowCompareBaselineMode) {
+            const baselinePolicy = {
+                ...(effectivePolicy ?? {}),
+                mode: shadowCompareBaselineMode
+            };
+            // Compute a baseline provider payload in the *same execution*, without recording
+            // snapshots/diffs and without re-running the full pipeline. This avoids side effects
+            // (conversation store, followup captures, etc.) that a second execute() would trigger.
+            const baselineFormatted = typeof globalThis.structuredClone === 'function'
+                ? globalThis.structuredClone(formattedPayload)
+                : jsonClone(formattedPayload);
+            let baselinePayload = applyHubProviderOutboundPolicy({
+                policy: baselinePolicy,
+                providerProtocol: outboundProtocol,
+                payload: baselineFormatted,
+                stageRecorder: undefined,
+                requestId: normalized.id
+            });
+            baselinePayload = applyProviderOutboundToolSurface({
+                config: this.config.toolSurface,
+                providerProtocol: outboundProtocol,
+                payload: baselinePayload,
+                stageRecorder: undefined,
+                requestId: normalized.id
+            });
+            shadowBaselineProviderPayload = baselinePayload;
+        }
+        // Phase 0/1: observe provider outbound payload violations before any enforcement rewrites.
+        // This provides black-box visibility into what the pipeline would have sent upstream.
+        recordHubPolicyObservation({
+            policy: effectivePolicy,
+            providerProtocol: outboundProtocol,
+            payload: formattedPayload,
+            stageRecorder: outboundRecorder,
+            requestId: normalized.id
+        });
         providerPayload = applyHubProviderOutboundPolicy({
             policy: effectivePolicy,
             providerProtocol: outboundProtocol,
@@ -331,6 +468,13 @@ export class HubPipeline {
             stageRecorder: outboundRecorder,
             requestId: normalized.id
         });
+        providerPayload = applyProviderOutboundToolSurface({
+            config: this.config.toolSurface,
+            providerProtocol: outboundProtocol,
+            payload: providerPayload,
+            stageRecorder: outboundRecorder,
+            requestId: normalized.id
+        });
         recordHubPolicyObservation({
             policy: effectivePolicy,
             providerProtocol: outboundProtocol,
@@ -387,7 +531,17 @@ export class HubPipeline {
             processMode: normalized.processMode,
             routeHint: normalized.routeHint,
             target: routing.target,
-            ...(typeof outboundStream === 'boolean' ? { providerStream: outboundStream } : {})
+            ...(typeof outboundStream === 'boolean' ? { providerStream: outboundStream } : {}),
+            ...(shadowBaselineProviderPayload
+                ? {
+                    hubShadowCompare: {
+                        baselineMode: shadowCompareBaselineMode,
+                        candidateMode: (effectivePolicy?.mode ?? 'off'),
+                        providerProtocol: outboundProtocol,
+                        baselineProviderPayload: shadowBaselineProviderPayload
+                    }
+                }
+                : {})
         };
         return {
             requestId: normalized.id,
@@ -409,8 +563,310 @@ export class HubPipeline {
             return 'anthropic-messages';
         return 'openai-chat';
     }
+    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 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 } : {})
+            }
+        };
+        // Keep rawPayload minimal and JSON-safe; chat-process only needs the OpenAI-chat-like surface here.
+        const rawPayload = {
+            model,
+            messages,
+            ...(tools ? { tools } : {}),
+            ...(parameters && Object.keys(parameters).length ? { parameters } : {})
+        };
+        return { standardizedRequest, rawPayload };
+    }
+    async executeChatProcessEntryPipeline(normalized) {
+        const hooks = this.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 = this.asJsonObject(normalized.payload);
+        const { standardizedRequest: standardizedRequestBase, rawPayload } = this.coerceStandardizedRequestFromPayload(rawPayloadInput, normalized);
+        // Keep metadata injection consistent with the inbound path: servertool/web_search config must be available
+        // to chat-process/tool governance even when request enters at outbound stage.
+        const metaBase = {
+            ...(normalized.metadata ?? {})
+        };
+        const webSearchConfig = this.config.virtualRouter?.webSearch;
+        if (webSearchConfig) {
+            metaBase.webSearch = webSearchConfig;
+        }
+        const execCommandGuard = this.config.virtualRouter?.execCommandGuard;
+        if (execCommandGuard) {
+            metaBase.execCommandGuard = execCommandGuard;
+        }
+        const clockConfig = this.config.virtualRouter?.clock;
+        if (clockConfig) {
+            metaBase.clock = clockConfig;
+        }
+        normalized.metadata = metaBase;
+        const standardizedRequest = standardizedRequestBase;
+        try {
+            const mode = String(metaBase?.applyPatchToolMode || '').trim().toLowerCase();
+            if (mode === 'freeform' || mode === 'schema') {
+                standardizedRequest.metadata.applyPatchToolMode = mode;
+            }
+        }
+        catch {
+            // ignore
+        }
+        const adapterContext = this.buildAdapterContext(normalized);
+        const stageRecorder = this.maybeCreateStageRecorder(adapterContext, normalized.entryEndpoint, {
+            disableSnapshots: normalized.disableSnapshots === true
+        });
+        let processedRequest;
+        if (normalized.processMode !== 'passthrough') {
+            const processResult = await runReqProcessStage1ToolGovernance({
+                request: standardizedRequest,
+                rawPayload,
+                metadata: metaBase,
+                entryEndpoint: normalized.entryEndpoint,
+                requestId: normalized.id,
+                stageRecorder
+            });
+            processedRequest = processResult.processedRequest;
+            // Surface request-side clock reservation into pipeline metadata so response conversion
+            // can commit delivery only after a successful response is produced.
+            try {
+                const reservation = processedRequest?.metadata?.__clockReservation;
+                if (reservation && typeof reservation === 'object') {
+                    metaBase.__clockReservation = reservation;
+                }
+            }
+            catch {
+                // best-effort
+            }
+            if (processResult.nodeResult) {
+                nodeResults.push(this.convertProcessNodeResult('req_process_stage1_tool_governance', processResult.nodeResult));
+            }
+        }
+        let workingRequest = processedRequest ?? standardizedRequest;
+        // Token estimate for stats/diagnostics (best-effort).
+        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 = normalizedMeta && typeof normalizedMeta.responsesResume === 'object'
+            ? normalizedMeta.responsesResume
+            : undefined;
+        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 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,
+            ...(serverToolRequired ? { serverToolRequired: true } : {}),
+            ...(sessionIdentifiers.sessionId ? { sessionId: sessionIdentifiers.sessionId } : {}),
+            ...(sessionIdentifiers.conversationId ? { conversationId: sessionIdentifiers.conversationId } : {})
+        };
+        const routing = runReqProcessStage2RouteSelect({
+            routerEngine: this.routerEngine,
+            request: workingRequest,
+            metadataInput,
+            normalizedMetadata: normalized.metadata,
+            stageRecorder
+        });
+        const stopMessageState = this.routerEngine.getStopMessageState(metadataInput);
+        if (stopMessageState && normalized.metadata && typeof normalized.metadata === 'object') {
+            normalized.metadata.stopMessageState = stopMessageState;
+            workingRequest = applyHubOperations(workingRequest, [
+                { op: 'set_request_metadata_fields', fields: { stopMessageState } }
+            ]);
+        }
+        // Emit virtual router hit log for debugging (same as inbound path).
+        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 = this.resolveOutboundStreamIntent(routing.target?.streaming);
+        workingRequest = this.applyOutboundStreamPreference(workingRequest, outboundStream);
+        const outboundAdapterContext = this.buildAdapterContext(normalized, routing.target);
+        if (routing.target?.compatibilityProfile) {
+            outboundAdapterContext.compatibilityProfile = routing.target.compatibilityProfile;
+        }
+        const outboundProtocol = outboundAdapterContext.providerProtocol;
+        const protocolSwitch = outboundProtocol !== normalized.providerProtocol;
+        const outboundHooks = protocolSwitch ? this.resolveProtocolHooks(outboundProtocol) : hooks;
+        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 = this.maybeCreateStageRecorder(outboundAdapterContext, normalized.entryEndpoint, {
+            disableSnapshots: normalized.disableSnapshots === true
+        });
+        const outboundStart = Date.now();
+        let providerPayload;
+        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
+        });
+        // Phase 0/1: observe + enforce provider outbound policy and tool surface (same as inbound path).
+        const effectivePolicy = normalized.policyOverride ?? this.config.policy;
+        recordHubPolicyObservation({
+            policy: effectivePolicy,
+            providerProtocol: outboundProtocol,
+            payload: formattedPayload,
+            stageRecorder: outboundRecorder,
+            requestId: normalized.id
+        });
+        providerPayload = applyHubProviderOutboundPolicy({
+            policy: effectivePolicy,
+            providerProtocol: outboundProtocol,
+            payload: formattedPayload,
+            stageRecorder: outboundRecorder,
+            requestId: normalized.id
+        });
+        providerPayload = applyProviderOutboundToolSurface({
+            config: this.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
+        };
+    }
     async execute(request) {
         const normalized = await this.normalizeRequest(request);
+        if (normalized.direction === 'request' && normalized.hubEntryMode === 'chat_process') {
+            return await this.executeChatProcessEntryPipeline(normalized);
+        }
         const hooks = this.resolveProtocolHooks(normalized.providerProtocol);
         if (!hooks) {
             throw new Error(`Unsupported provider protocol for hub pipeline: ${normalized.providerProtocol}`);
@@ -540,6 +996,12 @@ export class HubPipeline {
             adapterContext.clientToolsRaw = metadata
                 .clientToolsRaw;
         }
+        const applyPatchToolMode = typeof metadata.applyPatchToolMode === 'string'
+            ? metadata.applyPatchToolMode.trim().toLowerCase()
+            : '';
+        if (applyPatchToolMode === 'freeform' || applyPatchToolMode === 'schema') {
+            adapterContext.applyPatchToolMode = applyPatchToolMode;
+        }
         const sessionId = typeof metadata.sessionId === 'string'
             ? metadata.sessionId.trim()
             : '';
@@ -629,10 +1091,23 @@ export class HubPipeline {
         if (Object.prototype.hasOwnProperty.call(metadataRecord, '__hubPolicyOverride')) {
             delete metadataRecord.__hubPolicyOverride;
         }
+        const shadowCompare = extractHubShadowCompareConfig(metadataRecord);
+        if (Object.prototype.hasOwnProperty.call(metadataRecord, '__hubShadowCompare')) {
+            delete metadataRecord.__hubShadowCompare;
+        }
         const disableSnapshots = metadataRecord.__disableHubSnapshots === true;
         if (Object.prototype.hasOwnProperty.call(metadataRecord, '__disableHubSnapshots')) {
             delete metadataRecord.__disableHubSnapshots;
         }
+        const hubEntryRaw = typeof metadataRecord.__hubEntry === 'string'
+            ? String(metadataRecord.__hubEntry).trim().toLowerCase()
+            : '';
+        const hubEntryMode = hubEntryRaw === 'chat_process' || hubEntryRaw === 'chat-process' || hubEntryRaw === 'chatprocess'
+            ? 'chat_process'
+            : undefined;
+        if (Object.prototype.hasOwnProperty.call(metadataRecord, '__hubEntry')) {
+            delete metadataRecord.__hubEntry;
+        }
         const entryEndpoint = typeof metadataRecord.entryEndpoint === 'string'
             ? normalizeEndpoint(metadataRecord.entryEndpoint)
             : endpoint;
@@ -671,12 +1146,14 @@ export class HubPipeline {
             payload,
             metadata: normalizedMetadata,
             policyOverride: policyOverride ?? undefined,
+            shadowCompare: shadowCompare ?? undefined,
             disableSnapshots,
             processMode,
             direction,
             stage,
             stream,
-            routeHint
+            routeHint,
+            ...(hubEntryMode ? { hubEntryMode } : {})
         };
     }
     convertProcessNodeResult(id, result) {
@@ -772,25 +1249,18 @@ export class HubPipeline {
     }
     applyOutboundStreamPreference(request, stream) {
         if (!request || typeof request !== 'object') {
-            return;
+            return request;
         }
-        const parameters = request.parameters || {};
-        const nextParameters = { ...parameters };
+        const ops = [];
         if (typeof stream === 'boolean') {
-            nextParameters.stream = stream;
-        }
-        else if ('stream' in nextParameters) {
-            delete nextParameters.stream;
+            ops.push({ op: 'set_request_parameter_fields', fields: { stream } });
+            ops.push({ op: 'set_request_metadata_fields', fields: { outboundStream: stream } });
         }
-        request.parameters = nextParameters;
-        if (request.metadata && typeof request.metadata === 'object') {
-            if (typeof stream === 'boolean') {
-                request.metadata.outboundStream = stream;
-            }
-            else if ('outboundStream' in request.metadata) {
-                delete request.metadata.outboundStream;
-            }
+        else {
+            ops.push({ op: 'unset_request_parameter_keys', keys: ['stream'] });
+            ops.push({ op: 'unset_request_metadata_keys', keys: ['outboundStream'] });
         }
+        return applyHubOperations(request, ops);
     }
 }
 function normalizeToolCallIdStyleCandidate(value) {