@wengine-ai/llms 2.3.231 → 2.3.234

package/dist/transformer/customparams.transformer.d.ts

@@ -0,0 +1,30 @@
+import { UnifiedChatRequest } from "../types/llm";
+import { Transformer, TransformerOptions } from "../types/transformer";
+export interface CustomParamsOptions extends TransformerOptions {
+    /**
+     * Custom parameters to inject into the request body
+     * Any key-value pairs will be added to the request
+     * Supports: string, number, boolean, object, array
+     */
+    [key: string]: any;
+}
+/**
+ * Transformer for injecting dynamic custom parameters into LLM requests
+ * Allows runtime configuration of arbitrary parameters that get merged
+ * into the request body using deep merge strategy
+ */
+export declare class CustomParamsTransformer implements Transformer {
+    static TransformerName: string;
+    private options;
+    constructor(options?: CustomParamsOptions);
+    transformRequestIn(request: UnifiedChatRequest): Promise<UnifiedChatRequest>;
+    transformResponseOut(response: Response): Promise<Response>;
+    /**
+     * Deep merge two objects recursively
+     */
+    private deepMergeObjects;
+    /**
+     * Clone a value to prevent reference issues
+     */
+    private cloneValue;
+}

package/dist/transformer/deepseek.transformer.d.ts

@@ -0,0 +1,7 @@
+import { UnifiedChatRequest } from "../types/llm";
+import { Transformer } from "../types/transformer";
+export declare class DeepseekTransformer implements Transformer {
+    name: string;
+    transformRequestIn(request: UnifiedChatRequest): Promise<UnifiedChatRequest>;
+    transformResponseOut(response: Response): Promise<Response>;
+}

package/dist/transformer/enhancetool.transformer.d.ts

@@ -0,0 +1,5 @@
+import { Transformer } from "../types/transformer";
+export declare class EnhanceToolTransformer implements Transformer {
+    name: string;
+    transformResponseOut(response: Response): Promise<Response>;
+}

package/dist/transformer/forcereasoning.transformer.d.ts

@@ -0,0 +1,7 @@
+import { UnifiedChatRequest } from "../types/llm";
+import { Transformer } from "../types/transformer";
+export declare class ForceReasoningTransformer implements Transformer {
+    name: string;
+    transformRequestIn(request: UnifiedChatRequest): Promise<UnifiedChatRequest>;
+    transformResponseOut(response: Response): Promise<Response>;
+}

package/dist/transformer/gemini.transformer.d.ts

@@ -0,0 +1,10 @@
+import { LLMProvider, UnifiedChatRequest } from "../types/llm";
+import { Transformer } from "../types/transformer";
+import { transformRequestOut } from "../utils/gemini.util";
+export declare class GeminiTransformer implements Transformer {
+    name: string;
+    endPoint: string;
+    transformRequestIn(request: UnifiedChatRequest, provider: LLMProvider): Promise<Record<string, any>>;
+    transformRequestOut: typeof transformRequestOut;
+    transformResponseOut(response: Response): Promise<Response>;
+}

package/dist/transformer/groq.transformer.d.ts

@@ -0,0 +1,7 @@
+import { UnifiedChatRequest } from "../types/llm";
+import { Transformer } from "../types/transformer";
+export declare class GroqTransformer implements Transformer {
+    name: string;
+    transformRequestIn(request: UnifiedChatRequest): Promise<UnifiedChatRequest>;
+    transformResponseOut(response: Response): Promise<Response>;
+}

package/dist/transformer/index.d.ts

@@ -0,0 +1,49 @@
+import { AnthropicTransformer } from "./anthropic.transformer";
+import { GeminiTransformer } from "./gemini.transformer";
+import { VertexGeminiTransformer } from "./vertex-gemini.transformer";
+import { DeepseekTransformer } from "./deepseek.transformer";
+import { TooluseTransformer } from "./tooluse.transformer";
+import { OpenrouterTransformer } from "./openrouter.transformer";
+import { MaxTokenTransformer } from "./maxtoken.transformer";
+import { GroqTransformer } from "./groq.transformer";
+import { CleancacheTransformer } from "./cleancache.transformer";
+import { EnhanceToolTransformer } from "./enhancetool.transformer";
+import { ReasoningTransformer } from "./reasoning.transformer";
+import { SamplingTransformer } from "./sampling.transformer";
+import { MaxCompletionTokens } from "./maxcompletiontokens.transformer";
+import { VertexClaudeTransformer } from "./vertex-claude.transformer";
+import { CerebrasTransformer } from "./cerebras.transformer";
+import { StreamOptionsTransformer } from "./streamoptions.transformer";
+import { OpenAITransformer } from "./openai.transformer";
+import { CustomParamsTransformer } from "./customparams.transformer";
+import { VercelTransformer } from "./vercel.transformer";
+import { OpenAIResponsesTransformer } from "./openai.responses.transformer";
+import { ForceReasoningTransformer } from "./forcereasoning.transformer";
+import { KimiTransformer } from "./kimi.transformer";
+import { OpenCodeTransformer } from "./opencode.transformer";
+declare const _default: {
+    AnthropicTransformer: typeof AnthropicTransformer;
+    GeminiTransformer: typeof GeminiTransformer;
+    VertexGeminiTransformer: typeof VertexGeminiTransformer;
+    VertexClaudeTransformer: typeof VertexClaudeTransformer;
+    DeepseekTransformer: typeof DeepseekTransformer;
+    TooluseTransformer: typeof TooluseTransformer;
+    OpenrouterTransformer: typeof OpenrouterTransformer;
+    OpenAITransformer: typeof OpenAITransformer;
+    MaxTokenTransformer: typeof MaxTokenTransformer;
+    GroqTransformer: typeof GroqTransformer;
+    CleancacheTransformer: typeof CleancacheTransformer;
+    EnhanceToolTransformer: typeof EnhanceToolTransformer;
+    ReasoningTransformer: typeof ReasoningTransformer;
+    SamplingTransformer: typeof SamplingTransformer;
+    MaxCompletionTokens: typeof MaxCompletionTokens;
+    CerebrasTransformer: typeof CerebrasTransformer;
+    StreamOptionsTransformer: typeof StreamOptionsTransformer;
+    CustomParamsTransformer: typeof CustomParamsTransformer;
+    VercelTransformer: typeof VercelTransformer;
+    OpenAIResponsesTransformer: typeof OpenAIResponsesTransformer;
+    ForceReasoningTransformer: typeof ForceReasoningTransformer;
+    KimiTransformer: typeof KimiTransformer;
+    OpenCodeTransformer: typeof OpenCodeTransformer;
+};
+export default _default;

package/dist/transformer/kimi.transformer.d.ts

@@ -0,0 +1,17 @@
+import { UnifiedChatRequest } from "../types/llm";
+import { Transformer } from "../types/transformer";
+/**
+ * Kimi (Moonshot AI) Transformer
+ *
+ * Handles Kimi-specific requirements for thinking mode:
+ * - When thinking is enabled, assistant messages with tool_calls must have reasoning_content
+ * - Preserves reasoning_content_signature for multi-turn conversations
+ *
+ * Kimi API requires reasoning_content in assistant tool call messages when thinking mode is active.
+ * Without this, the API returns: "thinking is enabled but reasoning_content is missing in assistant tool call message"
+ */
+export declare class KimiTransformer implements Transformer {
+    name: string;
+    transformRequestIn(request: UnifiedChatRequest): Promise<UnifiedChatRequest>;
+    transformResponseOut(response: Response): Promise<Response>;
+}

package/dist/transformer/maxcompletiontokens.transformer.d.ts

@@ -0,0 +1,6 @@
+import { UnifiedChatRequest } from "../types/llm";
+import { Transformer } from "../types/transformer";
+export declare class MaxCompletionTokens implements Transformer {
+    static TransformerName: string;
+    transformRequestIn(request: UnifiedChatRequest): Promise<UnifiedChatRequest>;
+}

package/dist/transformer/maxtoken.transformer.d.ts

@@ -0,0 +1,9 @@
+import { UnifiedChatRequest } from "../types/llm";
+import { Transformer, TransformerOptions } from "../types/transformer";
+export declare class MaxTokenTransformer implements Transformer {
+    private readonly options?;
+    static TransformerName: string;
+    max_tokens: number;
+    constructor(options?: TransformerOptions | undefined);
+    transformRequestIn(request: UnifiedChatRequest): Promise<UnifiedChatRequest>;
+}

package/dist/transformer/openai.responses.transformer.d.ts

@@ -0,0 +1,28 @@
+import { UnifiedChatRequest } from "../types/llm";
+import { Transformer } from "../types/transformer";
+export declare class OpenAIResponsesTransformer implements Transformer {
+    name: string;
+    endPoint: string;
+    private getCacheReadInputTokens;
+    private getCacheCreationInputTokens;
+    private buildResponsesUsage;
+    transformRequestIn(request: UnifiedChatRequest): Promise<UnifiedChatRequest>;
+    transformResponseOut(response: Response): Promise<Response>;
+    private normalizeRequestContent;
+    transformResponseIn(response: Response, context?: any): Promise<Response>;
+    /**
+     * Prepend a string chunk to the beginning of an existing ReadableStream.
+     * Used when we've peeked at the first chunk and need to feed it back into
+     * the converter along with the rest of the stream.
+     */
+    private prependToStream;
+    /**
+     * Convert an OpenAI Chat SSE stream to Responses API SSE events.
+     * Handles choices[0].delta.content, choices[0].delta.tool_calls, and finish_reason.
+     */
+    private convertOpenAIChatStreamToResponsesAPI;
+    private convertAnthropicStreamToResponsesAPI;
+    private wrapChatInResponses;
+    private convertResponseToChat;
+    private buildImageContent;
+}

package/dist/transformer/openai.transformer.d.ts

@@ -0,0 +1,5 @@
+import { Transformer } from "../types/transformer";
+export declare class OpenAITransformer implements Transformer {
+    name: string;
+    endPoint: string;
+}

package/dist/transformer/opencode.transformer.d.ts

@@ -0,0 +1,29 @@
+import { UnifiedChatRequest } from "../types/llm";
+import { Transformer, TransformerOptions } from "../types/transformer";
+/**
+ * OpenCode Transformer
+ *
+ * Handles requests to OpenCode (opencode.ai) providers which expose an
+ * OpenAI-compatible /v1/chat/completions endpoint backed by GLM/Zhipu models.
+ *
+ * Key responsibilities:
+ * - Declares endPoint="/v1/chat/completions" so CCR does NOT bypass the
+ *   transformer chain. Without this declaration, a provider whose only
+ *   resolved transformer is AnthropicTransformer would trigger bypass mode,
+ *   sending Anthropic-format tools ({name,description,input_schema}) to an
+ *   OpenAI-compatible API that requires {type:"function",function:{…}}.
+ * - Cleans cache_control and Anthropic-specific image_url fields that GLM
+ *   does not understand.
+ * - Converts reasoning_content in streaming/non-streaming responses to the
+ *   thinking format expected by Claude Code.
+ * - Replaces purely-numeric tool_call IDs with UUID-based IDs to avoid
+ *   downstream parsing issues.
+ */
+export declare class OpenCodeTransformer implements Transformer {
+    private readonly options?;
+    static TransformerName: string;
+    endPoint: string;
+    constructor(options?: TransformerOptions | undefined);
+    transformRequestIn(request: UnifiedChatRequest): Promise<UnifiedChatRequest>;
+    transformResponseOut(response: Response): Promise<Response>;
+}

package/dist/transformer/openrouter.transformer.d.ts

@@ -0,0 +1,9 @@
+import { UnifiedChatRequest } from "../types/llm";
+import { Transformer, TransformerOptions } from "../types/transformer";
+export declare class OpenrouterTransformer implements Transformer {
+    private readonly options?;
+    static TransformerName: string;
+    constructor(options?: TransformerOptions | undefined);
+    transformRequestIn(request: UnifiedChatRequest): Promise<UnifiedChatRequest>;
+    transformResponseOut(response: Response): Promise<Response>;
+}

package/dist/transformer/reasoning.transformer.d.ts

@@ -0,0 +1,10 @@
+import { UnifiedChatRequest } from "../types/llm";
+import { Transformer, TransformerOptions } from "../types/transformer";
+export declare class ReasoningTransformer implements Transformer {
+    private readonly options?;
+    static TransformerName: string;
+    enable: any;
+    constructor(options?: TransformerOptions | undefined);
+    transformRequestIn(request: UnifiedChatRequest): Promise<UnifiedChatRequest>;
+    transformResponseOut(response: Response): Promise<Response>;
+}

package/dist/transformer/sampling.transformer.d.ts

@@ -0,0 +1,13 @@
+import { UnifiedChatRequest } from "../types/llm";
+import { Transformer, TransformerOptions } from "../types/transformer";
+export declare class SamplingTransformer implements Transformer {
+    private readonly options?;
+    static TransformerName: string;
+    max_tokens: number;
+    temperature: number;
+    top_p: number;
+    top_k: number;
+    repetition_penalty: number;
+    constructor(options?: TransformerOptions | undefined);
+    transformRequestIn(request: UnifiedChatRequest): Promise<UnifiedChatRequest>;
+}

package/dist/transformer/streamoptions.transformer.d.ts

@@ -0,0 +1,6 @@
+import { UnifiedChatRequest } from "../types/llm";
+import { Transformer } from "../types/transformer";
+export declare class StreamOptionsTransformer implements Transformer {
+    name: string;
+    transformRequestIn(request: UnifiedChatRequest): Promise<UnifiedChatRequest>;
+}

package/dist/transformer/tooluse.transformer.d.ts

@@ -0,0 +1,7 @@
+import { UnifiedChatRequest } from "../types/llm";
+import { Transformer } from "../types/transformer";
+export declare class TooluseTransformer implements Transformer {
+    name: string;
+    transformRequestIn(request: UnifiedChatRequest): UnifiedChatRequest;
+    transformResponseOut(response: Response): Promise<Response>;
+}

package/dist/transformer/vercel.transformer.d.ts

@@ -0,0 +1,10 @@
+import { UnifiedChatRequest } from "../types/llm";
+import { Transformer, TransformerOptions } from "../types/transformer";
+export declare class VercelTransformer implements Transformer {
+    private readonly options?;
+    static TransformerName: string;
+    endPoint: string;
+    constructor(options?: TransformerOptions | undefined);
+    transformRequestIn(request: UnifiedChatRequest): Promise<UnifiedChatRequest>;
+    transformResponseOut(response: Response): Promise<Response>;
+}

package/dist/transformer/vertex-claude.transformer.d.ts

@@ -0,0 +1,8 @@
+import { LLMProvider, UnifiedChatRequest } from "../types/llm";
+import { Transformer } from "../types/transformer";
+export declare class VertexClaudeTransformer implements Transformer {
+    name: string;
+    transformRequestIn(request: UnifiedChatRequest, provider: LLMProvider): Promise<Record<string, any>>;
+    transformRequestOut(request: Record<string, any>): Promise<UnifiedChatRequest>;
+    transformResponseOut(response: Response): Promise<Response>;
+}

package/dist/transformer/vertex-gemini.transformer.d.ts

@@ -0,0 +1,8 @@
+import { LLMProvider, UnifiedChatRequest } from "../types/llm";
+import { Transformer } from "../types/transformer";
+export declare class VertexGeminiTransformer implements Transformer {
+    name: string;
+    transformRequestIn(request: UnifiedChatRequest, provider: LLMProvider): Promise<Record<string, any>>;
+    transformRequestOut(request: Record<string, any>): Promise<UnifiedChatRequest>;
+    transformResponseOut(response: Response): Promise<Response>;
+}

package/dist/types/llm.d.ts

@@ -0,0 +1,233 @@
+import type { ChatCompletionMessageParam as OpenAIMessage } from "openai/resources/chat/completions";
+import type { MessageParam as AnthropicMessage } from "@anthropic-ai/sdk/resources/messages";
+import type { ChatCompletionChunk } from "openai/resources/chat/completions";
+import type { MessageStreamEvent } from "@anthropic-ai/sdk/resources/messages";
+import type { ChatCompletionTool } from "openai/resources/chat/completions";
+import type { Tool as AnthropicTool } from "@anthropic-ai/sdk/resources/messages";
+import { Transformer } from "./transformer";
+import type { ProviderTokenizerConfig } from "./tokenizer";
+export interface UrlCitation {
+    url: string;
+    title: string;
+    content: string;
+    start_index: number;
+    end_index: number;
+}
+export interface Annotation {
+    type: "url_citation";
+    url_citation?: UrlCitation;
+}
+export interface TextContent {
+    type: "text";
+    text: string;
+    cache_control?: {
+        type?: string;
+    };
+}
+export interface ImageContent {
+    type: "image_url";
+    image_url: {
+        url: string;
+    };
+    media_type: string;
+}
+export type MessageContent = TextContent | ImageContent;
+export interface UnifiedMessage {
+    role: "user" | "assistant" | "system" | "tool";
+    content: string | null | MessageContent[];
+    tool_calls?: Array<{
+        id: string;
+        type: "function";
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }>;
+    tool_call_id?: string;
+    cache_control?: {
+        type?: string;
+    };
+    thinking?: {
+        content: string;
+        signature?: string;
+    };
+}
+export interface UnifiedTool {
+    type: "function";
+    function: {
+        name: string;
+        description: string;
+        parameters: {
+            type: "object";
+            properties: Record<string, any>;
+            required?: string[];
+            additionalProperties?: boolean;
+            $schema?: string;
+        };
+    };
+}
+export type ThinkLevel = "none" | "low" | "medium" | "high";
+export interface UnifiedChatRequest {
+    messages: UnifiedMessage[];
+    model: string;
+    max_tokens?: number;
+    temperature?: number;
+    stream?: boolean;
+    tools?: UnifiedTool[];
+    tool_choice?: "auto" | "none" | "required" | string | {
+        type: "function";
+        function: {
+            name: string;
+        };
+    };
+    reasoning?: {
+        effort?: ThinkLevel;
+        max_tokens?: number;
+        enabled?: boolean;
+    };
+}
+export interface UnifiedChatResponse {
+    id: string;
+    model: string;
+    content: string | null;
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+    tool_calls?: Array<{
+        id: string;
+        type: "function";
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }>;
+    annotations?: Annotation[];
+}
+export interface StreamChunk {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    choices?: Array<{
+        index: number;
+        delta: {
+            role?: string;
+            content?: string;
+            thinking?: {
+                content?: string;
+                signature?: string;
+            };
+            tool_calls?: Array<{
+                id?: string;
+                type?: "function";
+                function?: {
+                    name?: string;
+                    arguments?: string;
+                };
+            }>;
+            annotations?: Annotation[];
+        };
+        finish_reason?: string | null;
+    }>;
+}
+export type AnthropicStreamEvent = MessageStreamEvent;
+export type OpenAIStreamChunk = ChatCompletionChunk;
+export interface OpenAIChatRequest {
+    messages: OpenAIMessage[];
+    model: string;
+    max_tokens?: number;
+    temperature?: number;
+    stream?: boolean;
+    tools?: ChatCompletionTool[];
+    tool_choice?: "auto" | "none" | {
+        type: "function";
+        function: {
+            name: string;
+        };
+    };
+}
+export interface AnthropicChatRequest {
+    messages: AnthropicMessage[];
+    model: string;
+    max_tokens: number;
+    temperature?: number;
+    stream?: boolean;
+    system?: string | Array<Record<string, any>>;
+    tools?: AnthropicTool[];
+    tool_choice?: {
+        type: "auto";
+    } | {
+        type: "tool";
+        name: string;
+    };
+}
+export interface ConversionOptions {
+    targetProvider: "openai" | "anthropic";
+    sourceProvider: "openai" | "anthropic";
+}
+export interface LLMProvider {
+    name: string;
+    baseUrl: string;
+    apiKey: string;
+    models: string[];
+    /** Optional token for quota/billing APIs that require separate authentication (e.g. Zhipu web console JWT) */
+    quotaToken?: string;
+    transformer?: {
+        [key: string]: {
+            use?: Transformer[];
+        };
+    } & {
+        use?: Transformer[];
+    };
+    /**
+     * How the provider reports input_tokens in usage responses.
+     * - 'exclusive' (default): input_tokens is net of cache, total = input + cache_read + cache_creation + output
+     * - 'inclusive': input_tokens already includes cache tokens, total = input + output
+     */
+    cacheMode?: 'exclusive' | 'inclusive';
+    enabled?: boolean;
+    proxyEnabled?: boolean;
+    wakeupEnabled?: boolean;
+    wakeupTime?: string;
+    wakeupModel?: string;
+}
+export type RegisterProviderRequest = LLMProvider;
+export interface ModelRoute {
+    provider: string;
+    model: string;
+    fullModel: string;
+}
+export interface RequestRouteInfo {
+    provider: LLMProvider;
+    originalModel: string;
+    targetModel: string;
+}
+export interface ConfigProvider {
+    name: string;
+    api_base_url: string;
+    api_key: string;
+    models: string[];
+    /** Optional token for quota/billing APIs that require separate authentication */
+    quota_token?: string;
+    transformer: {
+        use?: string[] | Array<any>[];
+    } & {
+        [key: string]: {
+            use?: string[] | Array<any>[];
+        };
+    };
+    tokenizer?: ProviderTokenizerConfig;
+    /**
+     * How the provider reports input_tokens in usage responses.
+     * - 'exclusive' (default): input_tokens is net of cache, total = input + cache_read + cache_creation + output
+     * - 'inclusive': input_tokens already includes cache tokens, total = input + output
+     */
+    cache_mode?: 'exclusive' | 'inclusive';
+    enabled?: boolean;
+    proxy_enabled?: boolean;
+    wakeup_enabled?: boolean;
+    wakeup_time?: string;
+    wakeup_model?: string;
+}

package/dist/types/transformer.d.ts

@@ -0,0 +1,23 @@
+import { LLMProvider, UnifiedChatRequest } from "./llm";
+export interface TransformerOptions {
+    [key: string]: any;
+}
+interface TransformerWithStaticName {
+    new (options?: TransformerOptions): Transformer;
+    TransformerName?: string;
+}
+export type TransformerConstructor = TransformerWithStaticName;
+export interface TransformerContext {
+    [key: string]: any;
+}
+export type Transformer = {
+    transformRequestIn?: (request: UnifiedChatRequest, provider: LLMProvider, context: TransformerContext) => Promise<Record<string, any>>;
+    transformResponseIn?: (response: Response, context?: TransformerContext) => Promise<Response>;
+    transformRequestOut?: (request: any, context: TransformerContext) => Promise<UnifiedChatRequest>;
+    transformResponseOut?: (response: Response, context: TransformerContext) => Promise<Response>;
+    endPoint?: string;
+    name?: string;
+    auth?: (request: any, provider: LLMProvider, context: TransformerContext) => Promise<any>;
+    logger?: any;
+};
+export {};

package/dist/utils/cache.d.ts

@@ -0,0 +1,17 @@
+export interface Usage {
+    input_tokens: number;
+    output_tokens: number;
+    cache_read_input_tokens: number;
+    cache_creation_input_tokens: number;
+}
+declare class LRUCache<K, V> {
+    private capacity;
+    private cache;
+    constructor(capacity: number);
+    get(key: K): V | undefined;
+    put(key: K, value: V): void;
+    values(): V[];
+    delete(key: K): boolean;
+}
+export declare const sessionUsageCache: LRUCache<string, Usage>;
+export {};

package/dist/utils/converter.d.ts

@@ -0,0 +1,12 @@
+import type { ChatCompletionTool } from "openai/resources/chat/completions";
+import type { Tool as AnthropicTool } from "@anthropic-ai/sdk/resources/messages";
+import { UnifiedChatRequest, UnifiedTool, OpenAIChatRequest, AnthropicChatRequest, ConversionOptions } from "../types/llm";
+export declare function convertToolsToOpenAI(tools: UnifiedTool[]): ChatCompletionTool[];
+export declare function convertToolsToAnthropic(tools: UnifiedTool[]): AnthropicTool[];
+export declare function convertToolsFromOpenAI(tools: ChatCompletionTool[]): UnifiedTool[];
+export declare function convertToolsFromAnthropic(tools: AnthropicTool[]): UnifiedTool[];
+export declare function convertToOpenAI(request: UnifiedChatRequest): OpenAIChatRequest;
+export declare function convertFromOpenAI(request: OpenAIChatRequest): UnifiedChatRequest;
+export declare function convertFromAnthropic(request: AnthropicChatRequest): UnifiedChatRequest;
+export declare function convertToAnthropic(request: UnifiedChatRequest): AnthropicChatRequest;
+export declare function convertRequest(request: OpenAIChatRequest | AnthropicChatRequest | UnifiedChatRequest, options: ConversionOptions): OpenAIChatRequest | AnthropicChatRequest;

package/dist/utils/debug-log.d.ts

@@ -0,0 +1,24 @@
+interface DebugLogOptions {
+    maxBodyLength: number;
+    maxStreamChunks: number;
+}
+export declare function setRuntimeDebugLog(enabled: boolean): void;
+export declare function getRuntimeDebugLog(): boolean;
+export declare function isDebugLogEnabled(configService: any): boolean;
+export declare function getDebugLogOptions(configService: any): DebugLogOptions;
+export declare function maskHeaders(headers: Record<string, string>): Record<string, string>;
+export declare function truncateBody(body: string, maxLen: number): string;
+export declare function logProviderRequest(logger: any, reqId: string, data: {
+    url: string;
+    headers: Record<string, string>;
+    body: any;
+}): void;
+export declare function logProviderResponse(logger: any, reqId: string, data: {
+    status: number;
+    headers: Record<string, string>;
+    body?: string;
+}): void;
+export declare function logStreamChunk(logger: any, reqId: string, chunkIndex: number, chunkStr: string): void;
+export declare function logStreamEnd(logger: any, reqId: string, totalChunks: number): void;
+export declare function readStreamForDebug(stream: ReadableStream<Uint8Array>, logger: any, reqId: string, options: DebugLogOptions): void;
+export {};