@caeliq/llms 1.0.56 → 1.0.57

package/dist/services/tokenizer.d.ts

@@ -0,0 +1,44 @@
+import { ConfigService } from "./config";
+import { ITokenizer, TokenizeRequest, TokenizerConfig, TokenizerResult, TokenizerOptions } from "../types/tokenizer";
+/**
+ * TokenizerService - Manages tokenization for different model types
+ *
+ * Supports three types of tokenizers:
+ * - tiktoken: Fast, OpenAI-compatible tokenizer (default)
+ * - huggingface: Local model-based tokenizer for open-source models
+ * - api: API-based tokenizer for closed-source models
+ *
+ * Features:
+ * - Automatic fallback to tiktoken on errors
+ * - Config-driven tokenizer selection
+ * - Per-provider and per-model configuration
+ */
+export declare class TokenizerService {
+    private tokenizers;
+    private configService;
+    private logger;
+    private options;
+    private fallbackTokenizer?;
+    constructor(configService: ConfigService, logger: any, options?: TokenizerOptions);
+    initialize(): Promise<void>;
+    /**
+     * Get or create a tokenizer for specific configuration
+     */
+    getTokenizer(config: TokenizerConfig): Promise<ITokenizer>;
+    /**
+     * Count tokens for a request using the specified tokenizer configuration
+     */
+    countTokens(request: TokenizeRequest, config?: TokenizerConfig): Promise<TokenizerResult>;
+    /**
+     * Get tokenizer configuration for a specific model/provider
+     */
+    getTokenizerConfigForModel(providerName: string, modelName: string): TokenizerConfig | undefined;
+    /**
+     * Dispose all tokenizers
+     */
+    dispose(): void;
+    /**
+     * Generate cache key from tokenizer config
+     */
+    private getCacheKey;
+}

package/dist/services/transformer.d.ts

@@ -0,0 +1,28 @@
+import { Transformer, TransformerConstructor } from "../types/transformer";
+import { ConfigService } from "./config";
+export declare class TransformerService {
+    private readonly configService;
+    private readonly logger;
+    private transformers;
+    constructor(configService: ConfigService, logger: any);
+    registerTransformer(name: string, transformer: Transformer): void;
+    getTransformer(name: string): Transformer | TransformerConstructor | undefined;
+    getAllTransformers(): Map<string, Transformer | TransformerConstructor>;
+    getTransformersWithEndpoint(): {
+        name: string;
+        transformer: Transformer;
+    }[];
+    getTransformersWithoutEndpoint(): {
+        name: string;
+        transformer: Transformer;
+    }[];
+    removeTransformer(name: string): boolean;
+    hasTransformer(name: string): boolean;
+    registerTransformerFromConfig(config: {
+        path?: string;
+        options?: any;
+    }): Promise<boolean>;
+    initialize(): Promise<void>;
+    private registerDefaultTransformersInternal;
+    private loadFromConfig;
+}

package/dist/tests/anthropic.stream-boundaries.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/anthropic.stream-cancel.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/antigravity.claude-tool-schema.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/antigravity.endpoint-fallback.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/cache-control.strip.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/cache-paths.integration.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/claude-auth.beta-headers.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/codex-auth.reliability.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/cursor-sdk.cancel.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/cursor-sdk.on-delta-thinking.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/cursor-sdk.progress-only.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/cursor-sdk.runner-recovery.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/cursor-sdk.send.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/cursor-sdk.stream-error.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/cursor-sdk.thinking-signature.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/cursor-sdk.usage.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/deepseek.reasoning.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/gemini.abnormal-finish.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/gemini.dual-dialect-request.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/gemini.function-call-signatures.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/gemini.parity.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/gemini.thinking-effort.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/gemini.thought-signature-roundtrip.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/opencode-headers.no-provider-retry.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/thinking-sequencer.dual-dialect.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/transformer-service.endpoints.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/upstream-ports.smoke.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tokenizer/api-tokenizer.d.ts

@@ -0,0 +1,45 @@
+import { ITokenizer, TokenizeRequest, TokenizerConfig } from "../types/tokenizer";
+/**
+ * Options for API tokenizer
+ */
+interface ApiTokenizerOptions {
+    timeout?: number;
+}
+/**
+ * API-based tokenizer implementation
+ * Calls provider's tokenization API to get token counts
+ * Supports flexible configuration for different API formats
+ */
+export declare class ApiTokenizer implements ITokenizer {
+    readonly type = "api";
+    readonly name: string;
+    private config;
+    private logger;
+    private options;
+    constructor(config: TokenizerConfig, logger: any, options?: ApiTokenizerOptions);
+    initialize(): Promise<void>;
+    countTokens(request: TokenizeRequest): Promise<number>;
+    isInitialized(): boolean;
+    dispose(): void;
+    /**
+     * Format request body based on requestFormat
+     */
+    private formatRequestBody;
+    /**
+     * Extract messages in OpenAI format
+     */
+    private extractMessagesAsOpenAIFormat;
+    /**
+     * Extract text from a message
+     */
+    private extractTextFromMessage;
+    /**
+     * Extract all text from request
+     */
+    private extractConcatenatedText;
+    /**
+     * Extract token count from response using the configured field path
+     */
+    private extractTokenCount;
+}
+export {};

package/dist/tokenizer/huggingface-tokenizer.d.ts

@@ -0,0 +1,52 @@
+import { ITokenizer, TokenizeRequest } from "../types/tokenizer";
+/**
+ * Options for HuggingFace tokenizer
+ */
+interface HFTokenizerOptions {
+    timeout?: number;
+    cacheDir?: string;
+}
+/**
+ * HuggingFace tokenizer implementation
+ * Uses @huggingface/tokenizers library for lightweight tokenization
+ */
+export declare class HuggingFaceTokenizer implements ITokenizer {
+    readonly type = "huggingface";
+    readonly name: string;
+    private readonly modelId;
+    private readonly logger;
+    private readonly options;
+    private tokenizer;
+    private readonly cacheDir;
+    private readonly safeModelName;
+    constructor(modelId: string, logger: any, options?: HFTokenizerOptions);
+    /**
+     * Get cache file paths for tokenizer files
+     */
+    private getCachePaths;
+    /**
+     * Ensure directory exists
+     */
+    private ensureDir;
+    /**
+     * Load tokenizer files from local cache
+     */
+    private loadFromCache;
+    /**
+     * Download tokenizer files from Hugging Face Hub and save to cache
+     */
+    private downloadAndCache;
+    initialize(): Promise<void>;
+    countTokens(request: TokenizeRequest): Promise<number>;
+    isInitialized(): boolean;
+    /**
+     * Encode text to tokens (for simple text tokenization)
+     */
+    encodeText(text: string): number[];
+    dispose(): void;
+    /**
+     * Extract text from tokenize request
+     */
+    private extractTextFromRequest;
+}
+export {};

package/dist/tokenizer/tiktoken-tokenizer.d.ts

@@ -0,0 +1,20 @@
+import { TiktokenEncoding } from "tiktoken";
+import type { ITokenizer, TokenizeRequest } from "../types/tokenizer";
+/**
+ * Tiktoken-based tokenizer implementation
+ * Uses tiktoken library for fast token counting (OpenAI compatible)
+ */
+export declare class TiktokenTokenizer implements ITokenizer {
+    readonly type = "tiktoken";
+    readonly name: string;
+    private encoding?;
+    constructor(encodingName?: TiktokenEncoding);
+    initialize(): Promise<void>;
+    countTokens(request: TokenizeRequest): Promise<number>;
+    isInitialized(): boolean;
+    /**
+     * Encode text to tokens (for simple text tokenization)
+     */
+    encodeText(text: string): number[];
+    dispose(): void;
+}

package/dist/transformer/anthropic.transformer.d.ts

@@ -0,0 +1,22 @@
+import { LLMProvider, UnifiedChatRequest } from "../types/llm";
+import { Transformer, TransformerContext, TransformerOptions } from "../types/transformer";
+export declare class AnthropicTransformer implements Transformer {
+    private readonly options?;
+    name: string;
+    endPoint: string;
+    private useBearer;
+    logger?: any;
+    constructor(options?: TransformerOptions | undefined);
+    auth(request: any, provider: LLMProvider, _context?: any): Promise<any>;
+    transformRequestOut(request: Record<string, any>, context?: any): Promise<UnifiedChatRequest>;
+    transformResponseIn(response: Response, context?: TransformerContext): Promise<Response>;
+    /**
+     * Rebuild an Anthropic-format request body from a UnifiedChatRequest.
+     * Used by claude-auth.transformRequestIn() to reconstruct the body before
+     * sending to Anthropic, preserving all original parameters.
+     */
+    static buildAnthropicBody(request: UnifiedChatRequest, logger?: any): Record<string, any>;
+    private convertAnthropicToolsToUnified;
+    private convertOpenAIStreamToAnthropic;
+    private convertOpenAIResponseToAnthropic;
+}

package/dist/transformer/antigravity-auth.transformer.d.ts

@@ -0,0 +1,15 @@
+import { Transformer } from "../types/transformer";
+export declare class AntigravityAuthTransformer implements Transformer {
+    name: string;
+    logger?: any;
+    private buildAuthAndEnvelope;
+    private buildHeaders;
+    /**
+     * Own the upstream fetch so we can refresh on 401, walk endpoint fallbacks,
+     * and surface 429 RetryInfo without leaking into the generic pipeline.
+     */
+    private sendWithFallback;
+    transformRequestIn(request: any, provider: any, context: any): Promise<Record<string, any>>;
+    auth(_request: any, provider: any, context: any): Promise<any>;
+    transformResponseOut(response: Response): Promise<Response>;
+}

package/dist/transformer/cerebras.transformer.d.ts

@@ -0,0 +1,16 @@
+import { LLMProvider, UnifiedChatRequest } from "../types/llm";
+import { Transformer } from "../types/transformer";
+/**
+ * Transformer class for Cerebras
+ */
+export declare class CerebrasTransformer implements Transformer {
+    name: string;
+    /**
+     * Transform the request from Claude Code format to Cerebras format
+     * @param request - The incoming request
+     * @param provider - The LLM provider information
+     * @returns The transformed request
+     */
+    transformRequestIn(request: UnifiedChatRequest, provider: LLMProvider, context?: any): Promise<Record<string, unknown>>;
+    transformResponseOut(response: Response): Promise<Response>;
+}

package/dist/transformer/chrome-on-device.transformer.d.ts

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

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

@@ -0,0 +1,25 @@
+import { UnifiedChatRequest } from "../types/llm";
+import { Transformer, TransformerContext } from "../types/transformer";
+/** Anthropic beta required for Claude subscription / Claude Code OAuth Bearer auth. */
+export declare const CLAUDE_OAUTH_REQUIRED_BETA = "oauth-2025-04-20";
+export declare function mergeAnthropicBetaValues(...values: Array<string | undefined | null>): string;
+/** Read a named header value from a Fastify/Node headers object (case-insensitive). */
+export declare function readHeaderValue(headers: Record<string, unknown> | undefined, name: string): string | undefined;
+/**
+ * Build outbound anthropic-beta for Claude subscription OAuth.
+ *
+ * - If the client sent anthropic-beta (e.g. Claude Code), merge with
+ *   oauth-2025-04-20 (deduped, case-insensitive).
+ * - Otherwise, send only oauth-2025-04-20. Do not synthesise Claude Code
+ *   betas — Anthropic validates the attestation on claude-code-20250219
+ *   and subscription OAuth works without it for non-Claude-Code clients.
+ */
+export declare function resolveClaudeAuthAnthropicBeta(input: {
+    clientBeta?: string;
+}): string;
+export declare class ClaudeAuthTransformer implements Transformer {
+    name: string;
+    logger?: any;
+    transformRequestIn(request: UnifiedChatRequest, provider: any, context?: TransformerContext): Promise<Record<string, any>>;
+    transformResponseOut(response: Response): Promise<Response>;
+}

package/dist/transformer/cleancache.transformer.d.ts

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

package/dist/transformer/codex.transformer.d.ts

@@ -0,0 +1,61 @@
+import { UnifiedChatRequest } from "../types/llm";
+import { Transformer } from "../types/transformer";
+export declare class CodexTransformer implements Transformer {
+    name: string;
+    logger?: any;
+    private streamIntent;
+    transformRequestIn(request: UnifiedChatRequest, provider: any, context?: any): Promise<Record<string, any>>;
+    auth(request: any, provider: any): Promise<any>;
+    private resolveAuth;
+    private buildAuthHeaders;
+    private recoverUnauthorizedAuth;
+    private resolvePatAuth;
+    private requestPatAuth;
+    transformResponseOut(response: Response, context?: {
+        req?: {
+            id?: string;
+        };
+    }): Promise<Response>;
+    private transformResponseOutInner;
+    private convertStreamEvent;
+    /**
+     * Consume a Codex SSE response fully and return a single OpenAI
+     * ChatCompletion JSON. Used for non-streaming Anthropic SDK calls
+     * (e.g. client.beta.messages.create with stream:false) where the
+     * SDK expects a flat BetaMessage. The SDK accumulates the response
+     * by reading a single JSON object, not by parsing SSE, so we
+     * have to materialize the response here.
+     */
+    /**
+     * Re-emit a single OpenAI ChatCompletion JSON as a one-shot SSE stream of
+     * `chat.completion.chunk` events, so a streaming caller (which expects SSE)
+     * still receives the content when codex returned a flat JSON instead of a
+     * stream. The downstream anthropic transformer's stream reader parses each
+     * `data:` line as a chunk, so we split the full message into proper delta
+     * chunks (text content first, then a final chunk with finish_reason + usage)
+     * — emitting the raw chat.completion would put the text under `message`
+     * instead of `delta` and the content would be dropped.
+     */
+    private jsonToSseStream;
+    /**
+     * Peek at the first non-whitespace character of a cloned response body to
+     * distinguish a real SSE stream (starts with `data:` or `event:`, first
+     * char `d` or `e`) from a flat JSON body (first char `{` or `[`) that the
+     * codex API sometimes returns even with text/event-stream Content-Type.
+     *
+     * - **For flat JSON** (`{` / `[`): reads the full clone body and returns
+     *   `{ firstChar, text }` so the caller can parse and handle it.
+     * - **For SSE** (anything else): returns `null` immediately after reading
+     *   only the first chunk from the clone. The original `response.body` on
+     *   the other side of the tee is untouched and can still be streamed live
+     *   by the SSE reader — avoiding buffering the entire response.
+     *
+     * Callers must pass `response.clone().body!` so the original body is not
+     * consumed by the peek.
+     */
+    private readBodyAndPeek;
+    private collectSseIntoChatCompletion;
+    private normalizeRequestContent;
+    private convertResponseToChat;
+    private buildImageContent;
+}

package/dist/transformer/cursor-sdk.transformer.d.ts

@@ -0,0 +1,23 @@
+import type { UnifiedChatRequest } from "../types/llm";
+import type { Transformer, TransformerOptions } from "../types/transformer";
+import { type CursorSdkMode } from "../cursor-sdk/shared";
+export interface CursorSdkTransformerOptions extends TransformerOptions {
+    cursorMode?: CursorSdkMode;
+    cursorCwd?: string;
+    /** Opt-in only; forced off in Docker. Default false. */
+    sandboxEnabled?: boolean;
+}
+/**
+ * Thin CCR transformer that owns the full upstream call via @cursor/sdk.
+ * Returns OpenAI-compatible SSE/JSON through config.__providerResponse so
+ * AnthropicTransformer can convert to Claude Code's wire format unchanged.
+ */
+export declare class CursorSdkTransformer implements Transformer {
+    static TransformerName: string;
+    name: string;
+    logger?: any;
+    private options;
+    constructor(options?: CursorSdkTransformerOptions);
+    transformRequestIn(request: UnifiedChatRequest, provider: any, context?: any): Promise<Record<string, any>>;
+    transformResponseOut(response: Response): Promise<Response>;
+}

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, provider?: any, context?: any): Promise<UnifiedChatRequest>;
+    transformResponseOut(response: Response, context?: any): Promise<Response>;
+}

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

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

package/dist/transformer/extrathinktag.transformer.d.ts

@@ -0,0 +1,10 @@
+import { Transformer } from "../types/transformer";
+/**
+ * Extracts <think>...</think> blocks from OpenAI-compatible responses into
+ * thinking.content (and streaming thinking deltas).
+ */
+export declare class ExtraThinkTagTransformer implements Transformer {
+    name: string;
+    transformRequestIn(request: any): Promise<any>;
+    transformResponseOut(response: Response): Promise<Response>;
+}

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

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

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

@@ -0,0 +1,15 @@
+import { LLMProvider, UnifiedChatRequest } from "../types/llm";
+import { Transformer, TransformerContext, TransformerOptions } from "../types/transformer";
+export declare class GeminiTransformer implements Transformer {
+    private readonly options?;
+    static TransformerName: string;
+    logger?: any;
+    name: string;
+    endPoint: string;
+    private readonly cachedContent;
+    private readonly thoughtSignatureFallback;
+    constructor(options?: TransformerOptions | undefined);
+    transformRequestIn(request: UnifiedChatRequest, provider: LLMProvider, context: any): Promise<Record<string, any>>;
+    transformRequestOut(request: any): Promise<UnifiedChatRequest>;
+    transformResponseOut(response: Response, context?: TransformerContext): 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,65 @@
+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 { VertexOpenaiTransformer } from "./vertex-openai.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 { CodexTransformer } from "./codex.transformer";
+import { QwenAuthTransformer } from "./qwen-auth.transformer";
+import { ForceReasoningTransformer } from "./forcereasoning.transformer";
+import { ExtraThinkTagTransformer } from "./extrathinktag.transformer";
+import { MistralTransformer } from "./mistral.transformer";
+import { ChromeOnDeviceTransformer } from "./chrome-on-device.transformer";
+import { OpencodeHeadersTransformer } from "./opencode-headers.transformer";
+import { ClaudeAuthTransformer } from "./claude-auth.transformer";
+import { CursorSdkTransformer } from "./cursor-sdk.transformer";
+import { AntigravityAuthTransformer } from "./antigravity-auth.transformer";
+declare const _default: {
+    AnthropicTransformer: typeof AnthropicTransformer;
+    GeminiTransformer: typeof GeminiTransformer;
+    VertexGeminiTransformer: typeof VertexGeminiTransformer;
+    VertexClaudeTransformer: typeof VertexClaudeTransformer;
+    VertexOpenaiTransformer: typeof VertexOpenaiTransformer;
+    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;
+    CodexTransformer: typeof CodexTransformer;
+    QwenAuthTransformer: typeof QwenAuthTransformer;
+    ForceReasoningTransformer: typeof ForceReasoningTransformer;
+    ExtraThinkTagTransformer: typeof ExtraThinkTagTransformer;
+    MistralTransformer: typeof MistralTransformer;
+    ChromeOnDeviceTransformer: typeof ChromeOnDeviceTransformer;
+    OpencodeHeadersTransformer: typeof OpencodeHeadersTransformer;
+    ClaudeAuthTransformer: typeof ClaudeAuthTransformer;
+    CursorSdkTransformer: typeof CursorSdkTransformer;
+    AntigravityAuthTransformer: typeof AntigravityAuthTransformer;
+};
+export default _default;

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