@jsonstudio/llms 0.4.2

package/dist/router/virtual-router/health-manager.js

@@ -0,0 +1,98 @@
+const DEFAULT_CONFIG = {
+    failureThreshold: 3,
+    cooldownMs: 30_000,
+    fatalCooldownMs: 120_000
+};
+export class ProviderHealthManager {
+    states = new Map();
+    config = DEFAULT_CONFIG;
+    configure(config) {
+        if (config) {
+            const normalizedCooldown = Math.max(5_000, config.cooldownMs ?? DEFAULT_CONFIG.cooldownMs);
+            const fatalCooldownCandidate = config.fatalCooldownMs ?? DEFAULT_CONFIG.fatalCooldownMs ?? normalizedCooldown;
+            this.config = {
+                failureThreshold: Math.max(1, config.failureThreshold ?? DEFAULT_CONFIG.failureThreshold),
+                cooldownMs: normalizedCooldown,
+                fatalCooldownMs: Math.max(fatalCooldownCandidate, normalizedCooldown)
+            };
+        }
+    }
+    registerProviders(providerKeys) {
+        for (const key of providerKeys) {
+            if (!this.states.has(key)) {
+                this.states.set(key, {
+                    providerKey: key,
+                    state: 'healthy',
+                    failureCount: 0
+                });
+            }
+        }
+    }
+    recordFailure(providerKey, reason) {
+        const state = this.getState(providerKey);
+        state.failureCount += 1;
+        state.lastFailureAt = Date.now();
+        if (reason) {
+            state.reason = reason;
+        }
+        if (state.failureCount >= this.config.failureThreshold) {
+            state.state = 'tripped';
+            state.cooldownExpiresAt = Date.now() + this.config.cooldownMs;
+            if (reason) {
+                state.reason = reason;
+            }
+        }
+        return state;
+    }
+    recordSuccess(providerKey) {
+        const state = this.getState(providerKey);
+        state.failureCount = 0;
+        state.state = 'healthy';
+        state.cooldownExpiresAt = undefined;
+        state.lastFailureAt = undefined;
+        state.reason = undefined;
+        return state;
+    }
+    tripProvider(providerKey, reason, cooldownOverrideMs) {
+        const state = this.getState(providerKey);
+        state.failureCount = Math.max(state.failureCount, this.config.failureThreshold);
+        state.state = 'tripped';
+        state.reason = reason;
+        const ttl = cooldownOverrideMs ?? this.config.fatalCooldownMs ?? this.config.cooldownMs;
+        state.cooldownExpiresAt = Date.now() + ttl;
+        state.lastFailureAt = Date.now();
+        return state;
+    }
+    isAvailable(providerKey) {
+        const state = this.getState(providerKey);
+        if (state.state === 'healthy') {
+            return true;
+        }
+        if (state.cooldownExpiresAt && Date.now() >= state.cooldownExpiresAt) {
+            this.recordSuccess(providerKey);
+            return true;
+        }
+        return false;
+    }
+    getSnapshot() {
+        return Array.from(this.states.values()).map((state) => ({
+            providerKey: state.providerKey,
+            state: state.state,
+            failureCount: state.failureCount,
+            cooldownExpiresAt: state.cooldownExpiresAt
+        }));
+    }
+    getConfig() {
+        return { ...this.config };
+    }
+    getState(providerKey) {
+        if (!this.states.has(providerKey)) {
+            this.states.set(providerKey, {
+                providerKey,
+                state: 'healthy',
+                failureCount: 0
+            });
+        }
+        return this.states.get(providerKey);
+    }
+}

package/dist/router/virtual-router/load-balancer.d.ts

@@ -0,0 +1,18 @@
+import type { LoadBalancingPolicy } from './types.js';
+export interface LoadBalancingOptions {
+    routeName: string;
+    candidates: string[];
+    stickyKey?: string;
+    availabilityCheck: (providerKey: string) => boolean;
+}
+export declare class RouteLoadBalancer {
+    private policy;
+    private readonly states;
+    constructor(policy?: LoadBalancingPolicy);
+    updatePolicy(policy?: LoadBalancingPolicy): void;
+    select(options: LoadBalancingOptions): string | null;
+    private selectRoundRobin;
+    private selectWeighted;
+    private selectSticky;
+    private getState;
+}

package/dist/router/virtual-router/load-balancer.js

@@ -0,0 +1,67 @@
+export class RouteLoadBalancer {
+    policy;
+    states = new Map();
+    constructor(policy) {
+        this.policy = policy ?? { strategy: 'round-robin' };
+    }
+    updatePolicy(policy) {
+        if (policy) {
+            this.policy = policy;
+        }
+    }
+    select(options) {
+        const available = options.candidates.filter((candidate) => options.availabilityCheck(candidate));
+        if (available.length === 0) {
+            return null;
+        }
+        switch (this.policy.strategy) {
+            case 'sticky':
+                return this.selectSticky(options.routeName, available, options.stickyKey);
+            case 'weighted':
+                return this.selectWeighted(available);
+            default:
+                return this.selectRoundRobin(options.routeName, available);
+        }
+    }
+    selectRoundRobin(routeName, candidates) {
+        const state = this.getState(routeName);
+        const choice = candidates[state.pointer % candidates.length];
+        state.pointer = (state.pointer + 1) % candidates.length;
+        return choice;
+    }
+    selectWeighted(candidates) {
+        if (!this.policy.weights) {
+            return candidates[0];
+        }
+        const weights = candidates.map((candidate) => Math.max(1, this.policy.weights?.[candidate] ?? 1));
+        const total = weights.reduce((sum, weight) => sum + weight, 0);
+        const threshold = Math.random() * total;
+        let running = 0;
+        for (let i = 0; i < candidates.length; i += 1) {
+            running += weights[i];
+            if (running >= threshold) {
+                return candidates[i];
+            }
+        }
+        return candidates[candidates.length - 1];
+    }
+    selectSticky(routeName, candidates, stickyKey) {
+        if (!stickyKey) {
+            return this.selectRoundRobin(routeName, candidates);
+        }
+        const state = this.getState(routeName);
+        const pinned = state.stickyMap.get(stickyKey);
+        if (pinned && candidates.includes(pinned)) {
+            return pinned;
+        }
+        const choice = this.selectRoundRobin(routeName, candidates);
+        state.stickyMap.set(stickyKey, choice);
+        return choice;
+    }
+    getState(routeName) {
+        if (!this.states.has(routeName)) {
+            this.states.set(routeName, { pointer: 0, stickyMap: new Map() });
+        }
+        return this.states.get(routeName);
+    }
+}

package/dist/router/virtual-router/provider-registry.d.ts

@@ -0,0 +1,11 @@
+import type { ProviderProfile, TargetMetadata } from './types.js';
+export declare class ProviderRegistry {
+    private readonly providers;
+    constructor(profiles?: Record<string, ProviderProfile>);
+    load(profiles: Record<string, ProviderProfile>): void;
+    get(providerKey: string): ProviderProfile;
+    has(providerKey: string): boolean;
+    listKeys(): string[];
+    buildTarget(providerKey: string): TargetMetadata;
+    private static normalizeProfile;
+}

package/dist/router/virtual-router/provider-registry.js

@@ -0,0 +1,74 @@
+import { VirtualRouterError, VirtualRouterErrorCode } from './types.js';
+export class ProviderRegistry {
+    providers = new Map();
+    constructor(profiles) {
+        if (profiles) {
+            this.load(profiles);
+        }
+    }
+    load(profiles) {
+        this.providers.clear();
+        for (const [key, profile] of Object.entries(profiles)) {
+            const normalized = ProviderRegistry.normalizeProfile(key, profile);
+            this.providers.set(normalized.providerKey, normalized);
+        }
+    }
+    get(providerKey) {
+        const profile = this.providers.get(providerKey);
+        if (!profile) {
+            throw new VirtualRouterError(`Provider ${providerKey} is not registered`, VirtualRouterErrorCode.CONFIG_ERROR, {
+                providerKey
+            });
+        }
+        return profile;
+    }
+    has(providerKey) {
+        return this.providers.has(providerKey);
+    }
+    listKeys() {
+        return Array.from(this.providers.keys());
+    }
+    buildTarget(providerKey) {
+        const profile = this.get(providerKey);
+        const modelId = profile.modelId ?? deriveModelId(profile.providerKey);
+        if (!modelId) {
+            throw new VirtualRouterError(`Provider ${providerKey} is missing model identifier`, VirtualRouterErrorCode.CONFIG_ERROR, { providerKey });
+        }
+        return {
+            providerKey: profile.providerKey,
+            providerType: profile.providerType,
+            outboundProfile: profile.outboundProfile,
+            compatibilityProfile: profile.compatibilityProfile,
+            runtimeKey: profile.runtimeKey,
+            modelId,
+            processMode: profile.processMode || 'chat'
+        };
+    }
+    static normalizeProfile(key, profile) {
+        const providerKey = profile.providerKey ?? key;
+        const modelId = profile.modelId ?? deriveModelId(providerKey);
+        return {
+            providerKey,
+            providerType: profile.providerType,
+            endpoint: profile.endpoint,
+            auth: profile.auth,
+            outboundProfile: profile.outboundProfile,
+            compatibilityProfile: profile.compatibilityProfile,
+            runtimeKey: profile.runtimeKey,
+            modelId,
+            processMode: profile.processMode || 'chat'
+        };
+    }
+}
+function deriveModelId(providerKey) {
+    if (!providerKey)
+        return undefined;
+    const firstDot = providerKey.indexOf('.');
+    if (firstDot <= 0 || firstDot === providerKey.length - 1)
+        return undefined;
+    const remainder = providerKey.slice(firstDot + 1);
+    const secondDot = remainder.indexOf('.');
+    if (secondDot <= 0 || secondDot === remainder.length - 1)
+        return remainder.trim() || undefined;
+    return remainder.slice(secondDot + 1).trim() || undefined;
+}

package/dist/router/virtual-router/types.d.ts

@@ -0,0 +1,206 @@
+/**
+ * Virtual Router 类型定义
+ */
+import type { StandardizedRequest } from '../../conversion/hub/types/standardized.js';
+export declare const DEFAULT_ROUTE = "default";
+export declare const ROUTE_PRIORITY: string[];
+export type RoutingPools = Record<string, string[]>;
+export interface ProviderAuthConfig {
+    type: 'apiKey' | 'oauth';
+    secretRef?: string;
+    value?: string;
+    tokenFile?: string;
+    tokenUrl?: string;
+    deviceCodeUrl?: string;
+    clientId?: string;
+    clientSecret?: string;
+    scopes?: string[];
+    authorizationUrl?: string;
+    userInfoUrl?: string;
+    refreshUrl?: string;
+    oauthProviderId?: string;
+    rawType?: string;
+}
+export interface ProviderProfile {
+    providerKey: string;
+    providerType: string;
+    endpoint: string;
+    auth: ProviderAuthConfig;
+    outboundProfile: string;
+    compatibilityProfile?: string;
+    runtimeKey?: string;
+    modelId?: string;
+    processMode?: 'chat' | 'passthrough';
+}
+export interface ProviderRuntimeProfile {
+    runtimeKey: string;
+    providerId: string;
+    keyAlias: string;
+    providerType: string;
+    endpoint: string;
+    headers?: Record<string, string>;
+    auth: ProviderAuthConfig;
+    outboundProfile: string;
+    compatibilityProfile?: string;
+    modelId?: string;
+    processMode?: 'chat' | 'passthrough';
+}
+export interface VirtualRouterClassifierConfig {
+    longContextThresholdTokens?: number;
+    thinkingKeywords?: string[];
+    codingKeywords?: string[];
+    backgroundKeywords?: string[];
+    visionKeywords?: string[];
+}
+export interface LoadBalancingPolicy {
+    strategy: 'round-robin' | 'weighted' | 'sticky';
+    weights?: Record<string, number>;
+}
+export interface ProviderHealthConfig {
+    failureThreshold: number;
+    cooldownMs: number;
+    fatalCooldownMs?: number;
+}
+export interface VirtualRouterConfig {
+    routing: RoutingPools;
+    providers: Record<string, ProviderProfile>;
+    classifier: VirtualRouterClassifierConfig;
+    loadBalancing?: LoadBalancingPolicy;
+    health?: ProviderHealthConfig;
+}
+export type VirtualRouterProviderDefinition = Record<string, unknown>;
+export interface VirtualRouterBootstrapInput extends Record<string, unknown> {
+    virtualrouter?: Record<string, unknown>;
+    providers?: Record<string, VirtualRouterProviderDefinition>;
+    routing?: Record<string, unknown>;
+    classifier?: VirtualRouterClassifierConfig;
+    loadBalancing?: LoadBalancingPolicy;
+    health?: ProviderHealthConfig;
+}
+export type ProviderRuntimeMap = Record<string, ProviderRuntimeProfile>;
+export interface VirtualRouterBootstrapResult {
+    config: VirtualRouterConfig;
+    runtime: ProviderRuntimeMap;
+    targetRuntime: Record<string, ProviderRuntimeProfile>;
+    providers: Record<string, ProviderProfile>;
+    routing: RoutingPools;
+}
+export interface RouterMetadataInput {
+    requestId: string;
+    entryEndpoint: string;
+    processMode: 'chat' | 'passthrough';
+    stream: boolean;
+    direction: 'request' | 'response';
+    providerProtocol?: string;
+    stage?: 'inbound' | 'outbound' | 'response';
+    routeHint?: string;
+}
+export interface RoutingFeatures {
+    requestId: string;
+    model: string;
+    totalMessages: number;
+    userTextSample: string;
+    toolCount: number;
+    hasTools: boolean;
+    hasToolCallResponses: boolean;
+    hasVisionTool: boolean;
+    hasImageAttachment: boolean;
+    hasWebTool: boolean;
+    hasCodingTool: boolean;
+    hasThinkingKeyword: boolean;
+    estimatedTokens: number;
+    metadata: RouterMetadataInput;
+}
+export interface ClassificationResult {
+    routeName: string;
+    confidence: number;
+    reasoning: string;
+    fallback: boolean;
+    candidates?: string[];
+}
+export interface RoutingDecision {
+    routeName: string;
+    providerKey: string;
+    confidence: number;
+    reasoning: string;
+    fallback: boolean;
+    pool: string[];
+}
+export interface TargetMetadata {
+    providerKey: string;
+    providerType: string;
+    outboundProfile: string;
+    compatibilityProfile?: string;
+    runtimeKey?: string;
+    modelId: string;
+    processMode?: 'chat' | 'passthrough';
+}
+export declare enum VirtualRouterErrorCode {
+    NO_STANDARDIZED_REQUEST = "NO_STANDARDIZED_REQUEST",
+    ROUTE_NOT_FOUND = "ROUTE_NOT_FOUND",
+    PROVIDER_NOT_AVAILABLE = "PROVIDER_NOT_AVAILABLE",
+    CONFIG_ERROR = "CONFIG_ERROR"
+}
+export declare class VirtualRouterError extends Error {
+    readonly code: VirtualRouterErrorCode;
+    readonly details?: Record<string, unknown>;
+    constructor(message: string, code: VirtualRouterErrorCode, details?: Record<string, unknown>);
+}
+export interface RoutingDiagnostics {
+    routeName: string;
+    providerKey: string;
+    reasoning: string;
+    fallback: boolean;
+    pool: string[];
+    confidence: number;
+}
+export interface RoutingStatusSnapshot {
+    routes: Record<string, {
+        providers: string[];
+        hits: number;
+        lastUsedProvider?: string;
+    }>;
+    health: ProviderHealthState[];
+}
+export interface ProviderHealthState {
+    providerKey: string;
+    state: 'healthy' | 'tripped';
+    failureCount: number;
+    cooldownExpiresAt?: number;
+    reason?: string;
+}
+export interface ProviderFailureEvent {
+    providerKey: string;
+    routeName?: string;
+    reason?: string;
+    fatal?: boolean;
+    statusCode?: number;
+    errorCode?: string;
+    retryable?: boolean;
+    affectsHealth?: boolean;
+    cooldownOverrideMs?: number;
+    metadata?: Record<string, unknown>;
+}
+export interface ProviderErrorRuntimeMetadata {
+    requestId: string;
+    routeName?: string;
+    providerKey?: string;
+    providerId?: string;
+    providerType?: string;
+    providerProtocol?: string;
+    pipelineId?: string;
+    target?: TargetMetadata | Record<string, unknown>;
+}
+export interface ProviderErrorEvent {
+    code: string;
+    message: string;
+    stage: string;
+    status?: number;
+    recoverable?: boolean;
+    runtime: ProviderErrorRuntimeMetadata;
+    timestamp: number;
+    details?: Record<string, unknown>;
+}
+export interface FeatureBuilder {
+    build(request: StandardizedRequest, metadata: RouterMetadataInput): RoutingFeatures;
+}

package/dist/router/virtual-router/types.js

@@ -0,0 +1,31 @@
+/**
+ * Virtual Router 类型定义
+ */
+export const DEFAULT_ROUTE = 'default';
+export const ROUTE_PRIORITY = [
+    'vision',
+    'websearch',
+    'coding',
+    'tools',
+    'longcontext',
+    'thinking',
+    'background',
+    DEFAULT_ROUTE
+];
+export var VirtualRouterErrorCode;
+(function (VirtualRouterErrorCode) {
+    VirtualRouterErrorCode["NO_STANDARDIZED_REQUEST"] = "NO_STANDARDIZED_REQUEST";
+    VirtualRouterErrorCode["ROUTE_NOT_FOUND"] = "ROUTE_NOT_FOUND";
+    VirtualRouterErrorCode["PROVIDER_NOT_AVAILABLE"] = "PROVIDER_NOT_AVAILABLE";
+    VirtualRouterErrorCode["CONFIG_ERROR"] = "CONFIG_ERROR";
+})(VirtualRouterErrorCode || (VirtualRouterErrorCode = {}));
+export class VirtualRouterError extends Error {
+    code;
+    details;
+    constructor(message, code, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = 'VirtualRouterError';
+    }
+}

package/dist/sse/index.d.ts

@@ -0,0 +1,140 @@
+/**
+ * SSE双向转换模块统一导出
+ * 支持Chat和Responses协议的JSON↔SSE双向转换
+ */
+import type { ChatCompletionResponse, ChatJsonToSseOptions, ResponsesJsonToSseOptions, ResponsesResponse, SseToChatJsonOptions, SseToResponsesJsonOptions } from './types/index.js';
+import type { AnthropicMessageResponse } from './types/anthropic-types.js';
+import { ChatSseToJsonConverter as ChatSseToJsonConverterCtor } from './sse-to-json/index.js';
+import { ResponsesSseToJsonConverter as ResponsesSseToJsonConverterCtor } from './sse-to-json/index.js';
+import { AnthropicJsonToSseConverter as AnthropicJsonToSseConverterCtor } from './json-to-sse/anthropic-json-to-sse-converter.js';
+import { AnthropicSseToJsonConverter as AnthropicSseToJsonConverterCtor } from './sse-to-json/anthropic-sse-to-json-converter.js';
+export { ChatJsonToSseConverter } from './json-to-sse/index.js';
+export { ChatSseToJsonConverter } from './sse-to-json/index.js';
+export { ResponsesJsonToSseConverter } from './json-to-sse/index.js';
+export { ResponsesSseToJsonConverter } from './sse-to-json/index.js';
+export * from './shared/utils.js';
+export * from './types/index.js';
+/**
+ * 工厂函数：创建Chat协议转换器
+ */
+export declare function createChatConverters(): {
+    jsonToSse: import("./json-to-sse/chat-json-to-sse-converter.js").ChatJsonToSseConverterRefactored;
+    sseToJson: ChatSseToJsonConverterCtor;
+    /**
+     * 执行完整的回环测试
+     */
+    roundTrip(input: ChatCompletionResponse, options: ChatJsonToSseOptions & SseToChatJsonOptions): Promise<ChatCompletionResponse>;
+};
+/**
+ * 工厂函数：创建Responses协议转换器
+ */
+export declare function createResponsesConverters(): {
+    jsonToSse: import("./json-to-sse/responses-json-to-sse-converter.js").ResponsesJsonToSseConverterRefactored;
+    sseToJson: ResponsesSseToJsonConverterCtor;
+    /**
+     * 执行完整的回环测试
+     */
+    roundTrip(input: ResponsesResponse, options: ResponsesJsonToSseOptions & SseToResponsesJsonOptions): Promise<ResponsesResponse>;
+};
+/**
+ * 工厂函数：创建Anthropic协议转换器
+ */
+export declare function createAnthropicConverters(): {
+    jsonToSse: AnthropicJsonToSseConverterCtor;
+    sseToJson: AnthropicSseToJsonConverterCtor;
+    roundTrip(input: AnthropicMessageResponse, options: {
+        requestId: string;
+        model: string;
+    }): Promise<AnthropicMessageResponse>;
+};
+/**
+ * 工厂函数：创建完整的双向转换器（支持Chat和Responses协议）
+ */
+export declare function createBidirectionalConverters(): {
+    chat: {
+        jsonToSse: import("./json-to-sse/chat-json-to-sse-converter.js").ChatJsonToSseConverterRefactored;
+        sseToJson: ChatSseToJsonConverterCtor;
+        /**
+         * 执行完整的回环测试
+         */
+        roundTrip(input: ChatCompletionResponse, options: ChatJsonToSseOptions & SseToChatJsonOptions): Promise<ChatCompletionResponse>;
+    };
+    responses: {
+        jsonToSse: import("./json-to-sse/responses-json-to-sse-converter.js").ResponsesJsonToSseConverterRefactored;
+        sseToJson: ResponsesSseToJsonConverterCtor;
+        /**
+         * 执行完整的回环测试
+         */
+        roundTrip(input: ResponsesResponse, options: ResponsesJsonToSseOptions & SseToResponsesJsonOptions): Promise<ResponsesResponse>;
+    };
+    anthropic: {
+        jsonToSse: AnthropicJsonToSseConverterCtor;
+        sseToJson: AnthropicSseToJsonConverterCtor;
+        roundTrip(input: AnthropicMessageResponse, options: {
+            requestId: string;
+            model: string;
+        }): Promise<AnthropicMessageResponse>;
+    };
+    /**
+     * 自动检测协议类型并执行转换
+     */
+    autoConvert(input: any, options?: any): Promise<ChatCompletionResponse | ResponsesResponse | AnthropicMessageResponse>;
+};
+/**
+ * 默认转换器实例
+ */
+export declare const chatConverters: {
+    jsonToSse: import("./json-to-sse/chat-json-to-sse-converter.js").ChatJsonToSseConverterRefactored;
+    sseToJson: ChatSseToJsonConverterCtor;
+    /**
+     * 执行完整的回环测试
+     */
+    roundTrip(input: ChatCompletionResponse, options: ChatJsonToSseOptions & SseToChatJsonOptions): Promise<ChatCompletionResponse>;
+};
+export declare const responsesConverters: {
+    jsonToSse: import("./json-to-sse/responses-json-to-sse-converter.js").ResponsesJsonToSseConverterRefactored;
+    sseToJson: ResponsesSseToJsonConverterCtor;
+    /**
+     * 执行完整的回环测试
+     */
+    roundTrip(input: ResponsesResponse, options: ResponsesJsonToSseOptions & SseToResponsesJsonOptions): Promise<ResponsesResponse>;
+};
+export declare const bidirectionalConverters: {
+    chat: {
+        jsonToSse: import("./json-to-sse/chat-json-to-sse-converter.js").ChatJsonToSseConverterRefactored;
+        sseToJson: ChatSseToJsonConverterCtor;
+        /**
+         * 执行完整的回环测试
+         */
+        roundTrip(input: ChatCompletionResponse, options: ChatJsonToSseOptions & SseToChatJsonOptions): Promise<ChatCompletionResponse>;
+    };
+    responses: {
+        jsonToSse: import("./json-to-sse/responses-json-to-sse-converter.js").ResponsesJsonToSseConverterRefactored;
+        sseToJson: ResponsesSseToJsonConverterCtor;
+        /**
+         * 执行完整的回环测试
+         */
+        roundTrip(input: ResponsesResponse, options: ResponsesJsonToSseOptions & SseToResponsesJsonOptions): Promise<ResponsesResponse>;
+    };
+    anthropic: {
+        jsonToSse: AnthropicJsonToSseConverterCtor;
+        sseToJson: AnthropicSseToJsonConverterCtor;
+        roundTrip(input: AnthropicMessageResponse, options: {
+            requestId: string;
+            model: string;
+        }): Promise<AnthropicMessageResponse>;
+    };
+    /**
+     * 自动检测协议类型并执行转换
+     */
+    autoConvert(input: any, options?: any): Promise<ChatCompletionResponse | ResponsesResponse | AnthropicMessageResponse>;
+};
+export declare const anthropicConverters: {
+    jsonToSse: AnthropicJsonToSseConverterCtor;
+    sseToJson: AnthropicSseToJsonConverterCtor;
+    roundTrip(input: AnthropicMessageResponse, options: {
+        requestId: string;
+        model: string;
+    }): Promise<AnthropicMessageResponse>;
+};
+export { defaultSseCodecRegistry, SseCodecRegistry, type SseCodec, type SseProtocol, type JsonToSseContext, type SseToJsonContext, type NormalizeSseContext } from './registry/sse-codec-registry.js';