qlogicagent 2.10.12 → 2.10.13

package/dist/types/provider-core/transports/anthropic-messages.d.ts

@@ -1,65 +0,0 @@
-/**
- * Anthropic Messages TransportSSE streaming for Claude API.
- *
- * Aligned with CC (claude-code-haha) src/services/api/claude.ts:
- *   - cache_control ephemeral injection on system prompt blocks
- *   - ensureToolResultPairing() conversation repair before every request
- *   - Retry with exponential backoff on transient errors (429/529/overloaded)
- *   - Non-streaming fallback when stream errors out
- *   - 90s idle watchdog timeout for silently dropped connections
- *   - Adaptive/budget thinking with temperature omit
- *   - Cache token extraction with >0 guard (CC updateUsage parity)
- *   - signature_delta handling for thinking blocks
- */
-import type { LLMChunk, LLMRequest, LLMTransport } from "../transport.js";
-import type { ProviderQuirks } from "../provider-def.js";
-import type { FileUploadAdapter } from "../file-upload-service.js";
-export interface AnthropicTransportConfig {
-    baseUrl: string;
-    /** anthropic-version header (default "2023-06-01") */
-    apiVersion?: string;
-    /** Per-request timeout in ms (default 180_000) */
-    timeoutMs?: number;
-    /** Stream idle watchdog timeout in ms (default 90_000, CC parity) */
-    streamIdleTimeoutMs?: number;
-    /** Enable prompt caching via cache_control ephemeral (default true) */
-    enablePromptCaching?: boolean;
-    /** Max retry attempts on transient errors (default 3) */
-    maxRetries?: number;
-    /** Omit temperature when it equals 0MiniMax rejects temperature=0 */
-    omitZeroTemperature?: boolean;
-    /** Provider-specific quirks for conditional logic (CC/altcode parity) */
-    quirks?: ProviderQuirks;
-    /** File upload adapter (Hub OSS relay for Anthropic). */
-    fileUploadAdapter?: FileUploadAdapter;
-}
-export declare class AnthropicMessagesTransport implements LLMTransport {
-    private baseUrl;
-    private apiVersion;
-    private timeoutMs;
-    private streamIdleTimeoutMs;
-    private enablePromptCaching;
-    private maxRetries;
-    private omitZeroTemperature;
-    private quirks;
-    private fileUploadAdapter?;
-    constructor(config: AnthropicTransportConfig);
-    stream(request: LLMRequest, apiKey: string, signal?: AbortSignal): AsyncGenerator<LLMChunk>;
-    /**
-     * Stream with idle watchdog timer (CC parity: 90s default).
-     * Throws if no chunks received for streamIdleTimeoutMs.
-     */
-    private streamWithWatchdog;
-    /**
-     * Non-streaming fallback (CC executeNonStreamingRequest parity).
-     * Used when streaming fails after all retries.
-     * Caps max_tokens at 64K and adjusts thinking budget accordingly.
-     */
-    private nonStreamingFallback;
-    /**
-     * Convert a non-streaming API response to LLMChunk sequence.
-     */
-    private mapNonStreamingResponse;
-    private parseSSEStream;
-    private mapEvent;
-}

package/dist/types/provider-core/transports/gemini-cache-api.d.ts

@@ -1,86 +0,0 @@
-/**
- * GeminiCacheAPI 鈥?Explicit Context Caching for Gemini generateContent.
- *
- * Manages named cached content resources that can be referenced in
- * generateContent requests via the `cachedContent` field.
- *
- * REST endpoints:
- *   POST   /v1beta/cachedContents          鈥?create cache
- *   GET    /v1beta/cachedContents           鈥?list caches
- *   GET    /v1beta/cachedContents/{name}    鈥?get cache metadata
- *   PATCH  /v1beta/cachedContents/{name}    鈥?update TTL
- *   DELETE /v1beta/cachedContents/{name}    鈥?delete cache
- *
- * Minimum cacheable content: 1024 tokens (Flash) / 4096 tokens (Pro).
- * TTL default: 1 hour. Storage: ~$1.00/hour/MTok (Flash series).
- *
- * Docs: https://ai.google.dev/gemini-api/docs/caching
- */
-export interface GeminiCacheCreateOptions {
-    /** Model to use, e.g. "models/gemini-3-flash-preview" */
-    model: string;
-    /** Contents to cache (same format as generateContent contents) */
-    contents: Array<Record<string, unknown>>;
-    /** Optional system instruction to include in cache */
-    systemInstruction?: Record<string, unknown>;
-    /** Time-to-live, e.g. "300s" for 5 minutes. Default: "3600s" (1 hour) */
-    ttl?: string;
-    /** Human-readable name for identifying the cache */
-    displayName?: string;
-}
-export interface GeminiCachedContent {
-    /** Resource name, e.g. "cachedContents/abc123" */
-    name: string;
-    /** Model this cache is bound to */
-    model: string;
-    /** Display name (if set) */
-    displayName?: string;
-    /** Token usage metadata */
-    usageMetadata?: {
-        totalTokenCount?: number;
-    };
-    /** Creation time (ISO 8601) */
-    createTime?: string;
-    /** Last update time (ISO 8601) */
-    updateTime?: string;
-    /** Expiration time (ISO 8601) */
-    expireTime?: string;
-}
-export declare class GeminiCacheAPI {
-    private baseUrl;
-    private timeoutMs;
-    constructor(config: {
-        baseUrl: string;
-        timeoutMs?: number;
-    });
-    /**
-     * Create a new cached content resource.
-     * The cache name returned can be passed as `cachedContent` in generateContent.
-     */
-    createCache(options: GeminiCacheCreateOptions, apiKey: string, signal?: AbortSignal): Promise<GeminiCachedContent>;
-    /**
-     * Get metadata for a cached content resource.
-     */
-    getCache(name: string, apiKey: string, signal?: AbortSignal): Promise<GeminiCachedContent>;
-    /**
-     * List all cached content resources.
-     */
-    listCaches(apiKey: string, options?: {
-        pageSize?: number;
-        pageToken?: string;
-    }, signal?: AbortSignal): Promise<{
-        cachedContents: GeminiCachedContent[];
-        nextPageToken?: string;
-    }>;
-    /**
-     * Update a cache's TTL or expiration time.
-     */
-    updateCache(name: string, update: {
-        ttl?: string;
-        expireTime?: string;
-    }, apiKey: string, signal?: AbortSignal): Promise<GeminiCachedContent>;
-    /**
-     * Delete a cached content resource.
-     */
-    deleteCache(name: string, apiKey: string, signal?: AbortSignal): Promise<void>;
-}

package/dist/types/provider-core/transports/gemini-file-api.d.ts

@@ -1,90 +0,0 @@
-/**
- * GeminiFileAPI 鈥?Gemini File API for uploading and managing files.
- *
- * Files uploaded via this API can be referenced in generateContent requests
- * using `file_data: { file_uri, mime_type }` parts.
- *
- * Upload uses the resumable upload protocol (2-step):
- *   1. POST /upload/v1beta/files 鈫?get upload URL (response header)
- *   2. PUT {upload_url} with file bytes 鈫?get file info
- *
- * Other operations:
- *   GET    /v1beta/files           鈥?list files
- *   GET    /v1beta/files/{name}    鈥?get file metadata
- *   DELETE /v1beta/files/{name}    鈥?delete file
- *
- * Files expire after 48 hours. Max 2GB per file, 20GB per project.
- *
- * Docs: https://ai.google.dev/gemini-api/docs/files
- */
-export interface GeminiFileInfo {
-    /** Resource name, e.g. "files/abc123" */
-    name: string;
-    /** Display name (set during upload) */
-    displayName?: string;
-    /** MIME type */
-    mimeType: string;
-    /** File size in bytes */
-    sizeBytes?: string;
-    /** File URI for use in generateContent, e.g. "https://generativelanguage.googleapis.com/v1beta/files/abc123" */
-    uri: string;
-    /** Processing state: PROCESSING | ACTIVE | FAILED */
-    state: string;
-    /** Creation time (ISO 8601) */
-    createTime?: string;
-    /** Last update time (ISO 8601) */
-    updateTime?: string;
-    /** Expiration time (ISO 8601) */
-    expirationTime?: string;
-    /** Error info if state is FAILED */
-    error?: {
-        code: number;
-        message: string;
-    };
-}
-export declare class GeminiFileAPI {
-    private baseUrl;
-    private timeoutMs;
-    constructor(config: {
-        baseUrl: string;
-        timeoutMs?: number;
-    });
-    /**
-     * Upload a file using the resumable upload protocol.
-     *
-     * Step 1: Initiate upload 鈫?get upload URL from response header
-     * Step 2: Upload bytes to that URL 鈫?get file metadata
-     *
-     * @returns GeminiFileInfo with .uri for use in generateContent
-     */
-    uploadFile(file: Blob | Buffer, apiKey: string, options?: {
-        mimeType?: string;
-        displayName?: string;
-    }, signal?: AbortSignal): Promise<GeminiFileInfo>;
-    /**
-     * Wait for a file to finish processing (state 鈫?ACTIVE).
-     * Some file types (video, audio) require server-side processing.
-     */
-    waitForProcessing(name: string, apiKey: string, options?: {
-        pollIntervalMs?: number;
-        maxWaitMs?: number;
-    }): Promise<GeminiFileInfo>;
-    /**
-     * Get metadata for an uploaded file.
-     */
-    getFile(name: string, apiKey: string, signal?: AbortSignal): Promise<GeminiFileInfo>;
-    /**
-     * List uploaded files.
-     */
-    listFiles(apiKey: string, options?: {
-        pageSize?: number;
-        pageToken?: string;
-    }, signal?: AbortSignal): Promise<{
-        files: GeminiFileInfo[];
-        nextPageToken?: string;
-    }>;
-    /**
-     * Delete an uploaded file.
-     */
-    deleteFile(name: string, apiKey: string, signal?: AbortSignal): Promise<void>;
-}

package/dist/types/provider-core/transports/gemini-generatecontent.d.ts

@@ -1,56 +0,0 @@
-/**
- * Gemini generateContent TransportNative Gemini API streaming implementation.
- *
- * Targets Gemini 3 series exclusively (3.1 Pro, 3 Flash, 3.1 Flash-Lite).
- * Uses the native Gemini REST API instead of the OpenAI compatibility layer,
- * unlocking Gemini-exclusive features unavailable via the compat endpoint:
- *   - thinkingConfig (thinkingLevelG3 native control)
- *   - Google Search / Maps Grounding
- *   - Code Execution
- *   - Safety Settings fine-grained control
- *   - Thought Signatures for multi-turn reasoning continuity
- *   - URL Context / File Search
- *   - systemInstruction top-level field
- *
- * Streaming endpoint: POST .../models/{model}:streamGenerateContent?alt=sse
- * Non-streaming:      POST .../models/{model}:generateContent
- * Auth: x-goog-api-key header
- *
- * Protocol reference: https://ai.google.dev/gemini-api/docs
- * Aligned with gemini-ProviderMax.md native protocol strategy.
- */
-import type { LLMChunk, LLMRequest, LLMTransport } from "../transport.js";
-import type { ProviderQuirks } from "../provider-def.js";
-import type { FileUploadAdapter } from "../file-upload-service.js";
-export interface GeminiGenerateContentTransportConfig {
-    /** Base URL, e.g. "https://generativelanguage.googleapis.com/v1beta" */
-    baseUrl: string;
-    /** Per-request timeout in ms (default 180_000) */
-    timeoutMs?: number;
-    /** Provider-specific quirks */
-    quirks?: ProviderQuirks;
-    /** File upload adapter for resolving local media URLs via upload instead of base64. */
-    fileUploadAdapter?: FileUploadAdapter;
-}
-export declare class GeminiGenerateContentTransport implements LLMTransport {
-    private baseUrl;
-    private timeoutMs;
-    private quirks;
-    private fileUploadAdapter?;
-    constructor(config: GeminiGenerateContentTransportConfig);
-    stream(request: LLMRequest, apiKey: string, signal?: AbortSignal): AsyncGenerator<LLMChunk>;
-    private buildRequestBody;
-    private buildTools;
-    private buildToolConfig;
-    private buildGenerationConfig;
-    private fetchAndStream;
-    /**
-     * Parse SSE stream with 90s idle watchdog (CC parity).
-     */
-    private parseSSEStreamWithWatchdog;
-    /**
-     * Process a single Gemini response chunk, yielding LLMChunk events.
-     */
-    private processResponse;
-    private nonStreamingFallback;
-}

package/dist/types/provider-core/transports/gemini-lyria-realtime.d.ts

@@ -1,117 +0,0 @@
-/**
- * GeminiLyriaRealtimeSession 鈥?WebSocket-based real-time streaming music generation.
- *
- * Uses Lyria RealTime (`lyria-realtime-exp`) via the Gemini Live API WebSocket.
- * Provides both a full interactive session API and a one-shot convenience method.
- *
- * Protocol:
- *   - WebSocket URL: wss://generativelanguage.googleapis.com/ws/google.ai.generativelanguage.v1alpha.GenerativeService.BidiGenerateContent
- *   - Auth: API key as query parameter
- *   - Client 鈫?Server: setup, musicInput (weightedPrompts, musicGenerationConfig, playbackControl)
- *   - Server 鈫?Client: serverContent.audioChunks (base64 PCM s16le, 48kHz, stereo)
- *
- * Docs: https://ai.google.dev/gemini-api/docs/realtime-music-generation
- */
-export interface WeightedPrompt {
-    text: string;
-    weight: number;
-}
-export type MusicScale = "C_MAJOR_A_MINOR" | "D_FLAT_MAJOR_B_FLAT_MINOR" | "D_MAJOR_B_MINOR" | "E_FLAT_MAJOR_C_MINOR" | "E_MAJOR_D_FLAT_MINOR" | "F_MAJOR_D_MINOR" | "G_FLAT_MAJOR_E_FLAT_MINOR" | "G_MAJOR_E_MINOR" | "A_FLAT_MAJOR_F_MINOR" | "A_MAJOR_G_FLAT_MINOR" | "B_FLAT_MAJOR_G_MINOR" | "B_MAJOR_A_FLAT_MINOR" | "SCALE_UNSPECIFIED";
-export type MusicGenerationMode = "QUALITY" | "DIVERSITY" | "VOCALIZATION";
-export interface MusicGenerationConfig {
-    bpm?: number;
-    density?: number;
-    brightness?: number;
-    guidance?: number;
-    scale?: MusicScale;
-    temperature?: number;
-    topK?: number;
-    seed?: number;
-    muteBass?: boolean;
-    muteDrums?: boolean;
-    onlyBassAndDrums?: boolean;
-    musicGenerationMode?: MusicGenerationMode;
-    audioFormat?: string;
-    sampleRateHz?: number;
-}
-export interface LyriaRealtimeConfig {
-    /** Base URL (REST), e.g. "https://generativelanguage.googleapis.com/v1beta" */
-    baseUrl: string;
-}
-export interface LyriaRealtimeSessionOptions {
-    model?: string;
-    prompts: WeightedPrompt[];
-    config?: MusicGenerationConfig;
-}
-/** Audio chunk received from the server. */
-export interface AudioChunk {
-    /** Raw PCM s16le data (48kHz, stereo) */
-    data: Buffer;
-}
-/**
- * Interactive Lyria RealTime session over WebSocket.
- *
- * Usage:
- *   const session = new GeminiLyriaRealtimeSession({ baseUrl: "..." });
- *   await session.connect(apiKey, { prompts: [{ text: "jazz", weight: 1 }] });
- *   session.onAudioChunk = (chunk) => { ... };
- *   await session.play();
- *   // ... later
- *   await session.stop();
- *   session.close();
- */
-export declare class GeminiLyriaRealtimeSession {
-    private ws;
-    private wsUrl;
-    private model;
-    /** Called for each audio chunk received from the server. */
-    onAudioChunk: ((chunk: AudioChunk) => void) | null;
-    /** Called when the server reports a filtered prompt. */
-    onFilteredPrompt: ((reason: string) => void) | null;
-    /** Called on WebSocket error. */
-    onError: ((error: Error) => void) | null;
-    /** Called when the WebSocket connection closes. */
-    onClose: (() => void) | null;
-    constructor(config: LyriaRealtimeConfig);
-    /**
-     * Connect to the Lyria RealTime WebSocket and send setup + initial config.
-     */
-    connect(apiKey: string, options: LyriaRealtimeSessionOptions): Promise<void>;
-    /** Set or update weighted prompts (smooth transition). */
-    setWeightedPrompts(prompts: WeightedPrompt[]): Promise<void>;
-    /** Set or update music generation config. */
-    setMusicGenerationConfig(config: MusicGenerationConfig): Promise<void>;
-    /** Start streaming music. */
-    play(): Promise<void>;
-    /** Pause music streaming (can resume with play). */
-    pause(): Promise<void>;
-    /** Stop music streaming (terminates the current piece). */
-    stop(): Promise<void>;
-    /** Reset model context (for BPM/scale changes). */
-    resetContext(): Promise<void>;
-    /** Close the WebSocket connection. */
-    close(): void;
-    /** Whether the session is connected. */
-    get connected(): boolean;
-    private send;
-    private handleMessage;
-}
-/**
- * Generate a fixed-duration music clip using Lyria RealTime.
- *
- * Connects, plays for the specified duration (default 30s), collects all
- * audio chunks, assembles into a WAV file, and returns the file path.
- *
- * Output: 48kHz, stereo, 16-bit PCM wrapped in WAV.
- */
-export declare function generateRealtimeMusic(apiKey: string, config: LyriaRealtimeConfig, options: {
-    prompts: WeightedPrompt[];
-    durationSeconds?: number;
-    musicConfig?: MusicGenerationConfig;
-    model?: string;
-    signal?: AbortSignal;
-    onProgress?: (percent: number, status: string) => void;
-}): Promise<{
-    filePath: string;
-    durationMs: number;
-}>;

package/dist/types/provider-core/transports/gemini-media.d.ts

@@ -1,53 +0,0 @@
-/**
- * Gemini Media Transport 鈥?unified media generation for all Gemini media APIs.
- *
- * Supported media types and endpoints:
- *   image          鈥?POST /models/{model}:generateContent  (responseModalities: ["TEXT","IMAGE"])
- *   video          鈥?POST /models/{model}:predictLongRunning 鈫?poll operations 鈫?download URI
- *   music          鈥?POST /models/{model}:generateContent  (Lyria 3 鈥?inlineData audio)
- *   music_realtime 鈥?WebSocket session (Lyria RealTime 鈥?streaming PCM 鈫?WAV)
- *   tts            鈥?POST /models/{model}:generateContent  (speechConfig 鈥?inlineData PCM)
- *   embedding      鈥?POST /models/{model}:embedContent   (float vector)
- *
- * Auth: x-goog-api-key header for all endpoints.
- */
-import type { AsyncMediaTransport, MediaRequest, MediaResult, MediaType } from "../media-transport.js";
-export interface GeminiMediaConfig {
-    /** Base URL, e.g. "https://generativelanguage.googleapis.com/v1beta" */
-    baseUrl: string;
-    timeoutMs?: number;
-}
-export declare class GeminiMediaTransport implements AsyncMediaTransport {
-    readonly supportedTypes: readonly MediaType[];
-    private apiBase;
-    private timeoutMs;
-    constructor(config: GeminiMediaConfig);
-    generate(request: MediaRequest, apiKey: string, signal?: AbortSignal): Promise<MediaResult>;
-    deleteVideoTask(_taskId: string, _apiKey: string, _signal?: AbortSignal): Promise<void>;
-    listVideoTasks(_apiKey: string, _options?: {
-        after?: string;
-        limit?: number;
-        status?: string;
-    }, _signal?: AbortSignal): Promise<Record<string, unknown>>;
-    getTaskStatus(taskId: string, apiKey: string, signal?: AbortSignal): Promise<{
-        status: string;
-        task: Record<string, unknown>;
-    }>;
-    private generateImage;
-    private generateVideo;
-    private generateMusic;
-    private generateMusicRealtime;
-    private generateTTS;
-    private generateEmbedding;
-    private postJson;
-    private pollOperation;
-    /**
-     * Resolve an image URL to inline data for the Veo API.
-     * Supports file:// paths and https:// URLs.
-     */
-    private resolveImageData;
-    /** Extract base64 image data from generateContent response 鈫?persist to cache files. */
-    private extractInlineImages;
-    /** Extract base64 audio data from generateContent response 鈫?persist to cache files. */
-    private extractInlineAudio;
-}

package/dist/types/provider-core/transports/media-resolve.d.ts

@@ -1,50 +0,0 @@
-/**
- * Media URL Resolution 鈥?resolves local/private URLs for cloud LLM APIs.
- *
- * Cloud LLM APIs (OpenAI, Anthropic, DeepSeek, etc.) cannot fetch content
- * from localhost or private networks.
- *
- * **Primary approach (upload-based):**
- *   Local URLs are fetched 鈫?uploaded to provider's File API or Aliyun OSS 鈫?public URL returned.
- *   This is the ONLY approach for images, video, and documents.
- *
- * **Audio exception (base64):**
- *   OpenAI's input_audio.data API field mandates base64 encoding.
- *   resolveMediaUrl() is retained ONLY for this case.
- *
- * URL-first design: the gateway stores media as HTTP URLs; this layer handles
- * the last-mile transformation before sending to provider APIs.
- */
-import type { FileUploadAdapter } from "../file-upload-service.js";
-/** Check if a URL points to a local/private address that cloud APIs cannot reach. */
-export declare function isLocalUrl(url: string): boolean;
-export interface MediaResolveContext {
-    /** Provider-specific upload adapter. */
-    uploadAdapter: FileUploadAdapter;
-    /** API key for the upload. */
-    apiKey: string;
-    /** Abort signal. */
-    signal?: AbortSignal;
-}
-/**
- * Resolve a local URL by uploading to the provider's File API.
- * This is the **preferred** method for all media types.
- *
- * Public URLs pass through unchanged.
- * Local URLs are uploaded 鈫?public URL or file_id returned.
- */
-export declare function resolveMediaUrlViaUpload(url: string, ctx: MediaResolveContext): Promise<string>;
-/**
- * Batch-resolve URLs via upload. Best-effort: failures return original URL.
- */
-export declare function resolveMediaUrlsViaUpload(urls: string[], ctx: MediaResolveContext): Promise<string[]>;
-/**
- * Resolve local audio URL to base64 data URL.
- *
- * ONLY for audio 鈥?OpenAI's input_audio.data API field mandates base64 encoding.
- * There is no upload alternative for audio in the OpenAI API.
- *
- * For images/video/documents: ALWAYS use resolveMediaUrlViaUpload() instead.
- * base64 is forbidden for non-audio media per project architecture rules.
- */
-export declare function resolveMediaUrl(url: string, fallbackMime?: string): Promise<string>;

package/dist/types/provider-core/transports/minimax-media.d.ts

@@ -1,56 +0,0 @@
-/**
- * MiniMax Media Transport 鈥?Music + Video + TTS Generation.
- *
- * Music: POST /v1/music_generation (sync or async poll)
- * Video: POST /v1/video_generation (4 modes: text, image, first-last-frame, subject-ref)
- * Video Query: GET /v1/query/video_generation?task_id=XXX
- * File Retrieve: GET /v1/files/retrieve?file_id=XXX (get download_url)
- *
- * Auth: Authorization: Bearer $MINIMAX_API_KEY
- * Docs: minimax-ProviderMax.md 搂13-18 (video), 搂21 (music), 搂24-28 (files)
- */
-import type { AsyncMediaTransport, MediaRequest, MediaResult, MediaType } from "../media-transport.js";
-export interface MiniMaxMediaConfig {
-    /** Base URL, e.g. "https://api.minimaxi.com" */
-    baseUrl: string;
-    timeoutMs?: number;
-}
-export declare class MiniMaxMediaTransport implements AsyncMediaTransport {
-    readonly supportedTypes: readonly MediaType[];
-    private baseUrl;
-    private timeoutMs;
-    constructor(config: MiniMaxMediaConfig);
-    generate(request: MediaRequest, apiKey: string, signal?: AbortSignal): Promise<MediaResult>;
-    private generateTTS;
-    private generateMusic;
-    private pollTask;
-    /**
-     * Generate lyrics from a text prompt via MiniMax Lyrics Generation API.
-     * POST /v1/lyrics_generation 鈥?returns structured lyrics with tags.
-     */
-    generateLyrics(prompt: string, apiKey: string, signal?: AbortSignal): Promise<string>;
-    private generateVideo;
-    private pollVideoTask;
-    private getFileDownloadUrl;
-    /**
-     * Query a single video task by ID.
-     * GET /v1/query/video_generation?task_id=XXX
-     */
-    getTaskStatus(taskId: string, apiKey: string, signal?: AbortSignal): Promise<{
-        status: string;
-        task: Record<string, unknown>;
-    }>;
-    /**
-     * List tasks 鈥?MiniMax does not have a bulk list endpoint.
-     * Each task must be queried individually with getTaskStatus().
-     */
-    listVideoTasks(_apiKey: string, _options?: {
-        after?: string;
-        limit?: number;
-        status?: string;
-    }, _signal?: AbortSignal): Promise<Record<string, unknown>>;
-    /**
-     * Cancel/delete is not natively supported by MiniMax video API.
-     */
-    deleteVideoTask(_taskId: string, _apiKey: string, _signal?: AbortSignal): Promise<void>;
-}

package/dist/types/provider-core/transports/openai-chat.d.ts

@@ -1,81 +0,0 @@
-/**
- * OpenAI Chat Completions TransportSSE streaming implementation.
- *
- * Covers all OpenAI-compatible providers:
- *   DeepSeek, Qwen, Minimax, Moonshot, OpenRouter, etc.
- *
- * POST {baseUrl}/v1/chat/completions with stream: true
- * Auth: Authorization: Bearer {apiKey}
- *
- * SSE format: lines prefixed with "data: ", JSON parsing per event.
- *
- * Adapted from admin-infer-proxy-client.ts SSE logic + Hermes openai_chat.py transport.
- */
-import type { LLMChunk, LLMRequest, LLMTransport, FIMRequest, FIMChunk } from "../transport.js";
-import type { ProviderQuirks } from "../provider-def.js";
-import type { FileUploadAdapter } from "../file-upload-service.js";
-export interface OpenAIChatTransportConfig {
-    baseUrl: string;
-    /** Additional headers (e.g. for specific providers) */
-    extraHeaders?: Record<string, string>;
-    /** Timeout in ms (default 180_000) */
-    timeoutMs?: number;
-    /** Whether to include stream_options (default true). Set false for providers that reject it. */
-    supportsStreamOptions?: boolean;
-    /** Whether to omit temperature when it equals 0 (e.g. Moonshot rejects 0) */
-    omitZeroTemperature?: boolean;
-    /** Provider-specific quirks (CC/altcode parity) */
-    quirks?: ProviderQuirks;
-    /** File upload adapter for resolving local media URLs via upload instead of base64. */
-    fileUploadAdapter?: FileUploadAdapter;
-}
-export declare class OpenAIChatTransport implements LLMTransport {
-    private baseUrl;
-    private extraHeaders;
-    private timeoutMs;
-    private supportsStreamOptions;
-    private omitZeroTemperature;
-    private quirks;
-    private fileUploadAdapter?;
-    private cumulativeReasoningLen;
-    private cumulativeContentLen;
-    constructor(config: OpenAIChatTransportConfig);
-    stream(request: LLMRequest, apiKey: string, signal?: AbortSignal): AsyncGenerator<LLMChunk>;
-    private fetchAndStream;
-    /**
-     * Handle non-streaming JSON response from providers that ignore stream:true.
-     * Synthesize the same LLMChunk events a streaming response would produce.
-     */
-    private handleNonStreamingResponse;
-    /**
-     * Parse SSE stream with 90s idle watchdog (CC parity).
-     * If no data arrives within STREAM_IDLE_TIMEOUT_MS, throw to trigger retry.
-     */
-    private parseSSEStreamWithWatchdog;
-    private processChunk;
-    /**
-     * FIM completion via /beta/v1/completions.
-     * Only works with DeepSeek (requires supportsPrefixCompletion quirk).
-     * Non-thinking mode only; max completion 4K tokens.
-     */
-    complete(request: FIMRequest, apiKey: string, signal?: AbortSignal): AsyncGenerator<FIMChunk>;
-    /**
-     * Upload a file for use in conversations (Kimi File API).
-     * Returns a file_id that can be referenced in user messages.
-     * POST /v1/files with multipart/form-data.
-     */
-    uploadFile(fileBlob: Blob, filename: string, purpose: string, apiKey: string, signal?: AbortSignal): Promise<{
-        fileId: string;
-        filename: string;
-        bytes: number;
-    }>;
-    /**
-     * Get file content/statusGET /v1/files/{file_id}
-     */
-    getFileInfo(fileId: string, apiKey: string, signal?: AbortSignal): Promise<{
-        id: string;
-        filename: string;
-        bytes: number;
-        status: string;
-    }>;
-}