qlogicagent 1.0.1 → 1.1.0

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

@@ -0,0 +1,60 @@
+/**
+ * Zhipu (GLM) Media Transport — CogView (image), CogVideoX (video), TTS, STT, Embedding.
+ *
+ * API reference (docs.bigmodel.cn):
+ *   Image sync:  POST /images/generations          (CogView-4, cogview-3-flash)
+ *   Image async: POST /async/images/generations     (glm-image)
+ *   Video async: POST /videos/generations           (CogVideoX)
+ *   TTS sync:    POST /audio/speech                 (glm-tts, returns audio bytes)
+ *   STT sync:    POST /audio/transcriptions         (glm-asr, multipart/form-data)
+ *   Embedding:   POST /embeddings                   (embedding-3/2)
+ *   Async poll:  GET  /async-result/{id}            (unified poll for all async tasks)
+ *
+ * Base URL: https://open.bigmodel.cn/api/paas/v4
+ * Auth: Authorization: Bearer $ZHIPU_API_KEY
+ */
+import type { MediaTransport, MediaRequest, MediaResult, MediaType } from "../media-transport.js";
+export interface ZhipuMediaConfig {
+    /** Base URL, e.g. "https://open.bigmodel.cn/api/paas/v4" */
+    baseUrl: string;
+    timeoutMs?: number;
+}
+export declare class ZhipuMediaTransport implements MediaTransport {
+    readonly supportedTypes: readonly MediaType[];
+    private baseUrl;
+    private timeoutMs;
+    constructor(config: ZhipuMediaConfig);
+    generate(request: MediaRequest, apiKey: string, signal?: AbortSignal): Promise<MediaResult>;
+    private generateImage;
+    /** CogView-4 / cogview-3-flash — sync, returns URL directly */
+    private generateImageSync;
+    /** glm-image — async submit + poll */
+    private generateImageAsync;
+    private generateVideo;
+    private generateTTS;
+    private generateSTT;
+    private generateEmbedding;
+    private generateVoiceClone;
+    private generateDocumentParsing;
+    private generateRerank;
+    private postJSON;
+    /**
+     * Unified async result polling — GET /async-result/{id}
+     * Returns the result object when task_status === "SUCCESS".
+     * Throws on "FAIL" or timeout.
+     */
+    private pollAsyncResult;
+    /**
+     * List cloned voices — GET /voice/
+     * Returns all voice clones for the current user.
+     */
+    listVoices(apiKey: string, signal?: AbortSignal): Promise<Array<{
+        voice_id: string;
+        voice_name: string;
+        status: string;
+    }>>;
+    /**
+     * Delete a cloned voice — DELETE /voice/{voice_id}
+     */
+    deleteVoice(voiceId: string, apiKey: string, signal?: AbortSignal): Promise<void>;
+}

package/dist/types/llm/transports/zhipu-tool-api.d.ts

@@ -0,0 +1,35 @@
+/**
+ * ZhipuToolAPI — Zhipu-specific utility endpoints.
+ *
+ * Implements ProviderToolAPI for Zhipu GLM platform independent APIs:
+ *   C1: Web Search  — POST /tools/web-search
+ *   C2: Reader      — POST /tools/reader (extract web page content)
+ *   C3: Tokenizer   — POST /tokenizer
+ *   C4: Moderations — POST /moderations
+ *
+ * Base URL: https://open.bigmodel.cn/api/paas/v4
+ * Auth: Authorization: Bearer $ZHIPU_API_KEY
+ *
+ * C5 (File Parser) is handled by document_parsing media handler.
+ * C6 (Realtime API) requires WebSocket — out of scope for this interface.
+ */
+import type { ProviderToolAPI, ProviderToolCapability, WebSearchResult, ReaderResult, TokenizerResult, ModerationResult } from "../provider-tool-api.js";
+export interface ZhipuToolAPIConfig {
+    baseUrl: string;
+    apiKey: string;
+    timeoutMs?: number;
+}
+export declare class ZhipuToolAPI implements ProviderToolAPI {
+    readonly capabilities: readonly ProviderToolCapability[];
+    private baseUrl;
+    private apiKey;
+    private timeoutMs;
+    constructor(config: ZhipuToolAPIConfig);
+    webSearch(query: string, options?: {
+        maxResults?: number;
+    }): Promise<WebSearchResult[]>;
+    reader(pageUrl: string): Promise<ReaderResult>;
+    tokenize(text: string, model: string): Promise<TokenizerResult>;
+    moderate(text: string): Promise<ModerationResult>;
+    private postJSON;
+}

package/dist/types/orchestration/tool-cascade.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Tool Cascade — provider-native tool augmentation layer.
+ *
+ * When a provider (e.g. Zhipu GLM) offers native utility APIs (web search, reader,
+ * tokenizer, etc.), the tool cascade automatically routes through the provider API
+ * first, falling back to the host-provided implementation (e.g. SearXNG) on failure.
+ *
+ * ## Architecture
+ *
+ * Two levels of provider tool integration:
+ *
+ * 1. **D-level (builtin tools)**: Injected directly into chat completion request
+ *    via `builtinWebSearch` / `builtinCodeInterpreter` quirks.
+ *    The LLM decides to use these inline during generation — no agent intervention.
+ *    → Handled by openai-chat.ts transport layer.
+ *
+ * 2. **C-level (independent APIs)**: Discrete API endpoints the agent calls explicitly
+ *    as tool steps (web_search, reader, tokenizer, moderations).
+ *    → Handled by this cascade layer — wraps host-provided tool deps with
+ *      provider-native backends, falling back on error.
+ *
+ * ## Usage
+ *
+ * ```ts
+ * import { cascadeWebSearch } from "./tool-cascade.js";
+ * import { ZhipuToolAPI } from "../llm/transports/zhipu-tool-api.js";
+ *
+ * const providerApi = new ZhipuToolAPI({ baseUrl, apiKey });
+ * const cascadedSearch = cascadeWebSearch(providerApi, fallbackSearchFn);
+ * const tool = createWebSearchTool({ search: cascadedSearch });
+ * ```
+ */
+import type { ProviderToolAPI } from "../llm/provider-tool-api.js";
+import type { WebSearchToolDeps } from "../skills/tools/web-search-tool.js";
+/**
+ * Cascade web search: provider-native search → host fallback.
+ * Returns a WebSearchToolDeps.search function that tries the provider's
+ * webSearch API first, falling back to the host's search on error.
+ */
+export declare function cascadeWebSearch(providerApi: ProviderToolAPI | undefined, fallbackSearch: WebSearchToolDeps["search"]): WebSearchToolDeps["search"];

package/dist/types/orchestration/tool-loop/tool-schema.d.ts

@@ -32,7 +32,7 @@ export declare function parseOpenAiToolCallsFromChatResponse(responseBody: strin
 export declare function buildAssistantToolCallMessage(toolCalls: OpenAiToolCall[], text?: string, thinkingBlocks?: Array<{
     thinking: string;
     signature: string;
-}>): Record<string, unknown>;
+}>, reasoningContent?: string): Record<string, unknown>;
 export declare function buildToolResultMessage(callId: string, result: {
     ok: boolean;
     payload?: unknown;

package/dist/types/protocol/methods.d.ts

@@ -190,6 +190,21 @@ export interface ToolsListResult {
         parameters?: Record<string, unknown>;
     }>;
 }
+export interface MediaListModelsParams {
+    /** Filter by media type (image/video/music/tts/3d/stt/embedding). Omit to list all. */
+    mediaType?: string;
+}
+export interface MediaListModelsResult {
+    models: Array<{
+        providerId: string;
+        providerName: string;
+        modelId: string;
+        modelName: string;
+        mediaType: string;
+        /** Fine-grained capability metadata (operations, formats, limits) */
+        capabilities?: Record<string, unknown>;
+    }>;
+}
 export interface ConfigGetParams {
     keys?: string[];
 }
@@ -339,6 +354,10 @@ export interface RpcMethodMap {
         params: ToolsListParams;
         result: ToolsListResult;
     };
+    "media.listModels": {
+        params: MediaListModelsParams;
+        result: MediaListModelsResult;
+    };
     "config.get": {
         params: ConfigGetParams;
         result: ConfigGetResult;

package/dist/types/skills/memory/memory-extractor.d.ts

@@ -44,7 +44,7 @@ export type ExtractionCompleteFn = (params: {
     }>;
 }>;
 export interface MemoryExtractorOptions {
-    /** Model to use for extraction (default: "deepseek-chat"). */
+    /** Model to use for extraction (default: "deepseek-v4-flash"). */
     model?: string;
     /** Timeout in ms for the LLM call (default: 30_000). */
     timeoutMs?: number;

package/dist/types/skills/tools/file-management-tool.d.ts

@@ -0,0 +1,90 @@
+import type { PortableTool } from "../portable-tool.js";
+export declare const FILE_UPLOAD_TOOL_NAME: "file_upload";
+export interface FileUploadToolParams {
+    file_path: string;
+    purpose?: string;
+}
+export declare const FILE_UPLOAD_TOOL_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly file_path: {
+            readonly type: "string";
+            readonly description: string;
+        };
+        readonly purpose: {
+            readonly type: "string";
+            readonly description: string;
+        };
+    };
+    readonly required: readonly ["file_path"];
+};
+export interface FileUploadResult {
+    fileId: string;
+    url?: string;
+    filename: string;
+    bytes: number;
+    provider: string;
+}
+export interface FileUploadToolDeps {
+    uploadFile(params: {
+        filePath: string;
+        purpose?: string;
+    }): Promise<FileUploadResult>;
+}
+export declare function createFileUploadTool(deps: FileUploadToolDeps): PortableTool<FileUploadToolParams>;
+export declare const FILE_QUERY_TOOL_NAME: "file_query";
+export interface FileQueryToolParams {
+    file_id?: string;
+    limit?: number;
+}
+export declare const FILE_QUERY_TOOL_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly file_id: {
+            readonly type: "string";
+            readonly description: "Query a specific file by ID. If omitted, lists recent uploaded files.";
+        };
+        readonly limit: {
+            readonly type: "number";
+            readonly description: "Max number of files to list when file_id is omitted. Default: 10, max: 100.";
+        };
+    };
+    readonly required: readonly [];
+};
+export interface FileInfo {
+    id: string;
+    filename: string;
+    bytes: number;
+    status: string;
+    createdAt?: string;
+    url?: string;
+}
+export interface FileQueryToolDeps {
+    queryFile(params: {
+        fileId: string;
+    }): Promise<FileInfo>;
+    listFiles(params: {
+        limit?: number;
+    }): Promise<FileInfo[]>;
+}
+export declare function createFileQueryTool(deps: FileQueryToolDeps): PortableTool<FileQueryToolParams>;
+export declare const FILE_DELETE_TOOL_NAME: "file_delete";
+export interface FileDeleteToolParams {
+    file_id: string;
+}
+export declare const FILE_DELETE_TOOL_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly file_id: {
+            readonly type: "string";
+            readonly description: "ID of the uploaded file to delete.";
+        };
+    };
+    readonly required: readonly ["file_id"];
+};
+export interface FileDeleteToolDeps {
+    deleteFile(params: {
+        fileId: string;
+    }): Promise<void>;
+}
+export declare function createFileDeleteTool(deps: FileDeleteToolDeps): PortableTool<FileDeleteToolParams>;

package/dist/types/skills/tools/image-generate-tool.d.ts

@@ -7,6 +7,8 @@ export interface ImageGenerateToolParams {
     size?: string;
     image_url?: string;
     n?: number;
+    quality?: string;
+    seed?: number;
 }
 export declare const IMAGE_GENERATE_TOOL_SCHEMA: {
     readonly type: "object";
@@ -29,12 +31,20 @@ export declare const IMAGE_GENERATE_TOOL_SCHEMA: {
         };
         readonly image_url: {
             readonly type: "string";
-            readonly description: "Reference image URL for image-to-image generation (img2img). Character reference sheet or style transfer.";
+            readonly description: string;
         };
         readonly n: {
             readonly type: "number";
             readonly description: "Number of images to generate (1-4). Default: 1.";
         };
+        readonly quality: {
+            readonly type: "string";
+            readonly description: "Image quality level: 'auto', 'high', 'low', 'hd'. Provider-specific.";
+        };
+        readonly seed: {
+            readonly type: "number";
+            readonly description: "Random seed for reproducible generation. Same seed + prompt = same result.";
+        };
     };
     readonly required: readonly ["prompt"];
 };
@@ -57,6 +67,8 @@ export interface ImageGenerateToolDeps {
         size?: string;
         imageUrl?: string;
         n?: number;
+        quality?: string;
+        seed?: number;
     }): Promise<ImageGenerateResult>;
 }
 export declare function createImageGenerateTool(deps: ImageGenerateToolDeps): PortableTool<ImageGenerateToolParams>;

package/dist/types/skills/tools/music-generate-tool.d.ts

@@ -6,6 +6,9 @@ export interface MusicGenerateToolParams {
     style?: string;
     lyrics?: string;
     duration?: number;
+    is_instrumental?: boolean;
+    cover_audio_url?: string;
+    audio_format?: string;
 }
 export declare const MUSIC_GENERATE_TOOL_SCHEMA: {
     readonly type: "object";
@@ -30,6 +33,19 @@ export declare const MUSIC_GENERATE_TOOL_SCHEMA: {
             readonly type: "number";
             readonly description: "Duration in seconds (5-300). Infer from purpose: ringtone 15-30s, BGM 30-60s, full song 120-180s.";
         };
+        readonly is_instrumental: {
+            readonly type: "boolean";
+            readonly description: "Set true for pure instrumental music without vocals. Defaults to true when no lyrics are provided.";
+        };
+        readonly cover_audio_url: {
+            readonly type: "string";
+            readonly description: string;
+        };
+        readonly audio_format: {
+            readonly type: "string";
+            readonly enum: readonly ["mp3", "wav", "flac"];
+            readonly description: "Output audio format. Defaults to mp3.";
+        };
     };
     readonly required: readonly ["prompt"];
 };
@@ -50,6 +66,15 @@ export interface MusicGenerateToolDeps {
         style?: string;
         lyrics?: string;
         duration?: number;
+        isInstrumental?: boolean;
+        audioUrl?: string;
+        audioFormat?: string;
     }): Promise<MusicGenerateResult>;
+    /**
+     * Optional: auto-generate lyrics from a prompt (MiniMax Lyrics Generation API).
+     * When provided, the tool will auto-call this when no lyrics are supplied
+     * and the song is not marked as instrumental.
+     */
+    generateLyrics?: (prompt: string) => Promise<string>;
 }
 export declare function createMusicGenerateTool(deps: MusicGenerateToolDeps): PortableTool<MusicGenerateToolParams>;

package/dist/types/skills/tools/stt-tool.d.ts

@@ -0,0 +1,33 @@
+import type { PortableTool } from "../portable-tool.js";
+export declare const STT_TOOL_NAME: "stt";
+export interface SttToolParams {
+    audio_url: string;
+    language?: string;
+}
+export declare const STT_TOOL_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly audio_url: {
+            readonly type: "string";
+            readonly description: string;
+        };
+        readonly language: {
+            readonly type: "string";
+            readonly description: "Language hint for transcription: 'zh' (Chinese), 'en' (English), or auto-detect if omitted.";
+        };
+    };
+    readonly required: readonly ["audio_url"];
+};
+export interface SttResult {
+    transcription: string;
+    model?: string;
+    durationMs?: number;
+}
+/** Deps injected by the host runtime for STT. */
+export interface SttToolDeps {
+    speechToText(params: {
+        audioUrl: string;
+        language?: string;
+    }): Promise<SttResult>;
+}
+export declare function createSttTool(deps: SttToolDeps): PortableTool<SttToolParams>;

package/dist/types/skills/tools/three-d-generate-tool.d.ts

@@ -0,0 +1,45 @@
+import type { PortableTool } from "../portable-tool.js";
+export declare const THREE_D_GENERATE_TOOL_NAME: "three_d_generate";
+export interface ThreeDGenerateToolParams {
+    prompt: string;
+    image_url?: string;
+    output_format?: string;
+    seed?: number;
+}
+export declare const THREE_D_GENERATE_TOOL_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly prompt: {
+            readonly type: "string";
+            readonly description: string;
+        };
+        readonly image_url: {
+            readonly type: "string";
+            readonly description: string;
+        };
+        readonly output_format: {
+            readonly type: "string";
+            readonly description: "3D model output format: 'glb' (default), 'obj', 'usd', 'usdz'.";
+        };
+        readonly seed: {
+            readonly type: "number";
+            readonly description: "Random seed for reproducible generation.";
+        };
+    };
+    readonly required: readonly ["prompt"];
+};
+export interface ThreeDGenerateResult {
+    mediaUrls: string[];
+    model?: string;
+    durationMs?: number;
+}
+/** Deps injected by the host runtime for 3D generation. */
+export interface ThreeDGenerateToolDeps {
+    generate3D(params: {
+        prompt: string;
+        imageUrl?: string;
+        outputFormat?: string;
+        seed?: number;
+    }): Promise<ThreeDGenerateResult>;
+}
+export declare function createThreeDGenerateTool(deps: ThreeDGenerateToolDeps): PortableTool<ThreeDGenerateToolParams>;

package/dist/types/skills/tools/tts-tool.d.ts

@@ -3,6 +3,8 @@ export declare const TTS_TOOL_NAME: "tts";
 export interface TtsToolParams {
     text: string;
     channel?: string;
+    voice?: string;
+    speed?: number;
 }
 export declare const TTS_TOOL_SCHEMA: {
     readonly type: "object";
@@ -15,6 +17,14 @@ export declare const TTS_TOOL_SCHEMA: {
             readonly type: "string";
             readonly description: "Optional channel id to pick output format (e.g. telegram).";
         };
+        readonly voice: {
+            readonly type: "string";
+            readonly description: string;
+        };
+        readonly speed: {
+            readonly type: "number";
+            readonly description: "Speech speed multiplier (0.25-4.0). Default is 1.0.";
+        };
     };
     readonly required: readonly ["text"];
 };
@@ -33,6 +43,8 @@ export interface TtsToolDeps {
     textToSpeech(params: {
         text: string;
         channel?: string;
+        voice?: string;
+        speed?: number;
     }): Promise<TtsResult>;
 }
 export declare function createTtsTool(deps: TtsToolDeps): PortableTool<TtsToolParams>;

package/dist/types/skills/tools/video-edit-tool.d.ts

@@ -22,17 +22,20 @@ export declare const VIDEO_EDIT_TOOL_SCHEMA: {
             };
             readonly minItems: 1;
             readonly maxItems: 3;
-            readonly description: "Video(s) to edit (1-3 URLs). Order: [0]=视频1, [1]=视频2, [2]=视频3.";
+            readonly description: string;
         };
         readonly reference_images: {
             readonly type: "array";
             readonly items: {
                 readonly type: "string";
             };
-            readonly description: "Optional reference images for element replacement (up to 9).";
+            readonly maxItems: 9;
+            readonly description: string;
         };
         readonly duration: {
             readonly type: "number";
+            readonly minimum: 4;
+            readonly maximum: 15;
             readonly description: "Output duration in seconds (4-15s). Default: same as source.";
         };
         readonly aspect_ratio: {

package/dist/types/skills/tools/video-generate-tool.d.ts

@@ -5,8 +5,22 @@ export interface VideoGenerateToolParams {
     purpose?: string;
     style?: string;
     image_url?: string;
+    reference_videos?: string[];
+    reference_audios?: string[];
+    generate_audio?: boolean;
     aspect_ratio?: string;
     duration?: number;
+    resolution?: string;
+    fps?: number;
+    seed?: number;
+    camera_fixed?: boolean;
+    return_last_frame?: boolean;
+    draft?: boolean;
+    service_tier?: "default" | "flex";
+    callback_url?: string;
+    safety_identifier?: string;
+    execution_expires_after?: number;
+    video_tools?: string[];
 }
 export declare const VIDEO_GENERATE_TOOL_SCHEMA: {
     readonly type: "object";
@@ -25,7 +39,27 @@ export declare const VIDEO_GENERATE_TOOL_SCHEMA: {
         };
         readonly image_url: {
             readonly type: "string";
-            readonly description: "Reference image for image-to-video. Preview image from storyboard Step 3, or user-uploaded image.";
+            readonly description: string;
+        };
+        readonly reference_videos: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly maxItems: 3;
+            readonly description: string;
+        };
+        readonly reference_audios: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly maxItems: 3;
+            readonly description: string;
+        };
+        readonly generate_audio: {
+            readonly type: "boolean";
+            readonly description: string;
         };
         readonly aspect_ratio: {
             readonly type: "string";
@@ -33,7 +67,57 @@ export declare const VIDEO_GENERATE_TOOL_SCHEMA: {
         };
         readonly duration: {
             readonly type: "number";
-            readonly description: "Video duration in seconds (3-10s single-shot, >10s requires multi-shot workflow). Must be confirmed by user.";
+            readonly minimum: 3;
+            readonly maximum: 15;
+            readonly description: string;
+        };
+        readonly resolution: {
+            readonly type: "string";
+            readonly description: "Output resolution: '480p', '720p', '1080p'. Default: '720p'.";
+        };
+        readonly fps: {
+            readonly type: "number";
+            readonly description: "Frame rate: 24 or 30 fps. Default: provider-specific.";
+        };
+        readonly seed: {
+            readonly type: "number";
+            readonly description: "Random seed for reproducible generation.";
+        };
+        readonly camera_fixed: {
+            readonly type: "boolean";
+            readonly description: "Lock camera position (Seedance 1.0/1.5 only, not supported for img2video).";
+        };
+        readonly return_last_frame: {
+            readonly type: "boolean";
+            readonly description: "Return last frame URL for chaining continuous video segments.";
+        };
+        readonly draft: {
+            readonly type: "boolean";
+            readonly description: "Draft mode: low-cost preview (Seedance 1.5 pro only).";
+        };
+        readonly service_tier: {
+            readonly type: "string";
+            readonly enum: readonly ["default", "flex"];
+            readonly description: "'default' (online, fast) or 'flex' (offline, ~50% cost). Not all models support flex.";
+        };
+        readonly callback_url: {
+            readonly type: "string";
+            readonly description: "Webhook URL for async task completion notification.";
+        };
+        readonly safety_identifier: {
+            readonly type: "string";
+            readonly description: "End-user safety identifier for content moderation tracking.";
+        };
+        readonly execution_expires_after: {
+            readonly type: "number";
+            readonly description: "Task expiration in seconds (for offline/flex scheduling).";
+        };
+        readonly video_tools: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly description: "Video-level builtin tools, e.g. ['web_search'] (Seedance 2.0 online search).";
         };
     };
     readonly required: readonly ["prompt"];
@@ -42,6 +126,8 @@ export interface VideoGenerateResult {
     mediaUrls: string[];
     model?: string;
     durationMs?: number;
+    lastFrameUrl?: string;
+    taskId?: string;
 }
 /** Deps injected by the host runtime for video generation. */
 export interface VideoGenerateToolDeps {
@@ -55,8 +141,22 @@ export interface VideoGenerateToolDeps {
         purpose?: string;
         style?: string;
         imageUrl?: string;
+        referenceVideos?: string[];
+        referenceAudios?: string[];
+        generateAudio?: boolean;
         aspectRatio?: string;
         duration?: number;
+        resolution?: string;
+        fps?: number;
+        seed?: number;
+        cameraFixed?: boolean;
+        returnLastFrame?: boolean;
+        draft?: boolean;
+        serviceTier?: "default" | "flex";
+        callbackUrl?: string;
+        safetyIdentifier?: string;
+        executionExpiresAfterSeconds?: number;
+        videoTools?: string[];
     }): Promise<VideoGenerateResult>;
 }
 export declare function createVideoGenerateTool(deps: VideoGenerateToolDeps): PortableTool<VideoGenerateToolParams>;

package/dist/types/skills/tools/video-merge-tool.d.ts

@@ -26,7 +26,7 @@ export declare const VIDEO_MERGE_TOOL_SCHEMA: {
                 readonly properties: {
                     readonly video: {
                         readonly type: "string";
-                        readonly description: "Video file path.";
+                        readonly description: "Video URL or file path. MUST be publicly accessible HTTP/HTTPS URL. Use file_upload tool first if local file.";
                     };
                     readonly audio: {
                         readonly type: "string";

package/dist/types/skills/tools/video-upscale-tool.d.ts

@@ -10,7 +10,7 @@ export declare const VIDEO_UPSCALE_TOOL_SCHEMA: {
     readonly properties: {
         readonly video: {
             readonly type: "string";
-            readonly description: "Video file path (local or serve path).";
+            readonly description: string;
         };
         readonly targetResolution: {
             readonly type: "string";