@jsonstudio/llms 0.4.2 → 0.4.4

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>>;

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

@@ -1,68 +0,0 @@
-import { Readable } from 'node:stream';
-import type { HubNodeResult } from '../types/node.js';
-import type { StandardizedRequest, ProcessedRequest } from '../types/standardized.js';
-import type { JsonObject } from '../types/json.js';
-import type { NodeResult as V3NodeResult } from '../../conversion-v3/types/index.js';
-import type { VirtualRouterConfig, RoutingDecision, RoutingDiagnostics, TargetMetadata } from '../../../router/virtual-router/types.js';
-export interface HubPipelineConfig {
-    virtualRouter: VirtualRouterConfig;
-}
-export interface HubPipelineRequestMetadata extends Record<string, unknown> {
-    entryEndpoint?: string;
-    providerProtocol?: string;
-    processMode?: 'chat' | 'passthrough';
-    stage?: 'inbound' | 'outbound';
-    direction?: 'request' | 'response';
-    stream?: boolean;
-    routeHint?: string;
-}
-export interface HubPipelineRequest {
-    id?: string;
-    endpoint: string;
-    payload: Record<string, unknown> | {
-        readable?: Readable;
-    } | Readable;
-    metadata?: HubPipelineRequestMetadata;
-}
-type HubPipelineNodeMetadata = HubNodeResult['metadata'] | V3NodeResult['metadata'];
-export interface HubPipelineNodeResult {
-    id: string;
-    success: boolean;
-    metadata: HubPipelineNodeMetadata;
-    error?: HubNodeResult['error'] | JsonObject;
-}
-export interface HubPipelineResult {
-    requestId: string;
-    providerPayload?: Record<string, unknown>;
-    standardizedRequest?: StandardizedRequest;
-    processedRequest?: ProcessedRequest;
-    routingDecision?: RoutingDecision;
-    routingDiagnostics?: RoutingDiagnostics;
-    target?: TargetMetadata;
-    metadata: Record<string, unknown>;
-    nodeResults: HubPipelineNodeResult[];
-}
-export declare class HubPipeline {
-    private readonly routerEngine;
-    private config;
-    constructor(config: HubPipelineConfig);
-    updateVirtualRouterConfig(nextConfig: VirtualRouterConfig): void;
-    execute(request: HubPipelineRequest): Promise<HubPipelineResult>;
-    private runInboundStage;
-    private runProcessStage;
-    private routeRequest;
-    private applyTargetMetadata;
-    private applyTargetToSubject;
-    private extractModelFromTarget;
-    private runOutboundStage;
-    private normalizeRequest;
-    private createHubNodeContext;
-    private convertHubNodeResult;
-    private convertV3NodeResult;
-    private materializePayload;
-    private unwrapReadable;
-    private convertSsePayload;
-    private resolveSseProtocol;
-    private extractModelHint;
-}
-export {};

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

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

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

@@ -1,22 +0,0 @@
-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/process/chat-process.d.ts

@@ -1,13 +0,0 @@
-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/registry.d.ts

@@ -1,28 +0,0 @@
-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 {};

package/dist/conversion/hub/response/chat-response-utils.d.ts

@@ -1,6 +0,0 @@
-import type { ProcessedRequest } from '../types/standardized.js';
-interface BuildProcessedRequestOptions {
-    stream?: boolean;
-}
-export declare function buildProcessedRequestFromChatResponse(chatResponse: any, options?: BuildProcessedRequestOptions): ProcessedRequest;
-export {};

package/dist/conversion/hub/response/provider-response.d.ts

@@ -1,20 +0,0 @@
-import { Readable } from 'node:stream';
-import type { AdapterContext } from '../types/chat-envelope.js';
-import type { JsonObject } from '../types/json.js';
-import type { StageRecorder } from '../format-adapters/index.js';
-type ProviderProtocol = 'openai-chat' | 'openai-responses' | 'anthropic-messages' | 'gemini-chat';
-export interface ProviderResponseConversionOptions {
-    providerProtocol: ProviderProtocol;
-    providerResponse: JsonObject;
-    context: AdapterContext;
-    entryEndpoint: string;
-    wantsStream: boolean;
-    stageRecorder?: StageRecorder;
-}
-export interface ProviderResponseConversionResult {
-    body?: JsonObject;
-    __sse_responses?: Readable;
-    format?: string;
-}
-export declare function convertProviderResponse(options: ProviderResponseConversionOptions): Promise<ProviderResponseConversionResult>;
-export {};

package/dist/conversion/hub/response/response-mappers.d.ts

@@ -1,19 +0,0 @@
-import type { FormatEnvelope } from '../types/format-envelope.js';
-import type { AdapterContext } from '../types/chat-envelope.js';
-import type { JsonObject } from '../types/json.js';
-export type ChatCompletionLike = JsonObject;
-export interface ResponseMapper {
-    toChatCompletion(format: FormatEnvelope, ctx: AdapterContext): Promise<ChatCompletionLike> | ChatCompletionLike;
-}
-export declare class OpenAIChatResponseMapper implements ResponseMapper {
-    toChatCompletion(format: FormatEnvelope, _ctx: AdapterContext): ChatCompletionLike;
-}
-export declare class ResponsesResponseMapper implements ResponseMapper {
-    toChatCompletion(format: FormatEnvelope, _ctx: AdapterContext): ChatCompletionLike;
-}
-export declare class AnthropicResponseMapper implements ResponseMapper {
-    toChatCompletion(format: FormatEnvelope, _ctx: AdapterContext): ChatCompletionLike;
-}
-export declare class GeminiResponseMapper implements ResponseMapper {
-    toChatCompletion(format: FormatEnvelope, _ctx: AdapterContext): ChatCompletionLike;
-}

package/dist/conversion/hub/response/response-runtime.d.ts

@@ -1,3 +0,0 @@
-import type { JsonObject } from '../types/json.js';
-export declare function buildOpenAIChatFromAnthropicMessage(payload: JsonObject): JsonObject;
-export declare function buildAnthropicResponseFromChat(chatResponse: JsonObject): JsonObject;

package/dist/conversion/hub/semantic-mappers/anthropic-mapper.d.ts

@@ -1,7 +0,0 @@
-import type { SemanticMapper } from '../format-adapters/index.js';
-import type { AdapterContext, ChatEnvelope } from '../types/chat-envelope.js';
-import type { FormatEnvelope } from '../types/format-envelope.js';
-export declare class AnthropicSemanticMapper implements SemanticMapper {
-    toChat(format: FormatEnvelope, ctx: AdapterContext): Promise<ChatEnvelope>;
-    fromChat(chat: ChatEnvelope, ctx: AdapterContext): Promise<FormatEnvelope>;
-}

package/dist/conversion/hub/semantic-mappers/chat-mapper.d.ts

@@ -1,7 +0,0 @@
-import type { SemanticMapper } from '../format-adapters/index.js';
-import type { AdapterContext, ChatEnvelope } from '../types/chat-envelope.js';
-import type { FormatEnvelope } from '../types/format-envelope.js';
-export declare class ChatSemanticMapper implements SemanticMapper {
-    toChat(format: FormatEnvelope, ctx: AdapterContext): Promise<ChatEnvelope>;
-    fromChat(chat: ChatEnvelope, ctx: AdapterContext): Promise<FormatEnvelope>;
-}

package/dist/conversion/hub/semantic-mappers/gemini-mapper.d.ts

@@ -1,7 +0,0 @@
-import type { SemanticMapper } from '../format-adapters/index.js';
-import type { AdapterContext, ChatEnvelope } from '../types/chat-envelope.js';
-import type { FormatEnvelope } from '../types/format-envelope.js';
-export declare class GeminiSemanticMapper implements SemanticMapper {
-    toChat(format: FormatEnvelope, ctx: AdapterContext): Promise<ChatEnvelope>;
-    fromChat(chat: ChatEnvelope, ctx: AdapterContext): Promise<FormatEnvelope>;
-}

package/dist/conversion/hub/semantic-mappers/index.d.ts

@@ -1,4 +0,0 @@
-export { ChatSemanticMapper } from './chat-mapper.js';
-export { AnthropicSemanticMapper } from './anthropic-mapper.js';
-export { ResponsesSemanticMapper } from './responses-mapper.js';
-export { GeminiSemanticMapper } from './gemini-mapper.js';

package/dist/conversion/hub/semantic-mappers/responses-mapper.d.ts

@@ -1,21 +0,0 @@
-import type { SemanticMapper } from '../format-adapters/index.js';
-import type { AdapterContext, ChatEnvelope } from '../types/chat-envelope.js';
-import type { FormatEnvelope } from '../types/format-envelope.js';
-import { type JsonObject, type JsonValue } from '../types/json.js';
-interface ResponsesToolOutputEntry extends JsonObject {
-    tool_call_id?: string;
-    call_id?: string;
-    id?: string;
-    output?: JsonValue;
-    name?: string;
-}
-interface ResponsesPayload extends JsonObject {
-    input?: JsonValue[];
-    tools?: JsonValue[];
-    tool_outputs?: ResponsesToolOutputEntry[];
-}
-export declare class ResponsesSemanticMapper implements SemanticMapper {
-    toChat(format: FormatEnvelope<ResponsesPayload>, ctx: AdapterContext): Promise<ChatEnvelope>;
-    fromChat(chat: ChatEnvelope, ctx: AdapterContext): Promise<FormatEnvelope>;
-}
-export {};

package/dist/conversion/hub/snapshot-recorder.d.ts

@@ -1,12 +0,0 @@
-import type { StageRecorder } from './format-adapters/index.js';
-import type { AdapterContext } from './types/chat-envelope.js';
-export interface SnapshotStageRecorderOptions {
-    context: AdapterContext;
-    endpoint: string;
-}
-export declare class SnapshotStageRecorder implements StageRecorder {
-    private readonly options;
-    constructor(options: SnapshotStageRecorderOptions);
-    record(stage: string, payload: object): void;
-}
-export declare function createSnapshotRecorder(context: AdapterContext, endpoint: string): StageRecorder;

package/dist/conversion/hub/standardized-bridge.d.ts

@@ -1,12 +0,0 @@
-import type { StandardizedRequest } from './types/standardized.js';
-import type { AdapterContext, ChatEnvelope } from './types/chat-envelope.js';
-export interface ChatToStandardizedOptions {
-    adapterContext: AdapterContext;
-    endpoint: string;
-    requestId?: string;
-}
-export interface StandardizedToChatOptions {
-    adapterContext: AdapterContext;
-}
-export declare function chatEnvelopeToStandardized(chat: ChatEnvelope, options: ChatToStandardizedOptions): StandardizedRequest;
-export declare function standardizedToChatEnvelope(request: StandardizedRequest, options: StandardizedToChatOptions): ChatEnvelope;

package/dist/conversion/hub/types/chat-envelope.d.ts

@@ -1,67 +0,0 @@
-export type ChatRole = 'system' | 'user' | 'assistant' | 'tool';
-import type { JsonObject, JsonValue } from './json.js';
-export interface ChatMessageContentPart {
-    type: string;
-    text?: string;
-    [key: string]: JsonValue;
-}
-export interface ChatToolCall {
-    id: string;
-    type: 'function';
-    function: {
-        name: string;
-        arguments: string;
-    };
-    [key: string]: JsonValue;
-}
-export interface ChatMessage {
-    role: ChatRole;
-    content?: string | ChatMessageContentPart[];
-    tool_calls?: ChatToolCall[];
-    name?: string;
-    [key: string]: JsonValue;
-}
-export interface ChatToolDefinition {
-    type: 'function' | string;
-    function: {
-        name: string;
-        description?: string;
-        parameters?: JsonValue;
-        strict?: boolean;
-    };
-    [key: string]: JsonValue;
-}
-export interface ChatToolOutput {
-    tool_call_id: string;
-    content: string;
-    name?: string;
-    [key: string]: JsonValue;
-}
-export interface MissingField extends JsonObject {
-    path: string;
-    reason: string;
-    originalValue?: JsonValue;
-}
-export interface AdapterContext {
-    requestId: string;
-    entryEndpoint: string;
-    providerProtocol: string;
-    providerId?: string;
-    routeId?: string;
-    profileId?: string;
-    streamingHint?: 'auto' | 'force' | 'disable';
-    originalModelId?: string;
-    clientModelId?: string;
-    [key: string]: JsonValue;
-}
-export interface ChatEnvelope {
-    messages: ChatMessage[];
-    tools?: ChatToolDefinition[];
-    toolOutputs?: ChatToolOutput[];
-    parameters?: JsonObject;
-    metadata: {
-        context: AdapterContext;
-        missingFields?: MissingField[];
-        [key: string]: JsonValue;
-    };
-}

package/dist/conversion/hub/types/chat-schema.d.ts

@@ -1,112 +0,0 @@
-import type { JsonObject, JsonValue } from './json.js';
-export type ChatHubVersion = 'chat-hub@1';
-export interface ConversationReference {
-    readonly id?: string;
-    readonly parentIds?: readonly string[];
-    readonly metadata?: JsonObject;
-}
-export interface InstructionSegment {
-    readonly id?: string;
-    readonly source: string;
-    readonly content: string;
-    readonly metadata?: JsonObject;
-}
-export interface InstructionsEnvelope {
-    readonly segments: readonly InstructionSegment[];
-}
-export type MessageRole = 'system' | 'user' | 'assistant' | 'tool';
-interface BaseContentBlock {
-    readonly type: string;
-    readonly metadata?: JsonObject;
-}
-export interface TextContentBlock extends BaseContentBlock {
-    readonly type: 'text';
-    readonly text: string;
-    readonly annotations?: readonly JsonObject[];
-}
-export interface ImageContentBlock extends BaseContentBlock {
-    readonly type: 'image';
-    readonly mimeType?: string;
-    readonly data?: string;
-    readonly uri?: string;
-}
-export interface AudioContentBlock extends BaseContentBlock {
-    readonly type: 'audio';
-    readonly mimeType?: string;
-    readonly data?: string;
-    readonly uri?: string;
-}
-export interface DataContentBlock extends BaseContentBlock {
-    readonly type: 'data';
-    readonly mimeType?: string;
-    readonly value: JsonValue;
-}
-export interface ToolCallContentBlock extends BaseContentBlock {
-    readonly type: 'tool_call';
-    readonly toolCallId: string;
-    readonly name: string;
-    readonly arguments: JsonObject;
-}
-export interface ToolResultContentBlock extends BaseContentBlock {
-    readonly type: 'tool_result';
-    readonly toolCallId: string;
-    readonly output: readonly TextContentBlock[];
-    readonly isError?: boolean;
-}
-export type ChatContentBlock = TextContentBlock | ImageContentBlock | AudioContentBlock | DataContentBlock | ToolCallContentBlock | ToolResultContentBlock;
-export interface ChatMessage {
-    readonly id?: string;
-    readonly role: MessageRole;
-    readonly name?: string;
-    readonly content: readonly ChatContentBlock[];
-    readonly metadata?: JsonObject;
-}
-export interface ChatToolDefinition {
-    readonly id?: string;
-    readonly type: 'function' | string;
-    readonly name: string;
-    readonly description?: string;
-    readonly parameters?: JsonObject;
-    readonly strict?: boolean;
-    readonly metadata?: JsonObject;
-}
-export interface ChatAttachment {
-    readonly id: string;
-    readonly kind: 'file' | 'image' | 'audio';
-    readonly uri?: string;
-    readonly mimeType?: string;
-    readonly metadata?: JsonObject;
-}
-export interface ChatGenerationConfig {
-    readonly temperature?: number;
-    readonly topP?: number;
-    readonly topK?: number;
-    readonly maxOutputTokens?: number;
-    readonly stopSequences?: readonly string[];
-    readonly stream?: boolean;
-    readonly parallelToolCalls?: boolean;
-    readonly responseFormat?: JsonObject;
-    readonly metadata?: JsonObject;
-}
-export interface DetourEntry {
-    readonly path: string;
-    readonly value?: JsonValue;
-    readonly reason: string;
-    readonly stage: string;
-}
-export interface DetourState {
-    readonly inbound: readonly DetourEntry[];
-    readonly outbound: readonly DetourEntry[];
-}
-export interface ChatHubEnvelope {
-    readonly version: ChatHubVersion;
-    readonly conversation?: ConversationReference;
-    readonly instructions?: InstructionsEnvelope;
-    readonly messages: readonly ChatMessage[];
-    readonly tools?: readonly ChatToolDefinition[];
-    readonly config?: ChatGenerationConfig;
-    readonly attachments?: readonly ChatAttachment[];
-    readonly detours?: DetourState;
-    readonly metadata?: JsonObject;
-}
-export {};

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

@@ -1,5 +0,0 @@
-export declare class ConversionError extends Error {
-    readonly nodeId?: string;
-    readonly stage?: string;
-    constructor(message: string, nodeId?: string, stage?: string, cause?: Error);
-}

package/dist/conversion/hub/types/format-envelope.d.ts

@@ -1,7 +0,0 @@
-import type { JsonObject } from './json.js';
-export interface FormatEnvelope<TPayload extends JsonObject = JsonObject> {
-    protocol: string;
-    direction: 'request' | 'response';
-    payload: TPayload;
-    meta?: JsonObject;
-}

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

@@ -1,6 +0,0 @@
-export * from './chat-envelope.js';
-export * from './format-envelope.js';
-export * from './json.js';
-export * from './standardized.js';
-export * from './errors.js';
-export * from './node.js';

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

@@ -1,9 +0,0 @@
-export type JsonPrimitive = string | number | boolean | null;
-export type JsonValue = JsonPrimitive | JsonValue[] | JsonObject;
-export interface JsonObject {
-    [key: string]: JsonValue;
-}
-export type JsonArray = JsonValue[];
-export declare function isJsonObject(value: JsonValue | null | undefined): value is JsonObject;
-export declare function isJsonArray(value: JsonValue | null | undefined): value is JsonArray;
-export declare function jsonClone<T extends JsonValue>(value: T): T;

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

@@ -1,31 +0,0 @@
-import type { JsonObject } from './json.js';
-export interface HubNodeRequestContext {
-    id: string;
-    endpoint: string;
-    context?: Record<string, unknown>;
-}
-export interface HubNodeContext {
-    request: HubNodeRequestContext;
-}
-export interface HubNodeResult {
-    success: boolean;
-    data?: Record<string, unknown>;
-    error?: {
-        code: string;
-        message: string;
-        details?: JsonObject;
-        cause?: Error;
-    };
-    metadata: {
-        node: string;
-        executionTime: number;
-        startTime: number;
-        endTime: number;
-        dataProcessed?: {
-            messages?: number;
-            tools?: number;
-            tokens?: number;
-            responseSize?: number;
-        };
-    };
-}

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

@@ -1,94 +0,0 @@
-import type { JsonObject } from './json.js';
-export type ToolChoice = 'none' | 'auto' | 'required' | {
-    type: 'function';
-    function: {
-        name: string;
-    };
-} | Record<string, unknown>;
-export interface StandardizedTool {
-    type: 'function';
-    function: {
-        name: string;
-        description?: string;
-        parameters: {
-            type: 'object';
-            properties: Record<string, unknown>;
-            required?: string[];
-            additionalProperties?: boolean;
-        };
-        strict?: boolean;
-    };
-}
-export interface ToolCall {
-    id: string;
-    type: 'function';
-    function: {
-        name: string;
-        arguments: string;
-    };
-}
-export interface ToolCallResult {
-    tool_call_id: string;
-    status: 'success' | 'error' | 'timeout' | 'pending';
-    result?: JsonObject | JsonObject[] | string | number | boolean | null;
-    error?: string;
-    executionTime?: number;
-}
-export interface StandardizedMessage {
-    role: 'system' | 'user' | 'assistant' | 'tool';
-    content: string | null;
-    tool_calls?: ToolCall[];
-    tool_call_id?: string;
-    name?: string;
-    metadata?: Record<string, unknown>;
-}
-export interface StandardizedParameters {
-    temperature?: number;
-    max_tokens?: number;
-    top_p?: number;
-    frequency_penalty?: number;
-    presence_penalty?: number;
-    stop?: string | string[];
-    stream?: boolean;
-    [key: string]: unknown;
-}
-export interface StandardizedMetadata {
-    originalEndpoint: string;
-    capturedContext?: Record<string, unknown>;
-    requestId?: string;
-    stream?: boolean;
-    toolChoice?: ToolChoice;
-    providerKey?: string;
-    providerType?: string;
-    processMode?: 'chat' | 'passthrough';
-    routeHint?: string;
-    [key: string]: unknown;
-}
-export interface StandardizedRequest {
-    model: string;
-    messages: StandardizedMessage[];
-    tools?: StandardizedTool[];
-    parameters: StandardizedParameters;
-    metadata: StandardizedMetadata;
-}
-export interface ProcessedRequest extends StandardizedRequest {
-    processed: {
-        timestamp: number;
-        appliedRules: string[];
-        status: 'success' | 'partial' | 'failed';
-    };
-    processingMetadata: {
-        toolCalls?: ToolCallResult[];
-        streaming?: {
-            enabled: boolean;
-            chunkCount?: number;
-            totalTokens?: number;
-        };
-        context?: {
-            systemPrompt?: string;
-            conversationHistory?: string[];
-            relevantContext?: Record<string, unknown>;
-        };
-        passthrough?: boolean;
-    };
-}