@jsonstudio/llms 0.4.3 → 0.4.5

package/dist/conversion/conversion-v3/validations/tool-governance-enforcer.d.ts

@@ -1,139 +0,0 @@
-/**
- * 工具治理强制器
- * 确保工具修改权限的强制执行和违规检测
- */
-import type { PipelineContext, PipelineNodeKind, NodeCapabilities } from '../standards/pipeline-context.js';
-/**
- * 节点图配置接口
- */
-export interface PipelineConfig {
-    pipelines: PipelineConfigEntry[];
-}
-export interface PipelineConfigEntry {
-    id: string;
-    name?: string;
-    entryEndpoints: string[];
-    providerProtocols: string[];
-    processMode: 'chat' | 'passthrough';
-    streaming: 'always' | 'never' | 'auto';
-    nodes: PipelineNodeConfig[];
-}
-export interface PipelineNodeConfig {
-    id: string;
-    kind: PipelineNodeKind;
-    implementation: string;
-    options?: Record<string, unknown>;
-}
-/**
- * 工具治理违规错误
- */
-export declare class ToolGovernanceViolationError extends Error {
-    readonly nodeId: string;
-    readonly violation: ToolGovernanceViolation;
-    constructor(message: string, nodeId: string, violation: ToolGovernanceViolation);
-}
-/**
- * 工具治理违规类型
- */
-export interface ToolGovernanceViolation {
-    type: 'unauthorized-tool-modification' | 'invalid-node-type' | 'missing-governance-node';
-    nodeId: string;
-    nodeKind: PipelineNodeKind;
-    severity: 'error' | 'warning';
-    description: string;
-    suggestion?: string;
-}
-/**
- * 工具治理强制器
- * 负责验证和强制执行工具修改权限
- */
-export declare class ToolGovernanceEnforcer {
-    /** 授权的工具修改节点ID集合 */
-    private static readonly AUTHORIZED_TOOL_MODIFICATION_NODES;
-    /** 授权的工具修改节点类型 */
-    private static readonly AUTHORIZED_TOOL_MODIFICATION_KINDS;
-    /** 必须存在的工具治理节点（每个流水线至少一个） */
-    private static readonly REQUIRED_GOVERNANCE_NODES;
-    /**
-     * 验证节点执行权限
-     */
-    static validateNodeExecution(nodeId: string, nodeKind: PipelineNodeKind, capabilities: NodeCapabilities, context?: PipelineContext): void;
-    /**
-     * 验证工具修改权限
-     */
-    private static validateToolModificationPermission;
-    /**
-     * 验证 Provider 访问权限
-     */
-    private static validateProviderAccessPermission;
-    /**
-     * 验证流式处理权限
-     */
-    private static validateStreamingPermission;
-    /**
-     * 验证上下文权限
-     */
-    private static validateContextPermissions;
-    /**
-     * 检查是否为工具治理节点
-     */
-    private static isToolGovernanceNode;
-    /**
-     * 检查是否为授权的工具节点
-     */
-    private static isAuthorizedToolNode;
-    /**
-     * 检查上下文中是否已有工具治理节点执行过
-     */
-    private static hasToolGovernanceExecuted;
-    /**
-     * 标记工具治理已执行
-     */
-    static markToolGovernanceApplied(context: PipelineContext): void;
-    /**
-     * 验证节点图配置
-     */
-    static validateNodeGraph(pipelineConfig: PipelineConfig): ToolGovernanceValidationResult;
-    /**
-     * 验证单个流水线
-     */
-    private static validateSinglePipeline;
-    /**
-     * 检查节点是否可以修改工具（基于配置推断）
-     */
-    private static nodeCanModifyTools;
-    /**
-     * 运行时监控节点执行
-     */
-    static monitorNodeExecution(nodeId: string, nodeKind: PipelineNodeKind, context: PipelineContext): ToolGovernanceMonitorResult;
-    /**
-     * 检测工具修改痕迹
-     */
-    private static detectToolModification;
-    /**
-     * 生成改进建议
-     */
-    private static generateRecommendations;
-}
-/**
- * 工具治理验证结果接口
- */
-export interface ToolGovernanceValidationResult {
-    /** 是否验证通过 */
-    valid: boolean;
-    /** 违规列表 */
-    violations: ToolGovernanceViolation[];
-    /** 警告列表 */
-    warnings: ToolGovernanceViolation[];
-}
-/**
- * 工具治理监控结果接口
- */
-export interface ToolGovernanceMonitorResult {
-    /** 是否合规 */
-    compliant: boolean;
-    /** 问题列表 */
-    issues: string[];
-    /** 改进建议 */
-    recommendations: string[];
-}

package/dist/conversion/conversion-v3/validations/tool-governance-enforcer.js

@@ -1,338 +0,0 @@
-/**
- * 工具治理强制器
- * 确保工具修改权限的强制执行和违规检测
- */
-/**
- * 工具治理违规错误
- */
-export class ToolGovernanceViolationError extends Error {
-    nodeId;
-    violation;
-    constructor(message, nodeId, violation) {
-        super(message);
-        this.nodeId = nodeId;
-        this.violation = violation;
-        this.name = 'ToolGovernanceViolationError';
-    }
-}
-/**
- * 工具治理强制器
- * 负责验证和强制执行工具修改权限
- */
-export class ToolGovernanceEnforcer {
-    /** 授权的工具修改节点ID集合 */
-    static AUTHORIZED_TOOL_MODIFICATION_NODES = new Set([
-        'tool-process',
-        'chat-process',
-        'tool-canonicalizer',
-        'tool-harvester'
-    ]);
-    /** 授权的工具修改节点类型 */
-    static AUTHORIZED_TOOL_MODIFICATION_KINDS = new Set(['process']);
-    /** 必须存在的工具治理节点（每个流水线至少一个） */
-    static REQUIRED_GOVERNANCE_NODES = new Set([
-        'tool-process',
-        'chat-process'
-    ]);
-    /**
-     * 验证节点执行权限
-     */
-    static validateNodeExecution(nodeId, nodeKind, capabilities, context) {
-        // 检查工具修改权限
-        if (capabilities.canModifyTools) {
-            this.validateToolModificationPermission(nodeId, nodeKind, capabilities);
-        }
-        // 检查 Provider 访问权限
-        if (capabilities.canAccessProvider) {
-            this.validateProviderAccessPermission(nodeId, nodeKind);
-        }
-        // 检查流式处理权限
-        if (capabilities.canHandleStreaming) {
-            this.validateStreamingPermission(nodeId, nodeKind);
-        }
-        // 在执行上下文中验证
-        if (context) {
-            this.validateContextPermissions(nodeId, capabilities, context);
-        }
-    }
-    /**
-     * 验证工具修改权限
-     */
-    static validateToolModificationPermission(nodeId, nodeKind, capabilities) {
-        // 检查节点类型
-        if (!this.AUTHORIZED_TOOL_MODIFICATION_KINDS.has(nodeKind)) {
-            throw new ToolGovernanceViolationError(`Node '${nodeId}' (${nodeKind}) is not authorized to modify tools. Tool modification is only allowed in 'process' nodes.`, nodeId, {
-                type: 'unauthorized-tool-modification',
-                nodeId,
-                nodeKind,
-                severity: 'error',
-                description: 'Only process nodes can modify tools',
-                suggestion: `Use an authorized tool-process node or move logic into chat-process`
-            });
-        }
-        // 检查特定节点ID
-        if (!this.isAuthorizedToolNode(nodeId)) {
-            throw new ToolGovernanceViolationError(`Node '${nodeId}' is not authorized to modify tools. Only specific process nodes can modify tools.`, nodeId, {
-                type: 'unauthorized-tool-modification',
-                nodeId,
-                nodeKind,
-                severity: 'error',
-                description: `Node '${nodeId}' is not in the authorized list for tool modification`,
-                suggestion: `Use one of the authorized nodes: ${Array.from(this.AUTHORIZED_TOOL_MODIFICATION_NODES).join(', ')}`
-            });
-        }
-    }
-    /**
-     * 验证 Provider 访问权限
-     */
-    static validateProviderAccessPermission(nodeId, nodeKind) {
-        if (nodeKind !== 'provider') {
-            throw new ToolGovernanceViolationError(`Node '${nodeId}' (${nodeKind}) is not authorized to access providers directly. Only provider nodes can access external providers.`, nodeId, {
-                type: 'unauthorized-tool-modification',
-                nodeId,
-                nodeKind,
-                severity: 'error',
-                description: 'Only provider nodes can directly access external providers',
-                suggestion: `Move provider access logic to a provider node`
-            });
-        }
-    }
-    /**
-     * 验证流式处理权限
-     */
-    static validateStreamingPermission(nodeId, nodeKind) {
-        const allowedStreamingKinds = new Set(['sse-input', 'sse-output']);
-        if (!allowedStreamingKinds.has(nodeKind) && !nodeId.includes('streaming')) {
-            throw new ToolGovernanceViolationError(`Node '${nodeId}' (${nodeKind}) is not authorized to handle streaming data. Only SSE nodes and streaming control nodes can handle streaming.`, nodeId, {
-                type: 'unauthorized-tool-modification',
-                nodeId,
-                nodeKind,
-                severity: 'error',
-                description: 'Only SSE nodes and streaming control nodes can handle streaming data',
-                suggestion: `Use SSE nodes or add 'streaming' to node ID for streaming control`
-            });
-        }
-    }
-    /**
-     * 验证上下文权限
-     */
-    static validateContextPermissions(nodeId, capabilities, context) {
-        // 对于所有工具修改节点，检查是否已有工具治理节点执行过
-        if (capabilities.canModifyTools) {
-            if (!this.hasToolGovernanceExecuted(context)) {
-                // 只有工具治理节点本身可以在没有治理执行的情况下运行
-                if (!this.isToolGovernanceNode(nodeId)) {
-                    throw new ToolGovernanceViolationError(`Node '${nodeId}' attempting to modify tools without prior tool governance execution.`, nodeId, {
-                        type: 'missing-governance-node',
-                        nodeId,
-                        nodeKind: 'process',
-                        severity: 'error',
-                        description: 'Tool modification requires prior governance execution',
-                        suggestion: 'Ensure a tool-process node executes before any tool modification node'
-                    });
-                }
-            }
-        }
-    }
-    /**
-     * 检查是否为工具治理节点
-     */
-    static isToolGovernanceNode(nodeId) {
-        return nodeId === 'tool-process' ||
-            nodeId.includes('tool-process');
-    }
-    /**
-     * 检查是否为授权的工具节点
-     */
-    static isAuthorizedToolNode(nodeId) {
-        return this.AUTHORIZED_TOOL_MODIFICATION_NODES.has(nodeId) ||
-            nodeId.includes('tool-process') ||
-            nodeId.includes('chat-process') ||
-            nodeId.includes('tool-canonicalizer') ||
-            nodeId.includes('tool-harvester');
-    }
-    /**
-     * 检查上下文中是否已有工具治理节点执行过
-     */
-    static hasToolGovernanceExecuted(context) {
-        // 首先检查显式的治理状态标记
-        if (context.metadata.toolGovernanceApplied === true) {
-            return true;
-        }
-        // 如果没有显式标记，检查调试阶段中是否有工具治理节点
-        const toolGovernanceStages = Object.keys(context.debug.stages)
-            .filter(stage => stage.includes('tool-process') ||
-            stage.includes('tool-canonicalizer'));
-        return toolGovernanceStages.length > 0;
-    }
-    /**
-     * 标记工具治理已执行
-     */
-    static markToolGovernanceApplied(context) {
-        context.metadata.toolGovernanceApplied = true;
-        context.metadata.toolGovernanceTimestamp = Date.now();
-    }
-    /**
-     * 验证节点图配置
-     */
-    static validateNodeGraph(pipelineConfig) {
-        const violations = [];
-        const warnings = [];
-        // 验证每个流水线
-        for (const pipeline of pipelineConfig.pipelines) {
-            const pipelineValidation = this.validateSinglePipeline(pipeline);
-            violations.push(...pipelineValidation.violations);
-            warnings.push(...pipelineValidation.warnings);
-        }
-        return {
-            valid: violations.length === 0,
-            violations,
-            warnings
-        };
-    }
-    /**
-     * 验证单个流水线
-     */
-    static validateSinglePipeline(pipeline) {
-        const violations = [];
-        const warnings = [];
-        const toolModificationNodes = pipeline.nodes.filter(node => this.nodeCanModifyTools(node));
-        // 检查是否有工具修改节点
-        if (toolModificationNodes.length === 0) {
-            violations.push({
-                type: 'missing-governance-node',
-                nodeId: 'pipeline',
-                nodeKind: 'process',
-                severity: 'error',
-                description: `Pipeline '${pipeline.id}' must contain at least one tool governance node`,
-                suggestion: `Add 'tool-process' or 'chat-process' node to the pipeline`
-            });
-        }
-        // 检查工具修改节点类型
-        for (const node of toolModificationNodes) {
-            if (node.kind !== 'process') {
-                violations.push({
-                    type: 'invalid-node-type',
-                    nodeId: node.id,
-                    nodeKind: node.kind,
-                    severity: 'error',
-                    description: `Tool modification node '${node.id}' must be of kind 'process'`,
-                    suggestion: `Change node '${node.id}' kind to 'process'`
-                });
-            }
-        }
-        // 检查节点ID授权
-        for (const node of toolModificationNodes) {
-            if (!this.isAuthorizedToolNode(node.id)) {
-                warnings.push({
-                    type: 'unauthorized-tool-modification',
-                    nodeId: node.id,
-                    nodeKind: node.kind,
-                    severity: 'warning',
-                    description: `Node '${node.id}' may not be authorized for tool modification`,
-                    suggestion: `Consider using standard tool governance nodes or add to authorized list`
-                });
-            }
-        }
-        // 检查必需的工具治理节点
-        const governanceNodeIndex = pipeline.nodes.findIndex(node => this.REQUIRED_GOVERNANCE_NODES.has(node.id));
-        if (governanceNodeIndex === -1 && toolModificationNodes.length > 0) {
-            // 如果有工具修改节点但没有必需的治理节点，这是一个错误
-            violations.push({
-                type: 'missing-governance-node',
-                nodeId: 'pipeline',
-                nodeKind: 'process',
-                severity: 'error',
-                description: `Pipeline '${pipeline.id}' contains tool modification nodes but lacks required governance nodes (tool-process or chat-process)`,
-                suggestion: `Add either 'tool-process' or 'chat-process' node to enforce tool governance before tool modification`
-            });
-        }
-        else if (governanceNodeIndex > 0) {
-            // 如果有治理节点但位置不正确，这是一个警告
-            warnings.push({
-                type: 'missing-governance-node',
-                nodeId: pipeline.nodes[governanceNodeIndex].id,
-                nodeKind: pipeline.nodes[governanceNodeIndex].kind,
-                severity: 'warning',
-                description: `Tool governance node should be positioned earlier in the pipeline`,
-                suggestion: `Move tool governance node to the beginning of the process stage`
-            });
-        }
-        return {
-            valid: violations.length === 0,
-            violations,
-            warnings
-        };
-    }
-    /**
-     * 检查节点是否可以修改工具（基于配置推断）
-     */
-    static nodeCanModifyTools(node) {
-        // 基于节点ID和实现名称推断
-        const toolModificationPatterns = [
-            'tool',
-            'governance',
-            'canonicalizer',
-            'harvester',
-            'chat-process'
-        ];
-        return toolModificationPatterns.some(pattern => node.id.includes(pattern) ||
-            node.implementation.includes(pattern));
-    }
-    /**
-     * 运行时监控节点执行
-     */
-    static monitorNodeExecution(nodeId, nodeKind, context) {
-        const issues = [];
-        // 检查工具修改痕迹
-        const toolModificationDetected = this.detectToolModification(nodeId, context);
-        if (toolModificationDetected && !this.isAuthorizedToolNode(nodeId)) {
-            issues.push(`Unauthorized tool modification detected in node '${nodeId}'`);
-        }
-        // 检查上下文完整性
-        if (!context.request && !context.response) {
-            issues.push(`Node '${nodeId}' executed without proper request/response context`);
-        }
-        // 检查错误传播
-        if (context.metadata.errorContext) {
-            const errorContext = context.metadata.errorContext;
-            if (errorContext.nodeId !== nodeId) {
-                issues.push(`Error context from different node detected: ${errorContext.nodeId}`);
-            }
-        }
-        return {
-            compliant: issues.length === 0,
-            issues,
-            recommendations: this.generateRecommendations(nodeId, nodeKind, context)
-        };
-    }
-    /**
-     * 检测工具修改痕迹
-     */
-    static detectToolModification(nodeId, context) {
-        const debugStage = context.debug.stages[`${nodeId}:complete`];
-        if (!debugStage)
-            return false;
-        // 检查调试数据中是否包含工具相关信息
-        const debugData = JSON.stringify(debugStage);
-        return debugData.includes('tools') || debugData.includes('tool_calls');
-    }
-    /**
-     * 生成改进建议
-     */
-    static generateRecommendations(nodeId, nodeKind, context) {
-        const recommendations = [];
-        // 基于节点类型提供建议
-        if (nodeKind === 'process' && !this.isAuthorizedToolNode(nodeId)) {
-            recommendations.push(`Consider implementing tool governance in node '${nodeId}'`);
-        }
-        // 基于上下文状态提供建议
-        if (!context.debug.traceEnabled) {
-            recommendations.push('Enable debug tracing for better governance monitoring');
-        }
-        if (!context.snapshots) {
-            recommendations.push('Enable snapshot support for debugging tool governance');
-        }
-        return recommendations;
-    }
-}

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

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

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

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

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

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

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

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

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

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

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

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

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

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