@jsonstudio/llms 0.6.802 → 0.6.938

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

@@ -1,5 +1,5 @@
 import { Readable } from 'node:stream';
-import { isJsonObject } from '../types/json.js';
+import { isJsonObject, jsonClone } from '../types/json.js';
 import { VirtualRouterEngine } from '../../../router/virtual-router/engine.js';
 import { providerErrorCenter } from '../../../router/virtual-router/error-center.js';
 import { defaultSseCodecRegistry } from '../../../sse/index.js';
@@ -25,6 +25,7 @@ import { runReqOutboundStage3Compat } from './stages/req_outbound/req_outbound_s
 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';
 export class HubPipeline {
     routerEngine;
     config;
@@ -37,6 +38,7 @@ export class HubPipeline {
             quotaView: config.quotaView
         });
         this.routerEngine.initialize(config.virtualRouter);
+        setHubPolicyRuntimePolicy(config.policy);
         try {
             this.unsubscribeProviderErrors = providerErrorCenter.subscribe((event) => {
                 try {
@@ -97,6 +99,19 @@ export class HubPipeline {
         const formatAdapter = hooks.createFormatAdapter();
         const semanticMapper = hooks.createSemanticMapper();
         const rawRequest = this.asJsonObject(normalized.payload);
+        // Preserve the client-provided raw tool definitions (schema included) for response-side validation
+        // and protocol-correct outbound tool-call formatting. This must reflect the inbound request shape,
+        // not the governed/augmented tools.
+        try {
+            const toolsRaw = Array.isArray(rawRequest?.tools) ? rawRequest.tools : null;
+            if (toolsRaw && toolsRaw.length > 0) {
+                normalized.metadata = normalized.metadata || {};
+                normalized.metadata.clientToolsRaw = jsonClone(toolsRaw);
+            }
+        }
+        catch {
+            // best-effort: do not block request handling due to tool snapshot failures
+        }
         if (isCompactionRequest(rawRequest)) {
             normalized.metadata = normalized.metadata || {};
             normalized.metadata.compactionRequest = true;
@@ -104,6 +119,14 @@ export class HubPipeline {
         const inboundAdapterContext = this.buildAdapterContext(normalized);
         const inboundRecorder = this.maybeCreateStageRecorder(inboundAdapterContext, normalized.entryEndpoint);
         const inboundStart = Date.now();
+        // Phase 0: observe client inbound payload violations (best-effort; no rewrites).
+        recordHubPolicyObservation({
+            providerProtocol: this.resolveClientProtocol(normalized.entryEndpoint),
+            payload: rawRequest,
+            phase: 'client_inbound',
+            stageRecorder: inboundRecorder,
+            requestId: normalized.id
+        });
         const formatEnvelope = await runReqInboundStage1FormatParse({
             rawRequest,
             adapterContext: inboundAdapterContext,
@@ -139,20 +162,26 @@ export class HubPipeline {
                 }
             }
         });
+        // 将 VirtualRouter 层的 servertool 相关配置注入到 metadata，保证响应侧
+        // servertool（第三跳 reenter）也能访问到相同配置，即使当前 route 标记为 passthrough。
+        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;
+        }
+        normalized.metadata = metaBase;
         let processedRequest;
         if (normalized.processMode !== 'passthrough') {
-            const processMetadata = {
-                ...(normalized.metadata ?? {})
-            };
-            const webSearchConfig = this.config.virtualRouter?.webSearch;
-            if (webSearchConfig) {
-                processMetadata.webSearch = webSearchConfig;
-            }
-            normalized.metadata = processMetadata;
             const processResult = await runReqProcessStage1ToolGovernance({
                 request: standardizedRequest,
                 rawPayload: rawRequest,
-                metadata: processMetadata,
+                metadata: metaBase,
                 entryEndpoint: normalized.entryEndpoint,
                 requestId: normalized.id,
                 stageRecorder: inboundRecorder
@@ -273,7 +302,20 @@ export class HubPipeline {
             adapterContext: outboundAdapterContext,
             stageRecorder: outboundRecorder
         });
-        providerPayload = formattedPayload;
+        providerPayload = applyHubProviderOutboundPolicy({
+            policy: this.config.policy,
+            providerProtocol: outboundProtocol,
+            payload: formattedPayload,
+            stageRecorder: outboundRecorder,
+            requestId: normalized.id
+        });
+        recordHubPolicyObservation({
+            policy: this.config.policy,
+            providerProtocol: outboundProtocol,
+            payload: providerPayload,
+            stageRecorder: outboundRecorder,
+            requestId: normalized.id
+        });
         const outboundEnd = Date.now();
         nodeResults.push({
             id: 'req_outbound',
@@ -305,11 +347,13 @@ export class HubPipeline {
         // 对于 capturedChatRequest，我们只需要一个“可读快照”，不会在后续流程中
         // 对其做就地修改，因此可以直接使用浅拷贝结构，避免序列化失败导致整段
         // 逻辑失效。
+        // Deep-clone a JSON-safe snapshot for servertool followups.
+        // Only capture the canonical Chat payload fields (model/messages/tools/parameters) to keep it serializable.
         const capturedChatRequest = {
             model: workingRequest.model,
-            messages: Array.isArray(workingRequest.messages) ? [...workingRequest.messages] : workingRequest.messages,
-            tools: workingRequest.tools,
-            parameters: workingRequest.parameters
+            messages: jsonClone(workingRequest.messages),
+            tools: workingRequest.tools ? jsonClone(workingRequest.tools) : workingRequest.tools,
+            parameters: workingRequest.parameters ? jsonClone(workingRequest.parameters) : workingRequest.parameters
         };
         const metadata = {
             ...normalized.metadata,
@@ -335,6 +379,14 @@ export class HubPipeline {
             nodeResults
         };
     }
+    resolveClientProtocol(entryEndpoint) {
+        const lowered = String(entryEndpoint || '').toLowerCase();
+        if (lowered.includes('/v1/responses'))
+            return 'openai-responses';
+        if (lowered.includes('/v1/messages'))
+            return 'anthropic-messages';
+        return 'openai-chat';
+    }
     async execute(request) {
         const normalized = await this.normalizeRequest(request);
         const hooks = this.resolveProtocolHooks(normalized.providerProtocol);
@@ -457,6 +509,11 @@ export class HubPipeline {
             adapterContext.serverToolFollowup = metadata
                 .serverToolFollowup;
         }
+        // Preserve raw client tools (schemas) for response-side validation/formatting.
+        if (Object.prototype.hasOwnProperty.call(metadata, 'clientToolsRaw')) {
+            adapterContext.clientToolsRaw = metadata
+                .clientToolsRaw;
+        }
         const sessionId = typeof metadata.sessionId === 'string'
             ? metadata.sessionId.trim()
             : '';

package/dist/conversion/hub/pipeline/stages/req_process/req_process_stage1_tool_governance/index.js

@@ -1,5 +1,6 @@
 import { runHubChatProcess } from '../../../../process/chat-process.js';
 import { recordStage } from '../../../stages/utils.js';
+import { captureApplyPatchExecutionFailuresFromProcessedRequest } from '../../../../../../tools/apply-patch/execution-capturer.js';
 export async function runReqProcessStage1ToolGovernance(options) {
     const result = await runHubChatProcess({
         request: options.request,
@@ -10,6 +11,9 @@ export async function runReqProcessStage1ToolGovernance(options) {
     });
     if (result.processedRequest) {
         recordStage(options.stageRecorder, 'req_process_stage1_tool_governance', result.processedRequest);
+        // Best-effort: capture apply_patch execution failures reported by tool role messages.
+        // This is for errorsamples collection only and must not affect runtime behavior.
+        captureApplyPatchExecutionFailuresFromProcessedRequest(result.processedRequest);
     }
     return result;
 }

package/dist/conversion/hub/pipeline/stages/resp_outbound/resp_outbound_stage1_client_remap/index.js

@@ -12,8 +12,10 @@ export function runRespOutboundStage1ClientRemap(options) {
         });
     }
     else {
+        const toolsRaw = resolveClientToolsRawFromContext(options.adapterContext);
         clientPayload = buildResponsesPayloadFromChat(options.payload, {
-            requestId: options.requestId
+            requestId: options.requestId,
+            ...(toolsRaw ? { toolsRaw } : {})
         });
     }
     recordStage(options.stageRecorder, 'resp_outbound_stage1_client_remap', clientPayload);
@@ -41,3 +43,23 @@ function resolveAliasMapFromContext(adapterContext) {
     }
     return Object.keys(map).length ? map : undefined;
 }
+function resolveClientToolsRawFromContext(adapterContext) {
+    if (!adapterContext) {
+        return undefined;
+    }
+    const candidate = adapterContext.clientToolsRaw;
+    if (!candidate || !Array.isArray(candidate)) {
+        return undefined;
+    }
+    const filtered = [];
+    for (const entry of candidate) {
+        if (entry && typeof entry === 'object' && !Array.isArray(entry)) {
+            const type = entry.type;
+            if (typeof type !== 'string' || !type.trim()) {
+                continue;
+            }
+            filtered.push(entry);
+        }
+    }
+    return filtered.length ? filtered : undefined;
+}

package/dist/conversion/hub/pipelines/inbound.d.ts

@@ -0,0 +1,22 @@
+import type { ChatEnvelope, AdapterContext } from '../types/chat-envelope.js';
+import type { FormatAdapter, SemanticMapper, StageRecorder } from '../format-adapters/index.js';
+import type { JsonObject } from '../types/json.js';
+export type InboundStage = 'format_parse' | 'semantic_map_to_chat' | 'inbound_passthrough';
+export interface InboundPassthroughConfig {
+    mode: 'chat';
+    factory: (raw: JsonObject, ctx: AdapterContext) => Promise<ChatEnvelope> | ChatEnvelope;
+}
+export interface InboundPlan {
+    protocol?: string;
+    stages: InboundStage[];
+    formatAdapter?: Pick<FormatAdapter, 'parseRequest'>;
+    semanticMapper?: Pick<SemanticMapper, 'toChat'>;
+    passthrough?: InboundPassthroughConfig;
+}
+export interface InboundPipelineOptions {
+    rawRequest: JsonObject;
+    context: AdapterContext;
+    plan: InboundPlan;
+    stageRecorder?: StageRecorder;
+}
+export declare function runInboundPipeline(options: InboundPipelineOptions): Promise<ChatEnvelope>;

package/dist/conversion/hub/pipelines/outbound.d.ts

@@ -0,0 +1,22 @@
+import type { ChatEnvelope, AdapterContext } from '../types/chat-envelope.js';
+import type { FormatAdapter, SemanticMapper, StageRecorder } from '../format-adapters/index.js';
+import type { JsonObject } from '../types/json.js';
+export type OutboundStage = 'semantic_map_from_chat' | 'format_build' | 'outbound_passthrough';
+export interface OutboundPassthroughConfig {
+    mode: 'protocol';
+    factory: (chat: ChatEnvelope, ctx: AdapterContext) => Promise<JsonObject> | JsonObject;
+}
+export interface OutboundPlan {
+    protocol?: string;
+    stages: OutboundStage[];
+    formatAdapter?: Pick<FormatAdapter, 'buildResponse'>;
+    semanticMapper?: Pick<SemanticMapper, 'fromChat'>;
+    passthrough?: OutboundPassthroughConfig;
+}
+export interface OutboundPipelineOptions {
+    chat: ChatEnvelope;
+    context: AdapterContext;
+    plan: OutboundPlan;
+    stageRecorder?: StageRecorder;
+}
+export declare function runOutboundPipeline(options: OutboundPipelineOptions): Promise<JsonObject>;

package/dist/conversion/hub/policy/policy-engine.d.ts

@@ -0,0 +1,46 @@
+import type { JsonObject } from '../types/json.js';
+import type { StageRecorder } from '../format-adapters/index.js';
+export type HubPolicyMode = 'off' | 'observe' | 'enforce';
+export interface HubPolicyConfig {
+    mode?: HubPolicyMode;
+    /**
+     * Optional: sampling rate in [0, 1]. When provided, observation is best-effort
+     * and may skip recording for some requests.
+     */
+    sampleRate?: number;
+}
+export interface PolicyObservation {
+    phase: 'client_inbound' | 'provider_outbound' | 'provider_inbound' | 'client_outbound';
+    providerProtocol: string;
+    violations: Array<{
+        code: 'unexpected_wrapper' | 'unexpected_field';
+        path: string;
+        detail?: string;
+    }>;
+    summary: {
+        totalViolations: number;
+        unexpectedFieldCount: number;
+    };
+}
+export interface ProviderOutboundPolicyApplyResult {
+    payload: JsonObject;
+    changed: boolean;
+    removedTopLevelKeys: string[];
+    flattenedWrappers: string[];
+}
+export declare function setHubPolicyRuntimePolicy(policy?: HubPolicyConfig): void;
+export declare function recordHubPolicyObservation(options: {
+    policy?: HubPolicyConfig;
+    phase?: PolicyObservation['phase'];
+    providerProtocol: string;
+    payload: JsonObject;
+    stageRecorder?: StageRecorder;
+    requestId?: string;
+}): void;
+export declare function applyHubProviderOutboundPolicy(options: {
+    policy?: HubPolicyConfig;
+    providerProtocol: string;
+    payload: JsonObject;
+    stageRecorder?: StageRecorder;
+    requestId?: string;
+}): JsonObject;

package/dist/conversion/hub/policy/policy-engine.js

@@ -0,0 +1,176 @@
+import { resolveHubProtocolSpec } from './protocol-spec.js';
+let hubPolicyRuntime = undefined;
+export function setHubPolicyRuntimePolicy(policy) {
+    hubPolicyRuntime = policy;
+}
+function resolveEffectivePolicy(policy) {
+    return policy ?? hubPolicyRuntime;
+}
+function shouldSample(rate) {
+    if (rate === undefined)
+        return true;
+    if (!Number.isFinite(rate))
+        return true;
+    if (rate <= 0)
+        return false;
+    if (rate >= 1)
+        return true;
+    return Math.random() < rate;
+}
+function isJsonRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function applyProviderOutboundPolicy(providerProtocol, payload) {
+    const removedTopLevelKeys = [];
+    const flattenedWrappers = [];
+    const spec = resolveHubProtocolSpec(providerProtocol);
+    if (!spec.providerOutbound.enforceEnabled) {
+        return {
+            payload,
+            changed: false,
+            removedTopLevelKeys,
+            flattenedWrappers
+        };
+    }
+    let out = payload;
+    const ensureOutClone = () => {
+        if (out === payload) {
+            out = { ...payload };
+        }
+    };
+    // Reserved/private keys must never be sent upstream.
+    for (const key of Object.keys(payload)) {
+        if (spec.providerOutbound.reservedKeyPrefixes.some((prefix) => key.startsWith(prefix))) {
+            ensureOutClone();
+            delete out[key];
+            removedTopLevelKeys.push(key);
+        }
+    }
+    // Flatten accidental wrappers that have caused upstream 400s.
+    for (const rule of spec.providerOutbound.flattenWrappers) {
+        const wrapperKey = rule.wrapperKey;
+        if (!wrapperKey || typeof wrapperKey !== 'string') {
+            continue;
+        }
+        if (!isJsonRecord(out[wrapperKey])) {
+            continue;
+        }
+        ensureOutClone();
+        const inner = { ...out[wrapperKey] };
+        const alias = rule.aliasKeys || {};
+        for (const [from, to] of Object.entries(alias)) {
+            if (inner[to] === undefined && inner[from] !== undefined) {
+                inner[to] = inner[from];
+            }
+        }
+        const allow = Array.isArray(rule.allowKeys) ? new Set(rule.allowKeys) : null;
+        const onlyIfMissing = rule.onlyIfTargetMissing !== false;
+        for (const [key, value] of Object.entries(inner)) {
+            if (allow && !allow.has(key)) {
+                continue;
+            }
+            if (!onlyIfMissing || out[key] === undefined) {
+                out[key] = value;
+            }
+        }
+        delete out[wrapperKey];
+        flattenedWrappers.push(wrapperKey);
+    }
+    return {
+        payload: out,
+        changed: out !== payload || removedTopLevelKeys.length > 0 || flattenedWrappers.length > 0,
+        removedTopLevelKeys,
+        flattenedWrappers
+    };
+}
+function observeProviderOutboundPayload(providerProtocol, payload) {
+    const violations = [];
+    // V0 (observe-only): detect known "layout anti-patterns" and reserved keys.
+    // Do NOT modify payload here.
+    const spec = resolveHubProtocolSpec(providerProtocol);
+    for (const rule of spec.providerOutbound.forbidWrappers) {
+        if (rule.code !== 'forbid_wrapper') {
+            continue;
+        }
+        if (rule.path in payload && isJsonRecord(payload[rule.path])) {
+            violations.push({
+                code: 'unexpected_wrapper',
+                path: rule.path,
+                detail: rule.detail
+            });
+        }
+    }
+    // Always record unknown private wrapper keys (best-effort, conservative).
+    for (const key of Object.keys(payload)) {
+        if (spec.providerOutbound.reservedKeyPrefixes.some((prefix) => key.startsWith(prefix))) {
+            violations.push({
+                code: 'unexpected_field',
+                path: key
+            });
+        }
+    }
+    const unexpectedFieldCount = violations.filter((v) => v.code === 'unexpected_field').length;
+    return {
+        phase: 'provider_outbound',
+        providerProtocol,
+        violations,
+        summary: {
+            totalViolations: violations.length,
+            unexpectedFieldCount
+        }
+    };
+}
+export function recordHubPolicyObservation(options) {
+    if (!options.stageRecorder) {
+        return;
+    }
+    const effectivePolicy = resolveEffectivePolicy(options.policy);
+    const mode = effectivePolicy?.mode ?? 'off';
+    // Keep observing in enforce mode (best-effort) so operators can monitor
+    // violations while gradually turning enforcement on.
+    if (mode !== 'observe' && mode !== 'enforce') {
+        return;
+    }
+    if (!shouldSample(effectivePolicy?.sampleRate)) {
+        return;
+    }
+    try {
+        const phase = options.phase ?? 'provider_outbound';
+        const observation = observeProviderOutboundPayload(options.providerProtocol, options.payload);
+        observation.phase = phase;
+        if (observation.summary.totalViolations <= 0) {
+            return;
+        }
+        const stage = `hub_policy.observe.${phase}`;
+        options.stageRecorder.record(stage, {
+            requestId: options.requestId,
+            ...observation
+        });
+    }
+    catch {
+        // observe-only must never break the pipeline
+    }
+}
+export function applyHubProviderOutboundPolicy(options) {
+    const effectivePolicy = resolveEffectivePolicy(options.policy);
+    const mode = effectivePolicy?.mode ?? 'off';
+    if (mode !== 'enforce') {
+        return options.payload;
+    }
+    const result = applyProviderOutboundPolicy(options.providerProtocol, options.payload);
+    if (!result.changed) {
+        return options.payload;
+    }
+    try {
+        options.stageRecorder?.record('hub_policy.enforce.provider_outbound', {
+            requestId: options.requestId,
+            providerProtocol: options.providerProtocol,
+            removedTopLevelKeys: result.removedTopLevelKeys,
+            flattenedWrappers: result.flattenedWrappers
+        });
+    }
+    catch {
+        // policy enforcement recording must not break the pipeline
+    }
+    return result.payload;
+}

package/dist/conversion/hub/policy/protocol-spec.d.ts

@@ -0,0 +1,50 @@
+export type HubProviderProtocol = 'openai-chat' | 'openai-responses' | 'anthropic-messages' | 'gemini-chat';
+export interface ProviderOutboundLayoutRule {
+    code: 'forbid_wrapper';
+    path: string;
+    detail: string;
+}
+export interface ProviderOutboundWrapperFlattenRule {
+    wrapperKey: string;
+    /**
+     * When provided, only these keys from the wrapper are merged into top-level.
+     * When omitted, all keys are eligible.
+     */
+    allowKeys?: string[];
+    /**
+     * Key remap inside wrapper prior to merging (e.g. max_tokens -> max_output_tokens).
+     */
+    aliasKeys?: Record<string, string>;
+    /**
+     * Merge strategy: only write to target when top-level key is undefined.
+     */
+    onlyIfTargetMissing?: boolean;
+}
+export interface ProviderOutboundPolicySpec {
+    /**
+     * Whether provider outbound enforcement is enabled for this protocol.
+     * Keep this false for protocols not yet migrated, to avoid behavior changes.
+     */
+    enforceEnabled: boolean;
+    /**
+     * Reserved/private key prefixes that must not be sent upstream.
+     * (Enforced only when enforceEnabled=true.)
+     */
+    reservedKeyPrefixes: string[];
+    /**
+     * Wrappers that should not exist in provider outbound payload.
+     * observe: treat as violations; enforce: flatten/remove when configured.
+     */
+    forbidWrappers: ProviderOutboundLayoutRule[];
+    /**
+     * Best-effort fix for known wrapper anti-patterns by flattening into top-level.
+     * (Applied only when enforceEnabled=true.)
+     */
+    flattenWrappers: ProviderOutboundWrapperFlattenRule[];
+}
+export interface ProtocolSpec {
+    id: HubProviderProtocol;
+    providerOutbound: ProviderOutboundPolicySpec;
+}
+export declare const HUB_PROTOCOL_SPECS: Record<HubProviderProtocol, ProtocolSpec>;
+export declare function resolveHubProtocolSpec(protocol: string): ProtocolSpec;

package/dist/conversion/hub/policy/protocol-spec.js

@@ -0,0 +1,105 @@
+const RESPONSES_SPEC = {
+    id: 'openai-responses',
+    providerOutbound: {
+        enforceEnabled: true,
+        forbidWrappers: [
+            {
+                code: 'forbid_wrapper',
+                path: 'parameters',
+                detail: 'Responses provider payload must not contain a top-level parameters wrapper (expects flattened fields).'
+            },
+            {
+                code: 'forbid_wrapper',
+                path: 'request',
+                detail: 'Responses provider payload must not contain a nested request wrapper.'
+            }
+        ],
+        reservedKeyPrefixes: ['__', '_'],
+        flattenWrappers: [
+            {
+                wrapperKey: 'request',
+                onlyIfTargetMissing: true
+            },
+            {
+                wrapperKey: 'parameters',
+                onlyIfTargetMissing: true,
+                aliasKeys: {
+                    max_tokens: 'max_output_tokens'
+                },
+                allowKeys: [
+                    'temperature',
+                    'top_p',
+                    'max_output_tokens',
+                    'seed',
+                    'logit_bias',
+                    'user',
+                    'parallel_tool_calls',
+                    'tool_choice',
+                    'response_format',
+                    'stream',
+                    'stop',
+                    'stop_sequences',
+                    'modalities',
+                    'top_k'
+                ]
+            }
+        ]
+    }
+};
+const DEFAULT_SPEC = {
+    id: 'openai-chat',
+    providerOutbound: {
+        enforceEnabled: false,
+        forbidWrappers: [
+            {
+                code: 'forbid_wrapper',
+                path: 'parameters',
+                detail: 'OpenAI Chat provider payload must not contain a top-level parameters wrapper (expects flattened fields).'
+            },
+            {
+                code: 'forbid_wrapper',
+                path: 'request',
+                detail: 'OpenAI Chat provider payload must not contain a nested request wrapper.'
+            }
+        ],
+        reservedKeyPrefixes: ['__', '_'],
+        flattenWrappers: []
+    }
+};
+export const HUB_PROTOCOL_SPECS = {
+    'openai-chat': DEFAULT_SPEC,
+    'openai-responses': RESPONSES_SPEC,
+    'anthropic-messages': {
+        id: 'anthropic-messages',
+        providerOutbound: {
+            enforceEnabled: false,
+            forbidWrappers: [
+                {
+                    code: 'forbid_wrapper',
+                    path: 'parameters',
+                    detail: 'Anthropic Messages provider payload must not contain a top-level parameters wrapper.'
+                },
+                {
+                    code: 'forbid_wrapper',
+                    path: 'request',
+                    detail: 'Anthropic Messages provider payload must not contain a nested request wrapper.'
+                }
+            ],
+            reservedKeyPrefixes: ['__', '_'],
+            flattenWrappers: []
+        }
+    },
+    'gemini-chat': {
+        id: 'gemini-chat',
+        providerOutbound: {
+            enforceEnabled: false,
+            forbidWrappers: [],
+            reservedKeyPrefixes: ['__', '_'],
+            flattenWrappers: []
+        }
+    }
+};
+export function resolveHubProtocolSpec(protocol) {
+    const normalized = (protocol || '').trim().toLowerCase();
+    return HUB_PROTOCOL_SPECS[normalized] ?? DEFAULT_SPEC;
+}

package/dist/conversion/hub/process/chat-process.d.ts

@@ -0,0 +1,32 @@
+import type { ProcessedRequest, StandardizedRequest } from '../types/standardized.js';
+import type { JsonObject } from '../types/json.js';
+export interface HubChatProcessOptions {
+    request: StandardizedRequest;
+    requestId: string;
+    entryEndpoint: string;
+    rawPayload: Record<string, unknown>;
+    metadata: Record<string, unknown>;
+}
+export interface HubChatProcessResult {
+    processedRequest?: ProcessedRequest;
+    nodeResult: HubProcessNodeResult;
+}
+export interface HubProcessNodeResult {
+    success: boolean;
+    metadata: {
+        node: string;
+        executionTime: number;
+        startTime: number;
+        endTime: number;
+        dataProcessed?: {
+            messages: number;
+            tools: number;
+        };
+    };
+    error?: {
+        code?: string;
+        message: string;
+        details?: JsonObject;
+    };
+}
+export declare function runHubChatProcess(options: HubChatProcessOptions): Promise<HubChatProcessResult>;