qlogicagent 1.1.0 → 1.2.0

package/dist/types/llm/provider-def.d.ts

@@ -9,12 +9,12 @@
  *   Layer 2: model-catalog.ts remote (models.dev)
  *   Layer 3: user config (from agent.turn.config)
  */
-export type TransportType = "openai-chat" | "anthropic-messages" | "volcengine-responses";
+export type TransportType = "openai-chat" | "openai-responses" | "anthropic-messages" | "volcengine-responses" | "gemini-generatecontent";
 export type AuthType = "bearer" | "x-api-key" | "none";
-export type MediaCapability = "image" | "video" | "music" | "tts" | "3d" | "stt" | "embedding" | "video_understanding" | "image_understanding" | "voice_clone" | "rerank" | "document_parsing";
+export type MediaCapability = "image" | "video" | "music" | "music_realtime" | "tts" | "3d" | "stt" | "embedding" | "video_understanding" | "image_understanding" | "voice_clone" | "rerank" | "document_parsing" | "realtime_audio";
 export type VideoOperation = "text2video" | "img2video" | "video2video" | "edit" | "merge" | "upscale";
 export type ImageOperation = "text2image" | "img2img" | "inpainting" | "outpainting";
-export type MusicOperation = "text2music" | "cover";
+export type MusicOperation = "text2music" | "cover" | "realtime";
 export type TtsOperation = "text2speech" | "voice_clone";
 export type ThreeDOperation = "text2_3d" | "img2_3d";
 export interface VideoCapabilities {
@@ -87,7 +87,14 @@ export interface DocumentParsingCapabilities {
     maxPageCount?: number;
     maxFileSizeMB?: number;
 }
-export type MediaCapabilities = VideoCapabilities | ImageCapabilities | MusicCapabilities | TtsCapabilities | ThreeDCapabilities | SttCapabilities | EmbeddingCapabilities | VideoUnderstandingCapabilities | ImageUnderstandingCapabilities | VoiceCloneCapabilities | RerankCapabilities | DocumentParsingCapabilities;
+export interface RealtimeAudioCapabilities {
+    type: "realtime_audio";
+    voices?: string[];
+    modalities?: Array<"text" | "audio">;
+    vad?: boolean;
+    toolCalling?: boolean;
+}
+export type MediaCapabilities = VideoCapabilities | ImageCapabilities | MusicCapabilities | TtsCapabilities | ThreeDCapabilities | SttCapabilities | EmbeddingCapabilities | VideoUnderstandingCapabilities | ImageUnderstandingCapabilities | VoiceCloneCapabilities | RerankCapabilities | DocumentParsingCapabilities | RealtimeAudioCapabilities;
 /**
  * Provider-specific quirks — drives conditional logic in transports.
  * CC parity: provider detection via quirks flags instead of hardcoded if/else.
@@ -106,6 +113,12 @@ export interface ProviderQuirks {
     builtinWebSearch?: boolean;
     /** Provider has built-in code interpreter */
     builtinCodeInterpreter?: boolean;
+    /** Provider supports native URL context fetching (Gemini urlContext tool) */
+    builtinUrlContext?: boolean;
+    /** Provider supports Google Maps Grounding (Gemini googleMaps tool) */
+    builtinMapsGrounding?: boolean;
+    /** Provider supports native file search (Gemini fileSearch tool) */
+    builtinFileSearch?: boolean;
     /** Supports thinking.type="enabled"/"disabled" body param (Kimi K2, GLM).
      *  Disambiguation: GLM also sets supportsToolStream; Kimi does not. */
     supportsThinkingParam?: boolean;

package/dist/types/llm/transport.d.ts

@@ -57,7 +57,7 @@ export interface LLMRequest {
     topP?: number;
     maxTokens?: number;
     reasoning?: {
-        effort: "minimal" | "low" | "medium" | "high";
+        effort: "minimal" | "low" | "medium" | "high" | "xhigh";
         /** Request encrypted original reasoning content (Volcengine §17.7). */
         includeEncryptedReasoning?: boolean;
     };
@@ -123,6 +123,64 @@ export interface LLMRequest {
      * Server-side trimming of historical thinking chains and tool call traces.
      */
     contextManagement?: ContextManagementConfig;
+    /**
+     * Gemini explicit cache reference (gemini-ProviderMax §8).
+     * Passes a pre-created cache name (e.g. "cachedContents/abc123") to
+     * generateContent so the server uses cached tokens instead of re-processing.
+     * Create caches via GeminiCacheAPI.createCache() first.
+     */
+    cachedContent?: string;
+    /**
+     * Predicted output for speculative decoding (openai-ProviderMax §11).
+     * When editing code, pass the existing content so the model can diff efficiently.
+     * Reduces latency by 3-5x when prediction matches. Falls back when it doesn't.
+     * Works with OpenAI GPT-5.x models via Responses API and Chat Completions.
+     */
+    prediction?: {
+        type: "content";
+        content: string;
+    };
+    /**
+     * Prompt cache bucketing key (openai-ProviderMax §11).
+     * Replaces the deprecated `user` field. Helps OpenAI group similar requests
+     * for higher cache hit rates.
+     */
+    promptCacheKey?: string;
+    /**
+     * Prompt cache retention policy (openai-ProviderMax §11).
+     * "in_memory" = default 5-10 min, "24h" = extended up to 24 hours.
+     */
+    promptCacheRetention?: "in_memory" | "24h";
+    /**
+     * Service tier for request scheduling (openai-ProviderMax §14).
+     * "auto" = project default, "flex" = 50% cheaper / higher latency,
+     * "priority" = guaranteed low latency.
+     */
+    serviceTier?: "auto" | "default" | "flex" | "priority";
+    /**
+     * OpenAI Responses API built-in tools (openai-ProviderMax §7).
+     * Platform-executed tools like web_search, file_search, code_interpreter, etc.
+     */
+    openaiBuiltinTools?: Array<{
+        type: "web_search_preview" | "file_search" | "code_interpreter" | "computer_use_preview";
+        [key: string]: unknown;
+    }>;
+    /**
+     * OpenAI Responses API conversation ID (openai-ProviderMax §2.1).
+     * Alternative to previous_response_id — persistent server-side conversation.
+     * Cannot be used together with previousResponseId.
+     */
+    conversationId?: string;
+    /**
+     * Disable parallel tool calling for this request.
+     * When false, the model must call tools sequentially.
+     */
+    parallelToolCalls?: boolean;
+    /**
+     * Text output verbosity hint (openai-ProviderMax §5).
+     * Controls how detailed the model's textual output should be.
+     */
+    textVerbosity?: "low" | "medium" | "high";
 }
 /**
  * FIM completion request — DeepSeek Beta Completions API.
@@ -182,7 +240,7 @@ export type LLMChunk = {
     event: string;
     data?: Record<string, unknown>;
 } | {
-    /** Web search citation annotations from Volcengine web_search results. */
+    /** Web search citation annotations from provider builtin tools (Volcengine web_search, Gemini grounding). */
     type: "annotations";
     annotations: Array<{
         type: string;

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

@@ -0,0 +1,86 @@
+/**
+ * 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/llm/transports/gemini-file-api.d.ts

@@ -0,0 +1,90 @@
+/**
+ * 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/llm/transports/gemini-generatecontent.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Gemini generateContent Transport — Native 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 (thinkingLevel — G3 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";
+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;
+}
+export declare class GeminiGenerateContentTransport implements LLMTransport {
+    private baseUrl;
+    private timeoutMs;
+    private quirks;
+    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/llm/transports/gemini-lyria-realtime.d.ts

@@ -0,0 +1,117 @@
+/**
+ * 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/llm/transports/gemini-media.d.ts

@@ -1,21 +1,53 @@
 /**
- * Gemini Media Transport — Image generation via Gemini generateContent.
+ * Gemini Media Transport — unified media generation for all Gemini media APIs.
  *
- * Uses responseModalities: ["TEXT", "IMAGE"] with the Gemini REST API.
- * POST /v1beta/models/{model}:generateContent
- * Auth: key= query param or x-goog-api-key header
- * Docs: https://ai.google.dev/gemini-api/docs/image-generation
+ * 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 { MediaTransport, MediaRequest, MediaResult, MediaType } from "../media-transport.js";
+import type { AsyncMediaTransport, MediaRequest, MediaResult, MediaType } from "../media-transport.js";
 export interface GeminiMediaConfig {
-    /** Base URL, e.g. "https://generativelanguage.googleapis.com/v1beta/openai" */
+    /** Base URL, e.g. "https://generativelanguage.googleapis.com/v1beta" */
     baseUrl: string;
     timeoutMs?: number;
 }
-export declare class GeminiMediaTransport implements MediaTransport {
+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/llm/transports/minimax-media.d.ts

@@ -1,26 +1,55 @@
 /**
- * MiniMax Media Transport — Music Generation API (music-2.6, music-cover).
+ * MiniMax Media Transport — Music + Video 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)
  *
- * POST /v1/music_generation (async job: submit → poll → result)
  * Auth: Authorization: Bearer $MINIMAX_API_KEY
- * Docs: https://platform.minimaxi.com/document/Music
+ * Docs: minimax-ProviderMax.md §13-18 (video), §21 (music), §24-28 (files)
  */
-import type { MediaTransport, MediaRequest, MediaResult, MediaType } from "../media-transport.js";
+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 MediaTransport {
+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 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/llm/transports/openai-responses.d.ts

@@ -0,0 +1,60 @@
+/**
+ * OpenAI Responses API Transport — SSE streaming implementation.
+ *
+ * Implements the OpenAI Responses API (`POST /v1/responses`),
+ * the officially recommended path for GPT-5.x text generation.
+ *
+ * Key differences from OpenAI Chat Completions:
+ *   - Endpoint: POST {baseUrl}/v1/responses
+ *   - Request body uses `input` (not `messages`), `instructions`, `reasoning`
+ *   - SSE events: response.output_text.delta, response.function_call_arguments.delta,
+ *     response.completed, etc.
+ *   - Tool defs: { type: "function", name, parameters } (not nested under `function:`)
+ *   - Tool results: { type: "function_call_output", call_id, output }
+ *   - Context persistence: previous_response_id for server-side session continuation
+ *   - Structured output: `text: { format: { type: "json_schema", ... } }`
+ *   - Reasoning: `reasoning: { effort, summary }` for GPT-5.x models
+ *
+ * Wire format reference:
+ *   https://developers.openai.com/api/docs/api-reference/responses/create
+ *   https://developers.openai.com/api/docs/api-reference/responses/streaming-events
+ *
+ * Design: Closely mirrors volcengine-responses.ts patterns while adapting to
+ * OpenAI-specific wire format. Shared LLMChunk output makes upper layers
+ * transport-agnostic.
+ */
+import type { LLMChunk, LLMRequest, LLMTransport } from "../transport.js";
+import type { ProviderQuirks } from "../provider-def.js";
+export interface OpenAIResponsesTransportConfig {
+    baseUrl: string;
+    extraHeaders?: Record<string, string>;
+    timeoutMs?: number;
+    quirks?: ProviderQuirks;
+}
+export declare class OpenAIResponsesTransport implements LLMTransport {
+    private baseUrl;
+    private extraHeaders;
+    private timeoutMs;
+    private quirks;
+    constructor(config: OpenAIResponsesTransportConfig);
+    stream(request: LLMRequest, apiKey: string, signal?: AbortSignal): AsyncGenerator<LLMChunk>;
+    private buildRequestBody;
+    private fetchAndStream;
+    private handleNonStreamingResponse;
+    /**
+     * Parse OpenAI Responses API SSE stream.
+     *
+     * Event format: "event: <type>\ndata: <json>\n\n"
+     * Key events:
+     *   - response.output_text.delta           → text content delta
+     *   - response.reasoning_summary_text.delta → reasoning summary text
+     *   - response.function_call_arguments.delta → tool call arguments streaming
+     *   - response.output_item.added           → new output item started
+     *   - response.output_item.done            → output item completed
+     *   - response.content_part.done           → content part completed (annotations)
+     *   - response.completed                   → full response complete with usage
+     *   - response.failed                      → error
+     */
+    private parseSSEStream;
+    private processEvent;
+}