qlogicagent 0.5.3 → 1.0.0

package/dist/types/cli/stdio-server.d.ts

@@ -1,21 +1,25 @@
 /**
- * StdioServer — JSON-RPC 2.0 over stdio protocol handler.
+ * StdioServer — JSON-RPC 2.0 protocol handler.
  *
- * Reads line-delimited JSON from stdin, dispatches to handlers,
- * writes JSON-RPC responses/notifications to stdout.
+ * Receives JSON-RPC messages from a Transport, dispatches to handlers,
+ * writes JSON-RPC responses/notifications back through the Transport.
  * All log output goes to stderr.
  *
- * Protocol: each line on stdin/stdout is a single JSON-RPC 2.0 message.
+ * Protocol: each message is a single JSON-RPC 2.0 object.
+ * The physical I/O layer is abstracted via the Transport interface.
  */
+import type { Transport } from "./transport.js";
 export interface StdioServerConfig {
     verbose: boolean;
+    transport?: Transport;
 }
 export declare class StdioServer {
     private running;
     private activeTurn;
     private verbose;
+    private transport;
     private registry;
-    private toolRegistry;
+    private mediaClient;
     private agent;
     private lastLlmConfigKey;
     private currentSessionId;
@@ -40,15 +44,93 @@ export declare class StdioServer {
     start(): void;
     stop(): void;
     private handleMessage;
-    private handleHello;
+    /**
+     * `initialize` — the sole handshake handler.
+     * Accepts both legacy flat params (`hostName`, `hostVersion`) and
+     * Codex-style nested params (`host.name`, `host.version`).
+     * Always returns the InitializeResult shape.
+     */
+    private handleInitialize;
+    /**
+     * `thread.create` — create a new thread (session container).
+     * Maps threadId → sessionId for the underlying session system.
+     */
+    private handleThreadCreate;
+    /**
+     * `thread.list` — list available threads. Delegates to session listing.
+     */
+    private handleThreadList;
     private handlePing;
     private handleAbort;
     private handleApprovalResponse;
-    private handleSessionList;
     private handleSessionResume;
     private handleTurn;
+    private static readonly SUGGESTION_PROMPT;
+    /**
+     * Generate follow-up suggestions after a turn completes.
+     * Fire-and-forget — failures are silently logged. Non-blocking.
+     */
+    private generateSuggestions;
     private handleDream;
     private resolveAgent;
+    /**
+     * Load LLM settings from ~/.qlogicagent/settings.json (sync).
+     * Returns provider/model/apiKey if found, undefined otherwise.
+     */
+    private loadSettingsSync;
+    /**
+     * `session.getInfo` — Return session metadata, filesystem paths, and usage summary.
+     * Aligns with Codex/Copilot session introspection capability.
+     */
+    private handleSessionGetInfo;
+    /**
+     * `memory.list` — Enumerate available memory sources (local store + qmemory).
+     */
+    private handleMemoryList;
+    /**
+     * `memory.read` — Read memory content from local store or QMemory.
+     */
+    private handleMemoryRead;
+    /**
+     * `memory.write` — Write memory content to local store (agent notes / user profile).
+     */
+    private handleMemoryWrite;
+    /**
+     * `tools.list` — Return available tool definitions (local + MCP + plugin).
+     * Supports optional category filter.
+     */
+    private handleToolsList;
+    /**
+     * `config.get` — Read current agent runtime configuration.
+     * Returns merged user-level + project-level settings.
+     */
+    private handleConfigGet;
+    /**
+     * `config.update` — Update agent runtime configuration (merges into settings.json).
+     */
+    private handleConfigUpdate;
+    /**
+     * `todos.list` — Query current todo items and summary.
+     * Invokes the registered todo tool's list action.
+     */
+    private handleTodosList;
+    /**
+     * `memory.search` — Vector search via QMemory adapter.
+     * Powers the memory page's search feature.
+     */
+    private handleMemorySearch;
+    /**
+     * `memory.delete` — Remove a memory entry by substring match (local) or ID (qmemory).
+     */
+    private handleMemoryDelete;
+    /**
+     * `tasks.list` — Query running/completed infrastructure tasks.
+     */
+    private handleTasksList;
+    /**
+     * `tasks.cancel` — Cancel a running task by ID.
+     */
+    private handleTasksCancel;
     private sendResponse;
     private sendNotification;
     private writeStdout;

package/dist/types/cli/tool-bootstrap.d.ts

@@ -1,6 +1,13 @@
-import { ToolRegistry } from "../skills/tool-registry.js";
+import type { PortableTool } from "../skills/portable-tool.js";
 import { type ExecProgress } from "../skills/tools/exec-tool.js";
 import type { AgentLogger } from "../agent/types.js";
+import type { MediaClient } from "../llm/media-client.js";
+/**
+ * Set the media client + API keys for generation tools.
+ * Tools will call vendor APIs directly through MediaTransport.
+ * Keys map: { providerId: apiKey, ... }
+ */
+export declare function setMediaClientConfig(client: MediaClient | undefined, apiKeys?: Record<string, string>, onMediaUsage?: (model: string, billingUnit: string, quantity: number) => void): void;
 export interface BootstrapConfig {
     workdir?: string;
     log?: AgentLogger;
@@ -8,12 +15,16 @@ export interface BootstrapConfig {
     onExecProgress?(progress: ExecProgress): void;
 }
 /**
- * Create and populate a ToolRegistry with all locally-executable tools.
+ * Create all locally-executable tools and install into centralized tool pool.
+ *
+ * CC parity: getAllBaseTools() returns flat array, installed via setToolPool().
+ * Tools execute IN-PROCESS (zero IPC).
  *
- * Tools registered here execute IN-PROCESS (zero IPC).
- * All tools are agent-local — no Gateway relay.
+ * @alias initToolDeps — kept for backward compat with existing call sites.
  */
-export declare function bootstrapToolRegistry(config?: BootstrapConfig): ToolRegistry;
+export declare function getAllBaseTools(config?: BootstrapConfig): PortableTool[];
+/** @deprecated Use getAllBaseTools() instead. */
+export declare const initToolDeps: typeof getAllBaseTools;
 /**
  * Update the working directory for all local tool deps.
  * Called when Gateway sends a new workdir via config.

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

@@ -0,0 +1,40 @@
+/**
+ * Transport — abstract I/O layer for JSON-RPC message exchange.
+ *
+ * Decouples the agent protocol handler from the physical transport
+ * (stdin/stdout, WebSocket, Unix Domain Socket, etc.).
+ *
+ * Each transport reads incoming JSON-RPC messages and emits them
+ * to a registered handler; outgoing messages are sent via send().
+ */
+export interface Transport {
+    /** Register the message handler (called for each valid parsed message). */
+    onMessage(handler: (msg: unknown) => void): void;
+    /** Register the close handler (called when the transport closes). */
+    onClose(handler: () => void): void;
+    /** Send a JSON-RPC message (object will be serialized to JSON). */
+    send(msg: unknown): void;
+    /** Start listening for incoming messages. */
+    start(): void;
+    /** Close the transport gracefully. */
+    close(): void;
+}
+/**
+ * Line-delimited JSON over stdin/stdout.
+ * Each line on stdin is a JSON message; each send() writes one JSON line to stdout.
+ * All diagnostic logging goes to stderr.
+ */
+export declare class StdioTransport implements Transport {
+    private messageHandler;
+    private closeHandler;
+    private verbose;
+    constructor(opts?: {
+        verbose?: boolean;
+    });
+    onMessage(handler: (msg: unknown) => void): void;
+    onClose(handler: () => void): void;
+    send(msg: unknown): void;
+    start(): void;
+    close(): void;
+    private log;
+}

package/dist/types/contracts/index.d.ts

@@ -7,4 +7,3 @@
 export * from "./planner.js";
 export * from "./todo.js";
 export * from "./hooks.js";
-export * from "./skill-candidate.js";

package/dist/types/contracts/todo.d.ts

@@ -4,11 +4,20 @@ export interface TodoItem {
     id: number;
     title: string;
     status: TodoItemStatus;
+    /** Detailed task description (V2). */
+    description?: string;
+    /** Owner agent/subagent identifier for per-agent isolation (V2). */
+    owner?: string;
+    /** IDs of tasks that must complete before this one can start (V2). */
+    blockedBy?: number[];
+    /** IDs of tasks this one blocks from starting (V2). */
+    blocks?: number[];
 }
 export interface TodoListSummary {
     total: number;
     completed: number;
     inProgress: number;
     notStarted: number;
+    blocked: number;
 }
 export declare function summarizeTodoList(items: readonly TodoItem[]): TodoListSummary;

package/dist/types/index.d.ts

@@ -7,6 +7,9 @@ export { Agent } from "./agent/agent.js";
 export type { AgentLogger, ChatMessage, ToolDefinition, ToolInvoker, TurnConfig, TurnEvent, TurnRequest, HookRegistry, } from "./agent/types.js";
 export { parseCliArgs } from "./config/config.js";
 export type { AgentConfig } from "./config/config.js";
+export type { Transport } from "./cli/transport.js";
+export { StdioTransport } from "./cli/transport.js";
+export { StdioServer, type StdioServerConfig } from "./cli/stdio-server.js";
 export { ProviderRegistry, createLLMClient, autoDetectProvider, } from "./llm/index.js";
 export type { LLMTransport, LLMRequest, LLMChunk } from "./llm/index.js";
 export { createHookRegistry } from "./runtime/hooks/hook-registry.js";

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

@@ -3,9 +3,11 @@
  *
  * Provides: ProviderDef + LLMTransport + ProviderRegistry + LLMClient factory
  */
-export type { ProviderDef, ModelInfo, TransportType, AuthType } from "./provider-def.js";
+export type { ProviderDef, ModelInfo, TransportType, AuthType, MediaCapability } from "./provider-def.js";
 export type { LLMTransport, LLMRequest, LLMChunk, AccumulatedToolCall, } from "./transport.js";
 export { accumulateToolCalls } from "./transport.js";
+export type { MediaTransport, MediaRequest, MediaResult, MediaType } from "./media-transport.js";
+export { MediaClient, type MediaClientConfig, type ResolvedMediaModel } from "./media-client.js";
 export { ProviderRegistry } from "./provider-registry.js";
 export { BUILTIN_PROVIDERS } from "./builtin-providers.js";
 export { ModelCatalog } from "./model-catalog.js";
@@ -13,4 +15,8 @@ export type { LLMClientConfig, LLMClient } from "./llm-client.js";
 export { createLLMClient, autoDetectProvider } from "./llm-client.js";
 export { OpenAIChatTransport } from "./transports/openai-chat.js";
 export { AnthropicMessagesTransport } from "./transports/anthropic-messages.js";
+export { VolcengineMediaTransport } from "./transports/volcengine-media.js";
+export { OpenAIMediaTransport } from "./transports/openai-media.js";
+export { MiniMaxMediaTransport } from "./transports/minimax-media.js";
+export { GeminiMediaTransport } from "./transports/gemini-media.js";
 export { isDebugTransportEnabled, createDebugTransport } from "./debug-transport.js";

package/dist/types/llm/media-client.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Media Client factory — resolves ProviderDef → creates MediaTransport instances.
+ *
+ * Parallel to createLLMClient() but for generation models (image/video/music/3D).
+ * Uses the same ProviderRegistry to look up provider config, then instantiates
+ * the correct media transport adapter.
+ *
+ * The MediaClient holds a provider-keyed transport cache so that repeated
+ * generation calls reuse the same adapter instance.
+ */
+import type { MediaTransport } from "./media-transport.js";
+import type { ProviderDef, MediaCapability, ModelInfo } from "./provider-def.js";
+import type { ProviderRegistry } from "./provider-registry.js";
+export interface MediaClientConfig {
+    registry: ProviderRegistry;
+}
+export interface ResolvedMediaModel {
+    providerId: string;
+    providerDef: ProviderDef;
+    modelInfo: ModelInfo;
+    mediaType: MediaCapability;
+}
+export declare class MediaClient {
+    private registry;
+    private transports;
+    constructor(config: MediaClientConfig);
+    /**
+     * Find the best available model for a given media type.
+     * Scans all providers for models with matching mediaType.
+     * If preferredProvider is set, search that first.
+     */
+    resolveModel(mediaType: MediaCapability, preferredProvider?: string): ResolvedMediaModel | undefined;
+    /**
+     * Get a MediaTransport for a specific provider.
+     * Creates and caches the adapter on first access.
+     */
+    getTransport(providerId: string): MediaTransport | undefined;
+    /**
+     * List all available generation models across all providers.
+     */
+    listMediaModels(mediaType?: MediaCapability): ResolvedMediaModel[];
+    private findModelInProvider;
+}

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

@@ -0,0 +1,80 @@
+/**
+ * MediaTransport — transport interface for generation APIs (image, video, music, 3D).
+ *
+ * Parallel to LLMTransport (chat/reasoning), MediaTransport handles
+ * non-chat generation endpoints that each vendor exposes differently:
+ *   - Sync (OpenAI images, Volcengine Seedream, Gemini generateContent)
+ *   - Async job (Volcengine Seedance/3D, MiniMax music) — submit → poll → result
+ *
+ * Each provider adapter implements this interface and hides vendor-specific
+ * auth, endpoint paths, request shapes, and polling logic.
+ */
+export type MediaType = "image" | "video" | "music" | "tts" | "3d";
+export interface MediaRequest {
+    /** Generation model id, e.g. "doubao-seedream-5-0-260128", "gpt-image-2" */
+    model: string;
+    /** What kind of media to generate */
+    mediaType: MediaType;
+    /** Text prompt for generation */
+    prompt: string;
+    /** Optional reference image URL (img2img, i2v, img-to-3d) */
+    imageUrl?: string;
+    /** Desired dimensions, e.g. "1024x1024" */
+    size?: string;
+    /** Aspect ratio for video, e.g. "16:9" */
+    aspectRatio?: string;
+    /** Duration in seconds (video, music) */
+    duration?: number;
+    /** Number of outputs (image) */
+    n?: number;
+    /** Visual/musical style */
+    style?: string;
+    /** Intended use / purpose */
+    purpose?: string;
+    /** Lyrics for music generation */
+    lyrics?: string;
+    /** Text for TTS */
+    text?: string;
+    /** TTS channel hint */
+    channel?: string;
+    /** Source video URLs for edit/merge operations */
+    sourceVideos?: string[];
+    /** Reference images for edit operations */
+    referenceImages?: string[];
+    /** Output resolution for upscale, e.g. "1080p" */
+    resolution?: string;
+    /** Operation variant: generate (default), edit, merge, upscale */
+    operation?: "generate" | "edit" | "merge" | "upscale";
+}
+export interface MediaResult {
+    /** URLs of generated media files */
+    mediaUrls: string[];
+    /** Model actually used */
+    model?: string;
+    /** Output dimensions / format info */
+    size?: string;
+    /** Total generation time in ms */
+    durationMs?: number;
+    /** Billing unit type for non-token models */
+    billingUnit?: "per_call" | "per_second" | "per_character" | "per_pixel" | "per_token";
+    /** Quantity consumed (seconds, characters, pixels, etc.) */
+    billingQuantity?: number;
+    /** Provider-specific metadata */
+    metadata?: Record<string, unknown>;
+}
+export interface MediaTransport {
+    /**
+     * Generate media content.
+     * Handles sync APIs directly and async job APIs (submit + poll) internally.
+     *
+     * @param request - Generation parameters
+     * @param apiKey  - User API key (passed explicitly, not from env)
+     * @param signal  - Optional abort signal
+     */
+    generate(request: MediaRequest, apiKey: string, signal?: AbortSignal): Promise<MediaResult>;
+    /**
+     * Which media types this transport supports.
+     * Used by the media client factory to route requests.
+     */
+    readonly supportedTypes: readonly MediaType[];
+}

package/dist/types/llm/model-catalog.d.ts

@@ -1,13 +1,13 @@
 /**
  * ModelCatalog — remote model directory with disk cache + fallback.
  *
- * Fetches model metadata from models.dev (open community catalog, 4000+ models).
- * Aligned with Hermes agent/models_dev.py caching strategy.
+ * Fetches model metadata from models.dev/api.json (community-maintained,
+ * comprehensive single-source catalog with 100+ providers).
  *
- * Three-layer fallback:
+ * Two-layer fallback:
  *   1. In-memory cache (process-level, TTL check against disk mtime)
- *   2. Disk cache (~/.openclaw/cache/model_catalog.json)
- *   3. Remote fetch (https://models.dev/api.json)
+ *   2. Disk cache (~/.qlogicagent/cache/model_catalog.json)
+ *   3. Remote fetch (models.dev single endpoint)
  *   4. Stale disk cache (if remote fails)
  *   5. Empty (caller falls back to builtin-providers.ts hardcoded)
  *

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

@@ -11,6 +11,7 @@
  */
 export type TransportType = "openai-chat" | "anthropic-messages";
 export type AuthType = "bearer" | "x-api-key" | "none";
+export type MediaCapability = "image" | "video" | "music" | "tts" | "3d";
 export interface ProviderDef {
     /** Unique provider id, e.g. "deepseek", "openai", "anthropic" */
     id: string;
@@ -56,4 +57,10 @@ export interface ModelInfo {
     costInput?: number;
     /** Cost per 1M output tokens (USD) */
     costOutput?: number;
+    /** Cost per 1M cache read tokens (USD) */
+    costCacheRead?: number;
+    /** Cost per 1M cache write tokens (USD) */
+    costCacheWrite?: number;
+    /** Media generation capability — undefined means chat/reasoning model */
+    mediaType?: MediaCapability;
 }

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

@@ -1,5 +1,5 @@
 /**
- * ProviderRegistry — three-layer merge registry for LLM providers.
+ * ProviderRegistry — two-layer merge registry for LLM providers.
  *
  * Layer 1: builtin-providers.ts hardcoded (lowest priority, ~20 providers)
  * Layer 2: model-catalog.ts remote (models.dev — enriches model metadata)

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

@@ -37,6 +37,8 @@ export type LLMChunk = {
     promptTokens: number;
     completionTokens: number;
     reasoningTokens?: number;
+    cacheReadTokens?: number;
+    cacheCreationTokens?: number;
 } | {
     type: "done";
     finishReason: string;

package/dist/types/llm/transports/anthropic-messages.d.ts

@@ -1,31 +1,54 @@
 /**
  * Anthropic Messages Transport — SSE streaming for Claude API.
  *
- * POST {baseUrl}/v1/messages with stream: true
- * Auth: x-api-key: {apiKey} + anthropic-version header
- *
- * SSE event types:
- *   message_start, content_block_start, content_block_delta,
- *   content_block_stop, message_delta, message_stop
- *
- * Tool use is via content blocks with type "tool_use" + "input_json_delta".
- *
- * Aligned with Hermes anthropic_messages.py transport.
+ * 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";
 export interface AnthropicTransportConfig {
     baseUrl: string;
     /** anthropic-version header (default "2023-06-01") */
     apiVersion?: string;
-    /** Timeout in ms (default 180_000) */
+    /** 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;
 }
 export declare class AnthropicMessagesTransport implements LLMTransport {
     private baseUrl;
     private apiVersion;
     private timeoutMs;
+    private streamIdleTimeoutMs;
+    private enablePromptCaching;
+    private maxRetries;
     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/llm/transports/gemini-media.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Gemini Media Transport — Image generation via Gemini generateContent.
+ *
+ * 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
+ */
+import type { MediaTransport, MediaRequest, MediaResult, MediaType } from "../media-transport.js";
+export interface GeminiMediaConfig {
+    /** Base URL, e.g. "https://generativelanguage.googleapis.com/v1beta/openai" */
+    baseUrl: string;
+    timeoutMs?: number;
+}
+export declare class GeminiMediaTransport implements MediaTransport {
+    readonly supportedTypes: readonly MediaType[];
+    private apiBase;
+    private timeoutMs;
+    constructor(config: GeminiMediaConfig);
+    generate(request: MediaRequest, apiKey: string, signal?: AbortSignal): Promise<MediaResult>;
+}

package/dist/types/llm/transports/minimax-media.d.ts

@@ -0,0 +1,21 @@
+/**
+ * MiniMax Media Transport — Music Generation API (music-2.6, music-cover).
+ *
+ * POST /v1/music_generation (async job: submit → poll → result)
+ * Auth: Authorization: Bearer $MINIMAX_API_KEY
+ * Docs: https://platform.minimaxi.com/document/Music
+ */
+import type { MediaTransport, 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 {
+    readonly supportedTypes: readonly MediaType[];
+    private baseUrl;
+    private timeoutMs;
+    constructor(config: MiniMaxMediaConfig);
+    generate(request: MediaRequest, apiKey: string, signal?: AbortSignal): Promise<MediaResult>;
+    private pollTask;
+}

package/dist/types/llm/transports/openai-chat.d.ts

@@ -2,7 +2,7 @@
  * OpenAI Chat Completions Transport — SSE streaming implementation.
  *
  * Covers all OpenAI-compatible providers:
- *   DeepSeek, Qwen, 硅基, Minimax, Moonshot, Groq, Together, OpenRouter, etc.
+ *   DeepSeek, Qwen, Minimax, Moonshot, OpenRouter, etc.
  *
  * POST {baseUrl}/v1/chat/completions with stream: true
  * Auth: Authorization: Bearer {apiKey}

package/dist/types/llm/transports/openai-media.d.ts

@@ -0,0 +1,24 @@
+/**
+ * OpenAI Media Transport — Images API (gpt-image-2) + Audio Speech API (tts-1).
+ *
+ * Image:  POST /v1/images/generations (sync response, returns URLs)
+ * TTS:    POST /v1/audio/speech      (sync response, returns raw audio bytes)
+ * Auth: Authorization: Bearer $OPENAI_API_KEY
+ * Docs: https://platform.openai.com/docs/api-reference/images/create
+ *       https://platform.openai.com/docs/api-reference/audio/createSpeech
+ */
+import type { MediaTransport, MediaRequest, MediaResult, MediaType } from "../media-transport.js";
+export interface OpenAIMediaConfig {
+    /** Base URL, e.g. "https://api.openai.com" */
+    baseUrl: string;
+    timeoutMs?: number;
+}
+export declare class OpenAIMediaTransport implements MediaTransport {
+    readonly supportedTypes: readonly MediaType[];
+    private baseUrl;
+    private timeoutMs;
+    constructor(config: OpenAIMediaConfig);
+    generate(request: MediaRequest, apiKey: string, signal?: AbortSignal): Promise<MediaResult>;
+    private generateImage;
+    private generateTTS;
+}

package/dist/types/llm/transports/qwen-media.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Qwen (DashScope) Media Transport — TTS via CosyVoice.
+ *
+ * DashScope TTS uses the async task API:
+ *   Submit: POST /api/v1/services/aigc/text2audio/generation
+ *   Poll:   GET  /api/v1/tasks/{taskId}
+ *
+ * Auth: Authorization: Bearer $DASHSCOPE_API_KEY
+ * Docs: https://help.aliyun.com/zh/model-studio/developer-reference/cosyvoice-large-speech-synthesis
+ */
+import type { MediaTransport, MediaRequest, MediaResult, MediaType } from "../media-transport.js";
+export interface QwenMediaConfig {
+    /** Base URL, e.g. "https://dashscope.aliyuncs.com" */
+    baseUrl: string;
+    timeoutMs?: number;
+}
+export declare class QwenMediaTransport implements MediaTransport {
+    readonly supportedTypes: readonly MediaType[];
+    private baseUrl;
+    private timeoutMs;
+    constructor(config: QwenMediaConfig);
+    generate(request: MediaRequest, apiKey: string, signal?: AbortSignal): Promise<MediaResult>;
+    private pollTask;
+    private extractAudioUrl;
+}

package/dist/types/llm/transports/volcengine-media.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Volcengine Media Transport — Doubao Seedream (image), Seedance (video), 3D generation.
+ *
+ * API reference:
+ *   Image:  POST /v3/images/generations            (sync)
+ *   Video:  POST /v3/contents/generations/tasks     (async job)
+ *   3D:     POST /v3/3d-contents/generations/tasks  (async job)
+ *
+ * Auth: Authorization: Bearer $ARK_API_KEY
+ * Docs: https://www.volcengine.com/docs/82379/1330310
+ */
+import type { MediaTransport, MediaRequest, MediaResult, MediaType } from "../media-transport.js";
+export interface VolcengineMediaConfig {
+    /** Base URL, e.g. "https://ark.cn-beijing.volces.com/api" */
+    baseUrl: string;
+    timeoutMs?: number;
+}
+export declare class VolcengineMediaTransport implements MediaTransport {
+    readonly supportedTypes: readonly MediaType[];
+    private baseUrl;
+    private timeoutMs;
+    constructor(config: VolcengineMediaConfig);
+    generate(request: MediaRequest, apiKey: string, signal?: AbortSignal): Promise<MediaResult>;
+    /**
+     * Check if this transport can handle a given operation.
+     * Video edit/merge/upscale are routed through the same video endpoint.
+     */
+    canHandle(request: MediaRequest): boolean;
+    private generateImage;
+    private generateVideo;
+    private generate3D;
+    private submitTask;
+    private pollTask;
+}