@jsonstudio/llms 0.4.2

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

@@ -0,0 +1,421 @@
+import { Readable } from 'node:stream';
+import { runHubInboundConversion, runHubOutboundConversion } from '../node-support.js';
+import { VirtualRouterEngine } from '../../../router/virtual-router/engine.js';
+import { defaultSseCodecRegistry } from '../../../sse/index.js';
+import { runHubChatProcess } from '../process/chat-process.js';
+export class HubPipeline {
+    routerEngine;
+    config;
+    constructor(config) {
+        this.config = config;
+        this.routerEngine = new VirtualRouterEngine();
+        this.routerEngine.initialize(config.virtualRouter);
+    }
+    updateVirtualRouterConfig(nextConfig) {
+        if (!nextConfig || typeof nextConfig !== 'object') {
+            throw new Error('HubPipeline updateVirtualRouterConfig requires VirtualRouterConfig payload');
+        }
+        this.config.virtualRouter = nextConfig;
+        this.routerEngine.initialize(nextConfig);
+    }
+    async execute(request) {
+        const normalized = await this.normalizeRequest(request);
+        const nodeResults = [];
+        const inbound = await this.runInboundStage(normalized);
+        nodeResults.push(inbound.nodeResult);
+        const process = await this.runProcessStage(normalized, inbound.standardizedRequest);
+        if (process.nodeResult) {
+            nodeResults.push(process.nodeResult);
+        }
+        const processedRequest = process.processedRequest;
+        const routing = this.routeRequest(processedRequest ?? inbound.standardizedRequest, normalized);
+        const outbound = await this.runOutboundStage(processedRequest ?? inbound.standardizedRequest, normalized, routing.target);
+        nodeResults.push(outbound.nodeResult);
+        const metadata = {
+            ...normalized.metadata,
+            entryEndpoint: normalized.entryEndpoint,
+            providerProtocol: normalized.providerProtocol,
+            stream: normalized.stream,
+            processMode: normalized.processMode,
+            routeHint: normalized.routeHint,
+            target: routing.target
+        };
+        return {
+            requestId: normalized.id,
+            providerPayload: outbound.payload,
+            standardizedRequest: inbound.standardizedRequest,
+            processedRequest,
+            routingDecision: routing.decision,
+            routingDiagnostics: routing.diagnostics,
+            target: routing.target,
+            metadata,
+            nodeResults
+        };
+    }
+    async runInboundStage(normalized) {
+        const hubContext = this.createHubNodeContext(normalized);
+        const inbound = await runHubInboundConversion({
+            protocol: normalized.providerProtocol,
+            rawRequest: normalized.payload,
+            nodeContext: hubContext,
+            nodeId: 'hub-inbound',
+            inputFormat: normalized.entryEndpoint,
+            outputFormat: 'standardized-request',
+            startTime: Date.now()
+        });
+        const standardized = inbound.data?.standardizedRequest;
+        if (!standardized) {
+            throw new Error('Hub inbound pipeline did not return a standardized request');
+        }
+        return {
+            standardizedRequest: standardized,
+            nodeResult: this.convertHubNodeResult('hub-inbound', inbound)
+        };
+    }
+    async runProcessStage(normalized, standardizedRequest) {
+        if (normalized.processMode === 'passthrough') {
+            return {};
+        }
+        const processResult = await runHubChatProcess({
+            request: standardizedRequest,
+            requestId: normalized.id,
+            entryEndpoint: normalized.entryEndpoint,
+            rawPayload: normalized.payload,
+            metadata: normalized.metadata
+        });
+        return {
+            processedRequest: processResult.processedRequest,
+            nodeResult: this.convertV3NodeResult('hub-chat-process', processResult.nodeResult)
+        };
+    }
+    routeRequest(request, normalized) {
+        const metadata = {
+            requestId: normalized.id,
+            entryEndpoint: normalized.entryEndpoint,
+            processMode: normalized.processMode,
+            stream: normalized.stream,
+            direction: normalized.direction,
+            providerProtocol: normalized.providerProtocol,
+            routeHint: normalized.routeHint,
+            stage: normalized.stage
+        };
+        const previousModel = typeof request?.model === 'string'
+            ? request.model
+            : undefined;
+        const result = this.routerEngine.route(request, metadata);
+        this.applyTargetMetadata(normalized.metadata, result.target, result.decision.routeName, previousModel);
+        this.applyTargetToSubject(request, result.target, previousModel);
+        return {
+            target: result.target,
+            decision: result.decision,
+            diagnostics: result.diagnostics
+        };
+    }
+    applyTargetMetadata(metadata, target, routeName, originalModel) {
+        if (!metadata || typeof metadata !== 'object')
+            return;
+        metadata.routeName = routeName;
+        metadata.pipelineId = target.providerKey;
+        metadata.target = target;
+        metadata.providerKey = target.providerKey;
+        metadata.providerType = target.providerType;
+        metadata.modelId = target.modelId;
+        metadata.processMode = target.processMode || 'chat';
+        if (originalModel && typeof originalModel === 'string' && originalModel.trim()) {
+            const trimmed = originalModel.trim();
+            if (typeof metadata.originalModelId !== 'string' || !metadata.originalModelId) {
+                metadata.originalModelId = trimmed;
+            }
+            if (typeof metadata.clientModelId !== 'string' || !metadata.clientModelId) {
+                metadata.clientModelId = trimmed;
+            }
+        }
+        if (typeof target.modelId === 'string' && target.modelId.trim()) {
+            metadata.assignedModelId = target.modelId.trim();
+        }
+    }
+    applyTargetToSubject(subject, target, originalModel) {
+        if (!subject || typeof subject !== 'object')
+            return;
+        const newModel = this.extractModelFromTarget(target);
+        if (!newModel)
+            return;
+        subject.model = newModel;
+        if (subject.parameters && typeof subject.parameters === 'object') {
+            subject.parameters = {
+                ...subject.parameters,
+                model: newModel
+            };
+        }
+        else {
+            subject.parameters = { model: newModel };
+        }
+        subject.metadata = {
+            ...subject.metadata,
+            providerKey: target.providerKey,
+            providerType: target.providerType,
+            processMode: target.processMode || 'chat'
+        };
+        if (!subject.metadata || typeof subject.metadata !== 'object') {
+            subject.metadata = {};
+        }
+        const subjectMeta = subject.metadata;
+        if (originalModel && typeof originalModel === 'string' && originalModel.trim()) {
+            const trimmed = originalModel.trim();
+            if (typeof subjectMeta.originalModelId !== 'string' || !subjectMeta.originalModelId) {
+                subjectMeta.originalModelId = trimmed;
+            }
+            if (typeof subjectMeta.clientModelId !== 'string' || !subjectMeta.clientModelId) {
+                subjectMeta.clientModelId = trimmed;
+            }
+        }
+        subjectMeta.assignedModelId = newModel;
+    }
+    extractModelFromTarget(target) {
+        if (!target || typeof target.providerKey !== 'string') {
+            return null;
+        }
+        if (typeof target.modelId === 'string' && target.modelId.trim()) {
+            return target.modelId.trim();
+        }
+        if (typeof target.runtimeKey === 'string' && target.runtimeKey.length) {
+            const prefix = `${target.runtimeKey}.`;
+            if (target.providerKey.startsWith(prefix)) {
+                const candidate = target.providerKey.slice(prefix.length).trim();
+                if (candidate.length) {
+                    return candidate;
+                }
+            }
+        }
+        const firstDot = target.providerKey.indexOf('.');
+        if (firstDot <= 0 || firstDot === target.providerKey.length - 1) {
+            return null;
+        }
+        const fallback = target.providerKey.slice(firstDot + 1).trim();
+        return fallback.length ? fallback : null;
+    }
+    async runOutboundStage(request, normalized, target) {
+        const outboundProtocol = target?.outboundProfile || normalized.providerProtocol;
+        const outboundContext = this.createHubNodeContext({
+            ...normalized,
+            metadata: {
+                ...normalized.metadata,
+                target
+            }
+        });
+        const start = Date.now();
+        const payload = await runHubOutboundConversion({
+            protocol: outboundProtocol,
+            request,
+            nodeContext: outboundContext
+        });
+        const nodeResult = {
+            id: 'hub-outbound',
+            success: true,
+            metadata: {
+                node: 'hub-outbound',
+                executionTime: Date.now() - start,
+                startTime: start,
+                endTime: Date.now(),
+                dataProcessed: {
+                    messages: request.messages.length,
+                    tools: request.tools?.length ?? 0
+                }
+            }
+        };
+        return { payload, nodeResult };
+    }
+    async normalizeRequest(request) {
+        if (!request || typeof request !== 'object') {
+            throw new Error('HubPipeline requires request payload');
+        }
+        const id = request.id || `req_${Date.now()}`;
+        const endpoint = normalizeEndpoint(request.endpoint);
+        const metadataRecord = {
+            ...(request.metadata ?? {})
+        };
+        const entryEndpoint = typeof metadataRecord.entryEndpoint === 'string'
+            ? normalizeEndpoint(metadataRecord.entryEndpoint)
+            : endpoint;
+        const providerProtocol = typeof metadataRecord.providerProtocol === 'string'
+            ? metadataRecord.providerProtocol
+            : inferProviderProtocol(entryEndpoint);
+        const processMode = metadataRecord.processMode === 'passthrough' ? 'passthrough' : 'chat';
+        const direction = metadataRecord.direction === 'response' ? 'response' : 'request';
+        const stage = metadataRecord.stage === 'outbound' ? 'outbound' : 'inbound';
+        const resolvedReadable = this.unwrapReadable(request.payload);
+        const stream = Boolean(metadataRecord.stream ||
+            resolvedReadable ||
+            (request.payload && typeof request.payload === 'object' && request.payload.stream));
+        const payload = await this.materializePayload(request.payload, {
+            requestId: id,
+            entryEndpoint,
+            providerProtocol,
+            metadata: metadataRecord
+        }, resolvedReadable);
+        const normalizedMetadata = {
+            ...metadataRecord,
+            entryEndpoint,
+            providerProtocol,
+            processMode,
+            direction,
+            stage,
+            stream
+        };
+        const routeHint = typeof metadataRecord.routeHint === 'string' ? metadataRecord.routeHint : undefined;
+        if (routeHint) {
+            normalizedMetadata.routeHint = routeHint;
+        }
+        return {
+            id,
+            endpoint,
+            entryEndpoint,
+            providerProtocol,
+            payload,
+            metadata: normalizedMetadata,
+            processMode,
+            direction,
+            stage,
+            stream,
+            routeHint
+        };
+    }
+    createHubNodeContext(normalized) {
+        return {
+            request: {
+                id: normalized.id,
+                endpoint: normalized.entryEndpoint,
+                context: {
+                    metadata: normalized.metadata
+                }
+            }
+        };
+    }
+    convertHubNodeResult(id, result) {
+        return {
+            id,
+            success: result.success,
+            metadata: result.metadata,
+            error: result.error
+        };
+    }
+    convertV3NodeResult(id, result) {
+        return {
+            id,
+            success: result.success,
+            metadata: result.metadata,
+            error: result.error
+                ? {
+                    code: result.error.code,
+                    message: result.error.message,
+                    details: result.error.details,
+                    cause: result.error.cause
+                }
+                : undefined
+        };
+    }
+    async materializePayload(payload, context, resolvedStream) {
+        const stream = resolvedStream ?? this.unwrapReadable(payload);
+        if (stream) {
+            return await this.convertSsePayload(stream, context);
+        }
+        if (!payload || typeof payload !== 'object') {
+            throw new Error('HubPipeline requires JSON object payload');
+        }
+        return payload;
+    }
+    unwrapReadable(payload) {
+        if (!payload) {
+            return null;
+        }
+        if (payload instanceof Readable) {
+            return payload;
+        }
+        if (payload && typeof payload === 'object' && 'readable' in payload) {
+            const candidate = payload.readable;
+            if (candidate instanceof Readable) {
+                return candidate;
+            }
+        }
+        return null;
+    }
+    async convertSsePayload(stream, context) {
+        const protocol = this.resolveSseProtocol(context);
+        const codec = defaultSseCodecRegistry.get(protocol);
+        try {
+            const result = await codec.convertSseToJson(stream, {
+                requestId: context.requestId,
+                model: this.extractModelHint(context.metadata),
+                direction: 'request'
+            });
+            if (!result || typeof result !== 'object') {
+                throw new Error('SSE conversion returned empty payload');
+            }
+            return result;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error ?? 'Unknown error');
+            throw new Error(`Failed to convert SSE payload for protocol ${protocol}: ${message}`);
+        }
+    }
+    resolveSseProtocol(context) {
+        const providerMeta = context.metadata.provider ?? undefined;
+        const profile = typeof providerMeta?.profile === 'string' ? providerMeta.profile : undefined;
+        const providerProtocol = typeof context.metadata.providerProtocol === 'string'
+            ? context.metadata.providerProtocol
+            : context.providerProtocol;
+        const routeHint = typeof context.metadata.routeHint === 'string'
+            ? context.metadata.routeHint
+            : undefined;
+        return inferSseProtocol(routeHint, providerProtocol, context.entryEndpoint);
+    }
+    extractModelHint(metadata) {
+        if (typeof metadata.model === 'string' && metadata.model.trim()) {
+            return metadata.model;
+        }
+        const provider = metadata.provider;
+        const candidates = [
+            provider?.model,
+            provider?.modelId,
+            provider?.defaultModel
+        ];
+        for (const candidate of candidates) {
+            if (typeof candidate === 'string' && candidate.trim()) {
+                return candidate;
+            }
+        }
+        return undefined;
+    }
+}
+function normalizeEndpoint(endpoint) {
+    if (!endpoint)
+        return '/v1/chat/completions';
+    const trimmed = endpoint.trim();
+    if (!trimmed)
+        return '/v1/chat/completions';
+    const normalized = trimmed.startsWith('/') ? trimmed : `/${trimmed}`;
+    return normalized.replace(/\/{2,}/g, '/');
+}
+function inferProviderProtocol(endpoint) {
+    const lowered = endpoint.toLowerCase();
+    if (lowered.includes('/v1/messages'))
+        return 'anthropic-messages';
+    if (lowered.includes('/v1/responses'))
+        return 'openai-responses';
+    if (lowered.includes('/v1beta'))
+        return 'gemini-chat';
+    return 'openai-chat';
+}
+function inferSseProtocol(routeHint, providerProtocol, entryEndpoint) {
+    const candidates = [routeHint, providerProtocol, entryEndpoint].filter((value) => typeof value === 'string' && value.length > 0);
+    for (const candidate of candidates) {
+        const lowered = candidate.toLowerCase();
+        if (lowered.includes('responses')) {
+            return 'openai-responses';
+        }
+        if (lowered.includes('messages') || lowered.includes('anthropic')) {
+            return 'anthropic-messages';
+        }
+    }
+    return 'openai-chat';
+}

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/inbound.js

@@ -0,0 +1,64 @@
+function recordStage(recorder, stage, payload) {
+    if (!recorder)
+        return;
+    try {
+        recorder.record(stage, payload);
+    }
+    catch {
+        /* snapshot failures ignored */
+    }
+}
+function ensureFormatEnvelope(envelope, rawRequest, plan, context) {
+    if (envelope)
+        return envelope;
+    return {
+        protocol: plan.protocol || context.providerProtocol,
+        direction: 'request',
+        payload: rawRequest
+    };
+}
+export async function runInboundPipeline(options) {
+    const { rawRequest, context, plan, stageRecorder } = options;
+    if (!plan)
+        throw new Error('Inbound plan is required');
+    if (plan.passthrough?.mode === 'chat') {
+        if (!plan.passthrough.factory) {
+            throw new Error('Inbound passthrough requires factory');
+        }
+        const envelope = await plan.passthrough.factory(rawRequest, context);
+        recordStage(stageRecorder, 'inbound_passthrough', envelope);
+        return envelope;
+    }
+    if (!Array.isArray(plan.stages) || plan.stages.length === 0) {
+        throw new Error('Inbound plan must declare stages or passthrough');
+    }
+    let lastFormat;
+    let lastChat;
+    for (const stage of plan.stages) {
+        switch (stage) {
+            case 'format_parse': {
+                if (!plan.formatAdapter) {
+                    throw new Error('format_parse stage requires format adapter');
+                }
+                lastFormat = await plan.formatAdapter.parseRequest(rawRequest, context);
+                recordStage(stageRecorder, 'format_parse', lastFormat);
+                break;
+            }
+            case 'semantic_map_to_chat': {
+                if (!plan.semanticMapper) {
+                    throw new Error('semantic_map_to_chat stage requires semantic mapper');
+                }
+                const formatEnvelope = ensureFormatEnvelope(lastFormat, rawRequest, plan, context);
+                lastChat = await plan.semanticMapper.toChat(formatEnvelope, context);
+                recordStage(stageRecorder, 'semantic_map_to_chat', lastChat);
+                break;
+            }
+            default:
+                throw new Error(`Unknown inbound stage: ${stage}`);
+        }
+    }
+    if (!lastChat) {
+        throw new Error('Inbound pipeline did not produce ChatEnvelope');
+    }
+    return lastChat;
+}

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/pipelines/outbound.js

@@ -0,0 +1,57 @@
+function recordStage(recorder, stage, payload) {
+    if (!recorder)
+        return;
+    try {
+        recorder.record(stage, payload);
+    }
+    catch {
+        /* ignore recorder errors */
+    }
+}
+export async function runOutboundPipeline(options) {
+    const { chat, context, plan, stageRecorder } = options;
+    if (!plan)
+        throw new Error('Outbound plan is required');
+    if (plan.passthrough?.mode === 'protocol') {
+        if (!plan.passthrough.factory) {
+            throw new Error('Outbound passthrough requires factory');
+        }
+        const payload = await plan.passthrough.factory(chat, context);
+        recordStage(stageRecorder, 'outbound_passthrough', payload);
+        return payload;
+    }
+    if (!Array.isArray(plan.stages) || plan.stages.length === 0) {
+        throw new Error('Outbound plan must declare stages or passthrough');
+    }
+    let formatEnvelope;
+    let finalPayload;
+    for (const stage of plan.stages) {
+        switch (stage) {
+            case 'semantic_map_from_chat': {
+                if (!plan.semanticMapper) {
+                    throw new Error('semantic_map_from_chat stage requires semantic mapper');
+                }
+                formatEnvelope = await plan.semanticMapper.fromChat(chat, context);
+                recordStage(stageRecorder, 'semantic_map_from_chat', formatEnvelope);
+                break;
+            }
+            case 'format_build': {
+                if (!plan.formatAdapter) {
+                    throw new Error('format_build stage requires format adapter');
+                }
+                if (!formatEnvelope) {
+                    throw new Error('format_build stage requires semantic_map_from_chat result');
+                }
+                finalPayload = await plan.formatAdapter.buildResponse(formatEnvelope, context);
+                recordStage(stageRecorder, 'format_build', finalPayload);
+                break;
+            }
+            default:
+                throw new Error(`Unknown outbound stage: ${stage}`);
+        }
+    }
+    if (finalPayload === undefined) {
+        throw new Error('Outbound pipeline did not produce payload');
+    }
+    return finalPayload;
+}

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

@@ -0,0 +1,13 @@
+import { type NodeResult as V3NodeResult } from '../../conversion-v3/types/index.js';
+import type { StandardizedRequest, ProcessedRequest } from '../types/standardized.js';
+export interface HubChatProcessResult {
+    processedRequest?: ProcessedRequest;
+    nodeResult: V3NodeResult;
+}
+export declare function runHubChatProcess(options: {
+    request: StandardizedRequest;
+    requestId: string;
+    entryEndpoint: string;
+    rawPayload: Record<string, unknown>;
+    metadata: Record<string, unknown>;
+}): Promise<HubChatProcessResult>;

package/dist/conversion/hub/process/chat-process.js

@@ -0,0 +1,50 @@
+import { ChatProcessNode } from '../../conversion-v3/nodes/process/chat-process-node.js';
+import { NodeType } from '../../conversion-v3/types/index.js';
+const CHAT_PROCESS_CONFIG = {
+    id: 'hub-chat-process',
+    type: NodeType.PROCESS,
+    name: 'Hub Chat Process Node',
+    inputFormat: 'standardized-request',
+    outputFormat: 'processed-request',
+    rules: [],
+    validation: {
+        strict: false,
+        required: [],
+        optional: []
+    },
+    timeout: 30_000,
+    options: {}
+};
+const chatProcessNode = new ChatProcessNode(CHAT_PROCESS_CONFIG);
+export async function runHubChatProcess(options) {
+    const nodeContext = buildProcessNodeContext(options);
+    const result = await chatProcessNode.execute(nodeContext);
+    return {
+        processedRequest: result.success ? result.data?.processedRequest : undefined,
+        nodeResult: result
+    };
+}
+function buildProcessNodeContext(options) {
+    return {
+        request: {
+            id: options.requestId,
+            timestamp: Date.now(),
+            endpoint: options.entryEndpoint,
+            payload: options.rawPayload,
+            context: {
+                metadata: options.metadata
+            }
+        },
+        data: {
+            standardizedRequest: options.request
+        },
+        pipeline: {
+            currentNode: CHAT_PROCESS_CONFIG.id,
+            previousResults: [],
+            isPassthrough: false,
+            startTime: Date.now()
+        },
+        nodeConfig: CHAT_PROCESS_CONFIG,
+        callbacks: null
+    };
+}

package/dist/conversion/hub/registry.d.ts

@@ -0,0 +1,28 @@
+import type { InboundPlan, InboundPassthroughConfig, InboundStage } from './pipelines/inbound.js';
+import type { OutboundPlan, OutboundPassthroughConfig, OutboundStage } from './pipelines/outbound.js';
+import type { FormatAdapter, SemanticMapper } from './format-adapters/index.js';
+interface InboundPlanFactory {
+    protocol: string;
+    stages: InboundStage[];
+    passthrough?: InboundPassthroughConfig;
+    createFormatAdapter?: () => FormatAdapter;
+    createSemanticMapper?: () => SemanticMapper;
+}
+interface OutboundPlanFactory {
+    protocol: string;
+    stages: OutboundStage[];
+    passthrough?: OutboundPassthroughConfig;
+    createFormatAdapter?: () => FormatAdapter;
+    createSemanticMapper?: () => SemanticMapper;
+}
+export interface HubProtocolDefinition {
+    protocol: string;
+    inbound: InboundPlanFactory;
+    outbound: OutboundPlanFactory;
+}
+export declare const HUB_PROTOCOL_REGISTRY: Record<string, HubProtocolDefinition>;
+export declare function createProtocolPlans(protocol: string): {
+    inbound: InboundPlan;
+    outbound: OutboundPlan;
+};
+export {};