@jsonstudio/llms 0.6.795 → 0.6.938

package/dist/bridge/routecodex-adapter.d.ts

@@ -0,0 +1,74 @@
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonObject | JsonValue[];
+export interface JsonObject {
+    [key: string]: JsonValue;
+}
+type Direction = 'request' | 'response';
+type Stage = 'inbound' | 'outbound';
+type ProviderType = 'openai' | 'anthropic' | 'responses' | 'gemini';
+export interface AdapterOptions {
+    baseDir?: string;
+    processMode?: 'passthrough' | 'chat' | string;
+    providerProtocol?: string;
+    providerType?: ProviderType;
+    entryEndpoint?: string;
+    direction?: Direction;
+    stage?: Stage;
+}
+export declare function processIncoming(request: JsonObject, options?: AdapterOptions): Promise<{
+    data: JsonValue;
+    metadata: {
+        conversionId: string;
+        conversionEndpoint: string;
+        conversionStage: Stage;
+    };
+}>;
+export declare function processOutgoing(response: JsonObject, options?: AdapterOptions): Promise<{
+    data: JsonValue;
+    metadata: {
+        conversionId: string;
+        conversionEndpoint: string;
+        conversionStage: Stage;
+    };
+}>;
+export declare function processInboundRequest(request: JsonObject, options?: AdapterOptions): Promise<{
+    data: JsonValue;
+    metadata: {
+        conversionId: string;
+        conversionEndpoint: string;
+        conversionStage: Stage;
+    };
+}>;
+export declare function processInboundResponse(response: JsonObject, options?: AdapterOptions): Promise<{
+    data: JsonValue;
+    metadata: {
+        conversionId: string;
+        conversionEndpoint: string;
+        conversionStage: Stage;
+    };
+}>;
+export declare function processOutboundRequest(request: JsonObject, options?: AdapterOptions): Promise<{
+    data: JsonValue;
+    metadata: {
+        conversionId: string;
+        conversionEndpoint: string;
+        conversionStage: Stage;
+    };
+}>;
+export declare function processOutboundResponse(response: JsonObject, options?: AdapterOptions): Promise<{
+    data: JsonValue;
+    metadata: {
+        conversionId: string;
+        conversionEndpoint: string;
+        conversionStage: Stage;
+    };
+}>;
+declare const _default: {
+    processIncoming: typeof processIncoming;
+    processOutgoing: typeof processOutgoing;
+    processInboundRequest: typeof processInboundRequest;
+    processInboundResponse: typeof processInboundResponse;
+    processOutboundRequest: typeof processOutboundRequest;
+    processOutboundResponse: typeof processOutboundResponse;
+};
+export default _default;

package/dist/config-unified/enhanced-path-resolver.d.ts

@@ -0,0 +1,5 @@
+export interface ResolvedPaths {
+    hostRoot: string;
+    configDir: string;
+}
+export declare function resolveHostPaths(): ResolvedPaths;

package/dist/config-unified/unified-config.d.ts

@@ -0,0 +1,26 @@
+export interface ContextBudget {
+    maxBytes: number;
+    safetyRatio: number;
+    allowedBytes: number;
+    source: string;
+}
+export declare class UnifiedConfigFacade {
+    private static _instance;
+    static getInstance(): UnifiedConfigFacade;
+    private watchers;
+    private fsWatcher;
+    getContextBudgetForModel(modelId: string): ContextBudget;
+    validateConfig(): {
+        ok: boolean;
+        issues: string[];
+    };
+    watchConfig(cb: (ev: {
+        file: string;
+        event: string;
+    }) => void): void;
+    unwatchConfig(cb?: (ev: {
+        file: string;
+        event: string;
+    }) => void): void;
+}
+export declare const UnifiedConfig: UnifiedConfigFacade;

package/dist/conversion/codec-registry.d.ts

@@ -0,0 +1,10 @@
+import type { ConversionCodec } from './types.js';
+export type CodecFactory = () => Promise<ConversionCodec> | ConversionCodec;
+export declare class CodecRegistry {
+    private readonly factories;
+    private readonly instances;
+    constructor(_deps?: unknown);
+    register(id: string, factory: CodecFactory): void;
+    resolve(id: string): Promise<ConversionCodec>;
+}
+export declare function getDefaultCodecFactories(): Record<string, CodecFactory>;

package/dist/conversion/codecs/gemini-openai-codec.d.ts

@@ -0,0 +1,16 @@
+import type { ConversionCodec, ConversionContext, ConversionProfile } from '../types.js';
+export declare function buildOpenAIChatFromGeminiRequest(payload: any): {
+    messages: any[];
+};
+export declare function buildOpenAIChatFromGeminiResponse(payload: any): any;
+export declare function buildGeminiFromOpenAIChat(chatResp: any): any;
+export declare class GeminiOpenAIConversionCodec implements ConversionCodec {
+    private readonly _dependencies;
+    readonly id = "gemini-openai";
+    private initialized;
+    constructor(_dependencies: any);
+    initialize(): Promise<void>;
+    private ensureInit;
+    convertRequest(payload: any, _profile: ConversionProfile, _context: ConversionContext): Promise<any>;
+    convertResponse(payload: any, _profile: ConversionProfile, _context: ConversionContext): Promise<any>;
+}

package/dist/conversion/codecs/openai-openai-codec.d.ts

@@ -0,0 +1,12 @@
+import type { ConversionCodec, ConversionContext, ConversionProfile } from '../types.js';
+export declare class OpenAIOpenAIConversionCodec implements ConversionCodec {
+    private readonly dependencies;
+    readonly id = "openai-openai";
+    private initialized;
+    private ctxMap;
+    constructor(dependencies: any);
+    initialize(): Promise<void>;
+    convertRequest(payload: any, profile: ConversionProfile, context: ConversionContext): Promise<any>;
+    convertResponse(payload: any, _profile: ConversionProfile, context: ConversionContext): Promise<any>;
+    private ensureInit;
+}

package/dist/conversion/codecs/responses-openai-codec.d.ts

@@ -0,0 +1,12 @@
+import type { ConversionCodec, ConversionContext, ConversionProfile } from '../types.js';
+export declare class ResponsesOpenAIConversionCodec implements ConversionCodec {
+    private readonly dependencies;
+    readonly id = "responses-openai";
+    private initialized;
+    private ctxMap;
+    constructor(dependencies: any);
+    initialize(): Promise<void>;
+    convertRequest(payload: any, profile: ConversionProfile, context: ConversionContext): Promise<any>;
+    convertResponse(payload: any, _profile: ConversionProfile, context: ConversionContext): Promise<any>;
+    private ensureInit;
+}

package/dist/conversion/compat/profiles/chat-gemini.json

@@ -8,6 +8,18 @@
       {
         "action": "gemini_web_search_request"
       },
+      {
+        "action": "shallow_pick",
+        "allowTopLevel": [
+          "model",
+          "contents",
+          "systemInstruction",
+          "tools",
+          "generationConfig",
+          "safetySettings",
+          "toolConfig"
+        ]
+      },
       { "action": "snapshot", "phase": "compat-post" }
     ]
   },

package/dist/conversion/config/config-manager.d.ts

@@ -0,0 +1,212 @@
+/**
+ * 配置管理模块
+ *
+ * 提供统一的配置读取、设置和管理功能
+ */
+/**
+ * 配置接口定义
+ */
+export interface ConversionConfig {
+    /** HTTP服务器配置 */
+    httpserver?: {
+        port: number;
+        host: string;
+    };
+    /** 虚拟路由器配置 */
+    virtualrouter?: {
+        inputProtocol?: string;
+        outputProtocol?: string;
+        providers?: Record<string, ProviderConfig>;
+        routing?: {
+            default?: string[];
+            [key: string]: string[];
+        };
+    };
+    /** 服务工具配置 */
+    serverTools?: {
+        replace?: Record<string, {
+            enabled: boolean;
+        }>;
+        enabled?: boolean;
+    };
+    /** 转换配置（V2/V3 版本切换相关） */
+    conversion?: {
+        /** 默认使用的转换版本 */
+        defaultVersion?: 'v2' | 'v3' | 'auto';
+        /** 允许附加自定义配置字段 */
+        [key: string]: unknown;
+    };
+}
+/**
+ * Provider 配置接口
+ */
+export interface ProviderConfig {
+    id: string;
+    enabled: boolean;
+    type: 'openai' | 'anthropic' | 'responses' | 'gemini' | 'custom';
+    baseUrl?: string;
+    apiKey?: string[];
+    auth?: {
+        type: 'apikey' | 'oauth';
+        apiKey?: string;
+    };
+    models?: Record<string, ModelConfig>;
+}
+/**
+ * 模型配置接口
+ */
+export interface ModelConfig {
+    supportsStreaming?: boolean;
+    compatibility?: {
+        type?: string;
+        config?: any;
+    };
+}
+/**
+ * 配置管理器类
+ */
+export declare class ConfigManager {
+    private static instance;
+    private config;
+    private constructor();
+    /**
+     * 获取单例实例
+     */
+    static getInstance(): ConfigManager;
+    /**
+     * 设置配置
+     *
+     * @param config 要设置的配置
+     * @param options 选项
+     */
+    static setConfig(config: Partial<ConversionConfig>, options?: {
+        merge?: boolean;
+        validate?: boolean;
+        save?: boolean;
+        source?: string;
+    }): void;
+    /**
+     * 获取配置
+     *
+     * @param path 指定配置路径（可选）
+     * @returns 配置对象
+     */
+    static getConfig(path?: string): Promise<ConversionConfig>;
+    /**
+     * 重新加载配置
+     */
+    static reloadConfig(): Promise<ConversionConfig>;
+    /**
+     * 验证配置
+     */
+    private validateConfig;
+    /**
+     * 深度合并对象（仅在内存中操作，不做任何持久化）
+     */
+    private deepMerge;
+    /**
+     * 获取配置摘要
+     */
+    static getConfigSummary(): {
+        totalProviders: number;
+        enabledProviders: string[];
+        outputProtocol: string;
+        inputProtocol: string;
+        routingDefaults: string[];
+        hasConversionConfig: boolean;
+    };
+    /**
+     * 获取 provider 配置
+     */
+    static getProviderConfig(providerName: string): ProviderConfig | null;
+    /**
+     * 检查 provider 是否可用
+     */
+    static isProviderEnabled(providerName: string): boolean;
+    /**
+     * 设置 provider 启用状态
+     */
+    static setProviderEnabled(providerName: string, enabled: boolean): void;
+    /**
+    /**
+     * 获取输出协议
+     */
+    static getOutputProtocol(): string;
+    /**
+     * 设置输出协议
+     */
+    static setOutputProtocol(protocol: string): void;
+    /**
+     * 获取输入协议
+     */
+    static getInputProtocol(): string;
+    /**
+     * 设置输入协议
+     */
+    static setInputProtocol(protocol: string): void;
+    /**
+   * 获取路由配置
+     */
+    static getRoutingConfig(): any;
+    /**
+   * 设置路由配置
+     */
+    static setRoutingConfig(routing: any): void;
+    /**
+   * 获取 V3 转换配置
+     */
+    static getConversionConfig(): any;
+    /**
+    * 设置 V3 转换配置
+     */
+    static setConversionConfig(conversion: any): void;
+}
+/**
+ * 便捷函数：设置配置
+ */
+export declare function setConfig(config: Partial<ConversionConfig>, options?: {
+    merge?: boolean;
+    validate?: boolean;
+    save?: boolean;
+    source?: string;
+}): void;
+/**
+ * 便捷函数：获取配置
+ */
+export declare function getConfig(path?: string): Promise<ConversionConfig>;
+/**
+ * 便捷函数：重新加载配置
+ */
+export declare function reloadConfig(): Promise<ConversionConfig>;
+/**
+ * 便捷函数：获取配置摘要
+ */
+export declare function getConfigSummary(): ReturnType<typeof ConfigManager.getConfigSummary>;
+/**
+ * 便捷函数：获取 Provider 配置
+ */
+export declare function getProviderConfig(providerName: string): ProviderConfig | null;
+/**
+ * 便捷函数：检查 Provider 状态
+ */
+export declare function isProviderEnabled(providerName: string): boolean;
+/**
+ * 便捷函数：设置 Provider 状态
+ */
+export declare function setProviderEnabled(providerName: string, enabled: boolean): void;
+/**
+ * 便捷函数：获取输出协议
+ */
+export declare function getOutputProtocol(): string;
+/**
+ * 便捷函数：设置输出协议
+ */
+export declare function setOutputProtocol(protocol: string): void;
+/**
+ * 便捷函数：获取输入协议
+ */
+export declare function getInputProtocol(): string;
+/**
+ * 便捷函数：设置输入协议
+ */
+export declare function setInputProtocol(protocol: string): void;

package/dist/conversion/hub/config/types.d.ts

@@ -0,0 +1,26 @@
+export type MappingDirection = 'inbound' | 'outbound';
+export interface FieldMapping {
+    readonly id: string;
+    readonly target: string;
+    readonly path: string;
+    readonly description: string;
+    readonly required?: boolean;
+    readonly transformNotes?: string;
+}
+export interface FormatMappingConfig {
+    readonly description: string;
+    readonly inbound: readonly FieldMapping[];
+    readonly outbound: readonly FieldMapping[];
+}
+export interface SemanticRule {
+    readonly id: string;
+    readonly appliesTo: MappingDirection | 'both';
+    readonly description: string;
+    readonly notes?: string;
+}
+export interface ProtocolConfigDocument {
+    readonly protocol: string;
+    readonly specReference: string;
+    readonly format: FormatMappingConfig;
+    readonly semanticRules: readonly SemanticRule[];
+}

package/dist/conversion/hub/core/detour-registry.d.ts

@@ -0,0 +1,9 @@
+import type { DetourEntry, DetourState } from '../types/chat-schema.js';
+import type { HubDirection } from './hub-context.js';
+export declare class DetourRegistry {
+    private readonly inbound;
+    private readonly outbound;
+    add(direction: HubDirection, entry: DetourEntry): void;
+    snapshot(): DetourState;
+    drain(direction: HubDirection): readonly DetourEntry[];
+}

package/dist/conversion/hub/core/hub-context.d.ts

@@ -0,0 +1,21 @@
+import type { JsonObject, JsonValue } from '../types/json.js';
+export type HubDirection = 'inbound' | 'outbound';
+export interface HubContext {
+    readonly requestId: string;
+    readonly protocol: string;
+    readonly direction: HubDirection;
+    readonly routeId?: string;
+    readonly providerId?: string;
+    readonly profileId?: string;
+    readonly endpoint?: string;
+    readonly metadata?: JsonObject;
+}
+export interface StageSnapshot {
+    readonly stage: string;
+    readonly protocol: string;
+    readonly direction: HubDirection;
+    readonly payload: JsonValue;
+}
+export interface StageSnapshotRecorder {
+    record(snapshot: StageSnapshot): void;
+}

package/dist/conversion/hub/core/index.d.ts

@@ -0,0 +1,3 @@
+export * from './hub-context.js';
+export * from './detour-registry.js';
+export * from './stage-driver.js';

package/dist/conversion/hub/core/stage-driver.d.ts

@@ -0,0 +1,30 @@
+import { DetourRegistry } from './detour-registry.js';
+import type { HubContext, HubDirection, StageSnapshotRecorder } from './hub-context.js';
+import type { JsonValue } from '../types/json.js';
+export type HubStageKind = 'format' | 'semantic' | 'config';
+export interface HubStageRuntime {
+    readonly context: HubContext;
+    readonly detours: DetourRegistry;
+}
+export interface HubStageDefinition {
+    readonly name: string;
+    readonly kind: HubStageKind;
+    readonly direction: HubDirection;
+    readonly execute: (input: JsonValue, runtime: HubStageRuntime) => Promise<JsonValue> | JsonValue;
+}
+export interface HubPlan {
+    readonly protocol: string;
+    readonly direction: HubDirection;
+    readonly passthrough?: {
+        readonly mode: 'identity' | 'clone';
+    };
+    readonly stages: readonly HubStageDefinition[];
+}
+export interface RunHubPlanOptions {
+    readonly plan: HubPlan;
+    readonly context: HubContext;
+    readonly initialInput: JsonValue;
+    readonly recorder?: StageSnapshotRecorder;
+    readonly detours?: DetourRegistry;
+}
+export declare function runHubPlan(options: RunHubPlanOptions): Promise<JsonValue>;

package/dist/conversion/hub/format-adapters/anthropic-format-adapter.d.ts

@@ -0,0 +1,16 @@
+import type { FormatAdapter } from './index.js';
+import type { AdapterContext } from '../types/chat-envelope.js';
+import type { FormatEnvelope } from '../types/format-envelope.js';
+import type { JsonObject, JsonValue } from '../types/json.js';
+interface AnthropicFormatPayload extends JsonObject {
+    messages?: JsonValue[];
+    tools?: JsonValue[];
+}
+export declare class AnthropicFormatAdapter implements FormatAdapter {
+    readonly protocol = "anthropic-messages";
+    parseRequest(original: JsonObject, _ctx: AdapterContext): Promise<FormatEnvelope<AnthropicFormatPayload>>;
+    buildRequest(format: FormatEnvelope<AnthropicFormatPayload>, _ctx: AdapterContext): Promise<AnthropicFormatPayload>;
+    parseResponse(original: JsonObject, _ctx: AdapterContext): Promise<FormatEnvelope<AnthropicFormatPayload>>;
+    buildResponse(format: FormatEnvelope<AnthropicFormatPayload>, _ctx: AdapterContext): Promise<AnthropicFormatPayload>;
+}
+export {};

package/dist/conversion/hub/format-adapters/chat-format-adapter.d.ts

@@ -0,0 +1,17 @@
+import type { FormatAdapter } from './index.js';
+import type { AdapterContext } from '../types/chat-envelope.js';
+import type { FormatEnvelope } from '../types/format-envelope.js';
+import type { JsonObject, JsonValue } from '../types/json.js';
+interface ChatFormatPayload extends JsonObject {
+    messages?: JsonValue[];
+    tools?: JsonValue[];
+    tool_outputs?: JsonValue[];
+}
+export declare class ChatFormatAdapter implements FormatAdapter {
+    readonly protocol = "openai-chat";
+    parseRequest(original: JsonObject, _ctx: AdapterContext): Promise<FormatEnvelope<ChatFormatPayload>>;
+    buildRequest(format: FormatEnvelope<ChatFormatPayload>, _ctx: AdapterContext): Promise<ChatFormatPayload>;
+    parseResponse(original: JsonObject, _ctx: AdapterContext): Promise<FormatEnvelope<ChatFormatPayload>>;
+    buildResponse(format: FormatEnvelope<ChatFormatPayload>, _ctx: AdapterContext): Promise<ChatFormatPayload>;
+}
+export {};

package/dist/conversion/hub/format-adapters/gemini-format-adapter.d.ts

@@ -0,0 +1,16 @@
+import type { FormatAdapter } from './index.js';
+import type { AdapterContext } from '../types/chat-envelope.js';
+import type { FormatEnvelope } from '../types/format-envelope.js';
+import type { JsonObject } from '../types/json.js';
+interface GeminiFormatPayload extends JsonObject {
+    contents?: JsonObject[];
+    tools?: JsonObject[];
+}
+export declare class GeminiFormatAdapter implements FormatAdapter {
+    readonly protocol = "gemini-chat";
+    parseRequest(original: JsonObject, _ctx: AdapterContext): Promise<FormatEnvelope<GeminiFormatPayload>>;
+    buildRequest(format: FormatEnvelope<GeminiFormatPayload>, _ctx: AdapterContext): Promise<GeminiFormatPayload>;
+    parseResponse(original: JsonObject, _ctx: AdapterContext): Promise<FormatEnvelope<GeminiFormatPayload>>;
+    buildResponse(format: FormatEnvelope<GeminiFormatPayload>, _ctx: AdapterContext): Promise<GeminiFormatPayload>;
+}
+export {};

package/dist/conversion/hub/format-adapters/index.d.ts

@@ -0,0 +1,21 @@
+import type { AdapterContext, ChatEnvelope } from '../types/chat-envelope.js';
+import type { FormatEnvelope } from '../types/format-envelope.js';
+import type { JsonObject } from '../types/json.js';
+export interface FormatAdapter<TRequestPayload extends JsonObject = JsonObject, TResponsePayload extends JsonObject = JsonObject> {
+    readonly protocol: string;
+    parseRequest(original: TRequestPayload, ctx: AdapterContext): Promise<FormatEnvelope<TRequestPayload>> | FormatEnvelope<TRequestPayload>;
+    buildRequest(format: FormatEnvelope, ctx: AdapterContext): Promise<TRequestPayload> | TRequestPayload;
+    parseResponse(original: TResponsePayload, ctx: AdapterContext): Promise<FormatEnvelope<TResponsePayload>> | FormatEnvelope<TResponsePayload>;
+    buildResponse(format: FormatEnvelope, ctx: AdapterContext): Promise<TResponsePayload> | TResponsePayload;
+}
+export interface StageRecorder {
+    record(stage: string, payload: object): void;
+}
+export interface SemanticMapper {
+    toChat(format: FormatEnvelope, ctx: AdapterContext): Promise<ChatEnvelope> | ChatEnvelope;
+    fromChat(chat: ChatEnvelope, ctx: AdapterContext): Promise<FormatEnvelope> | FormatEnvelope;
+}
+export { ChatFormatAdapter } from './chat-format-adapter.js';
+export { AnthropicFormatAdapter } from './anthropic-format-adapter.js';
+export { ResponsesFormatAdapter } from './responses-format-adapter.js';
+export { GeminiFormatAdapter } from './gemini-format-adapter.js';

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

@@ -0,0 +1 @@
+export declare function isHubProtocolEnabled(protocol: string): boolean;

package/dist/conversion/hub/node-support.d.ts

@@ -0,0 +1,19 @@
+import type { StandardizedRequest, ProcessedRequest } from './types/standardized.js';
+import type { HubNodeContext, HubNodeResult } from './types/node.js';
+export interface HubInboundOptions {
+    protocol: string;
+    rawRequest: Record<string, unknown>;
+    nodeContext: HubNodeContext;
+    nodeId: string;
+    inputFormat: string;
+    outputFormat: string;
+    startTime: number;
+}
+export interface HubOutboundOptions {
+    protocol: string;
+    request: StandardizedRequest | ProcessedRequest;
+    nodeContext: HubNodeContext;
+}
+export declare function shouldUseHub(protocol: string): boolean;
+export declare function runHubInboundConversion(options: HubInboundOptions): Promise<HubNodeResult>;
+export declare function runHubOutboundConversion(options: HubOutboundOptions): Promise<Record<string, unknown>>;

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

@@ -95,6 +95,17 @@ function applyMapping(root, mapping, state) {
         case 'remove':
             removePath(root, mapping.path);
             break;
+        case 'shallow_pick': {
+            const allow = new Set(Array.isArray(mapping.allowTopLevel) ? mapping.allowTopLevel : []);
+            const next = {};
+            for (const [key, value] of Object.entries(root)) {
+                if (allow.has(key)) {
+                    next[key] = value;
+                }
+            }
+            replaceRoot(root, next);
+            break;
+        }
         case 'rename':
             renamePath(root, mapping.from, mapping.to);
             break;

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

@@ -23,6 +23,9 @@ export interface CompatStageConfig {
 export type MappingInstruction = {
     action: 'remove';
     path: string;
+} | {
+    action: 'shallow_pick';
+    allowTopLevel: string[];
 } | {
     action: 'rename';
     from: string;

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

@@ -3,8 +3,14 @@ import type { StandardizedRequest, ProcessedRequest } from '../types/standardize
 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';
 export interface HubPipelineConfig {
     virtualRouter: VirtualRouterConfig;
+    /**
+     * Optional: hub-level policy controls (observe-only in V1 Phase 0).
+     * Must remain config-driven and default to off.
+     */
+    policy?: HubPolicyConfig;
     /**
      * 可选：供 VirtualRouterEngine 使用的健康状态持久化存储。
      * 当提供时，VirtualRouterEngine 将在初始化时恢复上一次快照，并在 cooldown/熔断变化时调用 persistSnapshot。
@@ -72,6 +78,7 @@ export declare class HubPipeline {
     updateVirtualRouterConfig(nextConfig: VirtualRouterConfig): void;
     dispose(): void;
     private executeRequestStagePipeline;
+    private resolveClientProtocol;
     execute(request: HubPipelineRequest): Promise<HubPipelineResult>;
     private captureAnthropicAliasMap;
     private shouldCaptureAnthropicAlias;