qlogicagent 0.2.1 → 0.4.0

package/dist/skills/tools/video-edit-tool.js

@@ -1,74 +0,0 @@
-// ============================================================
-// Video Edit Tool — edit existing videos via backend adapter.
-// Category: media
-// ============================================================
-export const VIDEO_EDIT_TOOL_NAME = "video_edit";
-export const VIDEO_EDIT_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        prompt: {
-            type: "string",
-            description: "Edit instruction. Reference videos as 视频1, 视频2, 视频3. " +
-                "Reference images as 图片1, 图片2. " +
-                "Operations: add/remove/modify elements, extend, track fill.",
-        },
-        source_videos: {
-            type: "array",
-            items: { type: "string" },
-            minItems: 1,
-            maxItems: 3,
-            description: "Video(s) to edit (1-3 URLs). Order: [0]=视频1, [1]=视频2, [2]=视频3.",
-        },
-        reference_images: {
-            type: "array",
-            items: { type: "string" },
-            description: "Optional reference images for element replacement (up to 9).",
-        },
-        duration: {
-            type: "number",
-            description: "Output duration in seconds (4-15s). Default: same as source.",
-        },
-        aspect_ratio: {
-            type: "string",
-            description: "Output aspect ratio: 16:9, 9:16, 1:1, 4:3, 3:4, 21:9. Default: same as source.",
-        },
-        resolution: {
-            type: "string",
-            description: "Output resolution: '480p' or '720p'. Default: '720p'.",
-        },
-    },
-    required: ["prompt", "source_videos"],
-};
-export function createVideoEditTool(deps) {
-    return {
-        name: VIDEO_EDIT_TOOL_NAME,
-        label: "Video Edit",
-        description: "Edit existing videos: add/remove/modify elements, extend, or bridge clips. " +
-            "Requires source_videos. Max 3 source videos, max 720p. " +
-            "For generating NEW videos from scratch, use video_generate instead.",
-        parameters: VIDEO_EDIT_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            if (!params.source_videos?.length) {
-                return { content: [{ type: "text", text: "Error: source_videos is required." }] };
-            }
-            const result = await deps.editVideo({
-                prompt: params.prompt,
-                sourceVideos: params.source_videos,
-                referenceImages: params.reference_images,
-                duration: params.duration,
-                aspectRatio: params.aspect_ratio,
-                resolution: params.resolution,
-            });
-            const text = `Video edited successfully${result.model ? ` (model: ${result.model})` : ""}`;
-            return {
-                content: [{ type: "text", text }],
-                details: {
-                    type: "video_edit",
-                    model: result.model,
-                    durationMs: result.durationMs,
-                    mediaUrls: result.mediaUrls,
-                },
-            };
-        },
-    };
-}

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

@@ -1,62 +0,0 @@
-import type { PortableTool } from "../portable-tool.js";
-export declare const VIDEO_GENERATE_TOOL_NAME: "video_generate";
-export interface VideoGenerateToolParams {
-    prompt: string;
-    purpose?: string;
-    style?: string;
-    image_url?: string;
-    aspect_ratio?: string;
-    duration?: number;
-}
-export declare const VIDEO_GENERATE_TOOL_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly prompt: {
-            readonly type: "string";
-            readonly description: "Video generation prompt. MUST be in English. Include scene, movement, camera motion, lighting, style.";
-        };
-        readonly purpose: {
-            readonly type: "string";
-            readonly description: "Intended use: 'social-media', 'short-video', 'presentation', etc.";
-        };
-        readonly style: {
-            readonly type: "string";
-            readonly description: "Visual style: 'cinematic', 'anime', 'watercolor', etc.";
-        };
-        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 aspect_ratio: {
-            readonly type: "string";
-            readonly description: "Video aspect ratio: '9:16' (vertical), '16:9' (horizontal), '1:1' (square). Default: '16:9'.";
-        };
-        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 required: readonly ["prompt"];
-};
-export interface VideoGenerateResult {
-    mediaUrls: string[];
-    model?: string;
-    durationMs?: number;
-}
-/** Deps injected by the host runtime for video generation. */
-export interface VideoGenerateToolDeps {
-    /**
-     * Generate a video clip via the configured backend.
-     * The host handles model selection, duration snapping, failover,
-     * watermark, and local storage.
-     */
-    generateVideo(params: {
-        prompt: string;
-        purpose?: string;
-        style?: string;
-        imageUrl?: string;
-        aspectRatio?: string;
-        duration?: number;
-    }): Promise<VideoGenerateResult>;
-}
-export declare function createVideoGenerateTool(deps: VideoGenerateToolDeps): PortableTool<VideoGenerateToolParams>;

package/dist/skills/tools/video-generate-tool.js

@@ -1,66 +0,0 @@
-// ============================================================
-// Video Generate Tool — generate video clips via backend.
-// Category: media
-// ============================================================
-export const VIDEO_GENERATE_TOOL_NAME = "video_generate";
-export const VIDEO_GENERATE_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        prompt: {
-            type: "string",
-            description: "Video generation prompt. MUST be in English. Include scene, movement, camera motion, lighting, style.",
-        },
-        purpose: {
-            type: "string",
-            description: "Intended use: 'social-media', 'short-video', 'presentation', etc.",
-        },
-        style: {
-            type: "string",
-            description: "Visual style: 'cinematic', 'anime', 'watercolor', etc.",
-        },
-        image_url: {
-            type: "string",
-            description: "Reference image for image-to-video. Preview image from storyboard Step 3, or user-uploaded image.",
-        },
-        aspect_ratio: {
-            type: "string",
-            description: "Video aspect ratio: '9:16' (vertical), '16:9' (horizontal), '1:1' (square). Default: '16:9'.",
-        },
-        duration: {
-            type: "number",
-            description: "Video duration in seconds (3-10s single-shot, >10s requires multi-shot workflow). Must be confirmed by user.",
-        },
-    },
-    required: ["prompt"],
-};
-export function createVideoGenerateTool(deps) {
-    return {
-        name: VIDEO_GENERATE_TOOL_NAME,
-        label: "Video Generate",
-        description: "Generate a short video clip from a text prompt (and optional reference image). " +
-            "Prompt MUST be in English. Include scene, movement, camera motion, lighting details. " +
-            "Single-shot: 3–10s. For longer videos (>10s), use multi-shot storyboard workflow.",
-        parameters: VIDEO_GENERATE_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            const result = await deps.generateVideo({
-                prompt: params.prompt,
-                purpose: params.purpose,
-                style: params.style,
-                imageUrl: params.image_url,
-                aspectRatio: params.aspect_ratio,
-                duration: params.duration,
-            });
-            const count = result.mediaUrls.length;
-            const text = `Generated ${count} video${count > 1 ? "s" : ""}${result.model ? ` (model: ${result.model})` : ""}`;
-            return {
-                content: [{ type: "text", text }],
-                details: {
-                    type: "video_generate",
-                    model: result.model,
-                    durationMs: result.durationMs,
-                    mediaUrls: result.mediaUrls,
-                },
-            };
-        },
-    };
-}

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

@@ -1,105 +0,0 @@
-import type { PortableTool } from "../portable-tool.js";
-export declare const VIDEO_MERGE_TOOL_NAME: "video_merge";
-export interface VideoMergeClip {
-    video: string;
-    audio?: string;
-    trimStart?: number;
-    trimEnd?: number;
-}
-export interface VideoMergeToolParams {
-    clips: VideoMergeClip[];
-    transition?: string;
-    transitionDuration?: number;
-    subtitles?: string;
-    bgm?: string;
-    bgmVolume?: number;
-    outputResolution?: string;
-    outputFps?: number;
-}
-export declare const VIDEO_MERGE_TOOL_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly clips: {
-            readonly type: "array";
-            readonly items: {
-                readonly type: "object";
-                readonly properties: {
-                    readonly video: {
-                        readonly type: "string";
-                        readonly description: "Video file path.";
-                    };
-                    readonly audio: {
-                        readonly type: "string";
-                        readonly description: "Narration audio file path (from TTS).";
-                    };
-                    readonly trimStart: {
-                        readonly type: "number";
-                        readonly description: "Trim start in seconds (default 0).";
-                    };
-                    readonly trimEnd: {
-                        readonly type: "number";
-                        readonly description: "Trim end in seconds (default: full).";
-                    };
-                };
-                readonly required: readonly ["video"];
-            };
-            readonly minItems: 2;
-            readonly description: "Array of video clips to merge, in order.";
-        };
-        readonly transition: {
-            readonly type: "string";
-            readonly description: "Transition effect: 'crossfade' (default), 'fade', 'wipeleft', 'cut', 'dissolve', etc.";
-        };
-        readonly transitionDuration: {
-            readonly type: "number";
-            readonly description: "Transition duration in seconds (0.1-2.0, default 0.5).";
-        };
-        readonly subtitles: {
-            readonly type: "string";
-            readonly description: "Path to SRT subtitle file to burn-in.";
-        };
-        readonly bgm: {
-            readonly type: "string";
-            readonly description: "Background music file path.";
-        };
-        readonly bgmVolume: {
-            readonly type: "number";
-            readonly description: "BGM volume (0.0-1.0, default 0.15).";
-        };
-        readonly outputResolution: {
-            readonly type: "string";
-            readonly description: "Output resolution: '1920x1080', '1080x1920', etc. Default: auto.";
-        };
-        readonly outputFps: {
-            readonly type: "number";
-            readonly description: "Output FPS (default 30).";
-        };
-    };
-    readonly required: readonly ["clips"];
-};
-export interface VideoMergeResult {
-    localPath: string;
-    servePath: string;
-    durationSec: number;
-    clipCount: number;
-    mediaUrls: string[];
-}
-/** Deps injected by the host runtime for video merging. */
-export interface VideoMergeToolDeps {
-    /**
-     * Merge video clips via the configured backend (ffmpeg, relay, etc.).
-     * The host handles resolution normalization, transition rendering,
-     * subtitle burn-in, BGM mixing, and local storage.
-     */
-    mergeVideos(params: {
-        clips: VideoMergeClip[];
-        transition?: string;
-        transitionDuration?: number;
-        subtitles?: string;
-        bgm?: string;
-        bgmVolume?: number;
-        outputResolution?: string;
-        outputFps?: number;
-    }): Promise<VideoMergeResult>;
-}
-export declare function createVideoMergeTool(deps: VideoMergeToolDeps): PortableTool<VideoMergeToolParams>;

package/dist/skills/tools/video-merge-tool.js

@@ -1,92 +0,0 @@
-// ============================================================
-// Video Merge Tool — merge multiple video clips with transitions.
-// Category: media
-// ============================================================
-export const VIDEO_MERGE_TOOL_NAME = "video_merge";
-export const VIDEO_MERGE_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        clips: {
-            type: "array",
-            items: {
-                type: "object",
-                properties: {
-                    video: { type: "string", description: "Video file path." },
-                    audio: { type: "string", description: "Narration audio file path (from TTS)." },
-                    trimStart: { type: "number", description: "Trim start in seconds (default 0)." },
-                    trimEnd: { type: "number", description: "Trim end in seconds (default: full)." },
-                },
-                required: ["video"],
-            },
-            minItems: 2,
-            description: "Array of video clips to merge, in order.",
-        },
-        transition: {
-            type: "string",
-            description: "Transition effect: 'crossfade' (default), 'fade', 'wipeleft', 'cut', 'dissolve', etc.",
-        },
-        transitionDuration: {
-            type: "number",
-            description: "Transition duration in seconds (0.1-2.0, default 0.5).",
-        },
-        subtitles: {
-            type: "string",
-            description: "Path to SRT subtitle file to burn-in.",
-        },
-        bgm: {
-            type: "string",
-            description: "Background music file path.",
-        },
-        bgmVolume: {
-            type: "number",
-            description: "BGM volume (0.0-1.0, default 0.15).",
-        },
-        outputResolution: {
-            type: "string",
-            description: "Output resolution: '1920x1080', '1080x1920', etc. Default: auto.",
-        },
-        outputFps: {
-            type: "number",
-            description: "Output FPS (default 30).",
-        },
-    },
-    required: ["clips"],
-};
-export function createVideoMergeTool(deps) {
-    return {
-        name: VIDEO_MERGE_TOOL_NAME,
-        label: "Video Merge",
-        description: "Merge multiple video clips into a single video with transitions, subtitles, and background music. " +
-            "Requires at least 2 clips. Supports crossfade, fade, wipe, dissolve, and cut transitions. " +
-            "Audio per clip is preserved; BGM is mixed at adjustable volume.",
-        parameters: VIDEO_MERGE_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            if (!params.clips || params.clips.length < 2) {
-                return { content: [{ type: "text", text: "Error: at least 2 clips are required for merging." }] };
-            }
-            const result = await deps.mergeVideos({
-                clips: params.clips,
-                transition: params.transition,
-                transitionDuration: params.transitionDuration,
-                subtitles: params.subtitles,
-                bgm: params.bgm,
-                bgmVolume: params.bgmVolume,
-                outputResolution: params.outputResolution,
-                outputFps: params.outputFps,
-            });
-            const text = `Merged ${result.clipCount} clips → ${result.durationSec.toFixed(1)}s video` +
-                (params.transition ? ` (transition: ${params.transition})` : "");
-            return {
-                content: [{ type: "text", text }],
-                details: {
-                    type: "video_merge",
-                    localPath: result.localPath,
-                    servePath: result.servePath,
-                    durationSec: result.durationSec,
-                    clipCount: result.clipCount,
-                    mediaUrls: result.mediaUrls,
-                },
-            };
-        },
-    };
-}

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

@@ -1,45 +0,0 @@
-import type { PortableTool } from "../portable-tool.js";
-export declare const VIDEO_UPSCALE_TOOL_NAME: "video_upscale";
-export interface VideoUpscaleToolParams {
-    video: string;
-    targetResolution?: string;
-    sharpness?: string;
-}
-export declare const VIDEO_UPSCALE_TOOL_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly video: {
-            readonly type: "string";
-            readonly description: "Video file path (local or serve path).";
-        };
-        readonly targetResolution: {
-            readonly type: "string";
-            readonly description: "Target resolution: '1080p' (default, 1920x1080/1080x1920), '2k' (2560x1440/1440x2560).";
-        };
-        readonly sharpness: {
-            readonly type: "string";
-            readonly description: "Sharpening intensity: 'light' (default), 'medium', 'strong'.";
-        };
-    };
-    readonly required: readonly ["video"];
-};
-export interface VideoUpscaleResult {
-    localPath: string;
-    servePath: string;
-    resolution: string;
-    durationSec: number;
-    mediaUrls: string[];
-}
-/** Deps injected by the host runtime for video upscaling. */
-export interface VideoUpscaleToolDeps {
-    /**
-     * Upscale a video via the configured backend (ffmpeg Lanczos + unsharp mask, etc.).
-     * The host handles orientation detection, filter chain, and storage.
-     */
-    upscaleVideo(params: {
-        video: string;
-        targetResolution?: string;
-        sharpness?: string;
-    }): Promise<VideoUpscaleResult>;
-}
-export declare function createVideoUpscaleTool(deps: VideoUpscaleToolDeps): PortableTool<VideoUpscaleToolParams>;

package/dist/skills/tools/video-upscale-tool.js

@@ -1,52 +0,0 @@
-// ============================================================
-// Video Upscale Tool — upscale video resolution + sharpen.
-// Category: media
-// ============================================================
-export const VIDEO_UPSCALE_TOOL_NAME = "video_upscale";
-export const VIDEO_UPSCALE_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        video: {
-            type: "string",
-            description: "Video file path (local or serve path).",
-        },
-        targetResolution: {
-            type: "string",
-            description: "Target resolution: '1080p' (default, 1920x1080/1080x1920), '2k' (2560x1440/1440x2560).",
-        },
-        sharpness: {
-            type: "string",
-            description: "Sharpening intensity: 'light' (default), 'medium', 'strong'.",
-        },
-    },
-    required: ["video"],
-};
-export function createVideoUpscaleTool(deps) {
-    return {
-        name: VIDEO_UPSCALE_TOOL_NAME,
-        label: "Video Upscale",
-        description: "Upscale a video to higher resolution with optional sharpening. " +
-            "Auto-detects orientation (landscape/portrait). Uses Lanczos interpolation + unsharp mask. " +
-            "Supports 1080p and 2K targets. Best used as post-processing after video_merge.",
-        parameters: VIDEO_UPSCALE_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            const result = await deps.upscaleVideo({
-                video: params.video,
-                targetResolution: params.targetResolution,
-                sharpness: params.sharpness,
-            });
-            const text = `Upscaled to ${result.resolution}${params.sharpness ? ` (sharpness: ${params.sharpness})` : ""}`;
-            return {
-                content: [{ type: "text", text }],
-                details: {
-                    type: "video_upscale",
-                    localPath: result.localPath,
-                    servePath: result.servePath,
-                    resolution: result.resolution,
-                    durationSec: result.durationSec,
-                    mediaUrls: result.mediaUrls,
-                },
-            };
-        },
-    };
-}

package/dist/skills/tools/web-fetch-tool.d.ts

@@ -1,78 +0,0 @@
-import type { PortableTool } from "../portable-tool.js";
-export declare const WEB_FETCH_TOOL_NAME: "web_fetch";
-export interface WebFetchToolParams {
-    url: string;
-    extractMode?: "markdown" | "text" | "json";
-    maxChars?: number;
-    query?: string;
-    extract?: boolean;
-    summarize?: boolean;
-}
-export declare const WEB_FETCH_TOOL_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly url: {
-            readonly type: "string";
-            readonly description: "HTTP or HTTPS URL to fetch.";
-        };
-        readonly extractMode: {
-            readonly type: "string";
-            readonly enum: readonly ["markdown", "text", "json"];
-            readonly description: "Extraction mode: \"markdown\" (default), \"text\", or \"json\" (LLM-driven structured extraction).";
-        };
-        readonly maxChars: {
-            readonly type: "number";
-            readonly description: "Maximum characters to return (truncates when exceeded).";
-            readonly minimum: 100;
-        };
-        readonly query: {
-            readonly type: "string";
-            readonly description: "Original search query. When provided, returns the most query-relevant sections.";
-        };
-        readonly extract: {
-            readonly type: "boolean";
-            readonly description: "When true, returns structured extraction (title, summary, key facts, entities, topics, sentiment).";
-        };
-        readonly summarize: {
-            readonly type: "boolean";
-            readonly description: string;
-        };
-    };
-    readonly required: readonly ["url"];
-};
-export interface WebFetchResult {
-    content: string;
-    title?: string;
-    relevantExcerpts?: string[];
-    summary?: string;
-    extraction?: {
-        title?: string;
-        summary?: string;
-        keyFacts?: string[];
-        entities?: string[];
-        topics?: string[];
-        sentiment?: string;
-    };
-}
-/** Deps injected by the host runtime for web fetching. */
-export interface WebFetchToolDeps {
-    /**
-     * Fetch a URL and extract content.
-     * The host handles user-agent rotation, anti-block,
-     * JS rendering, caching, and content extraction.
-     */
-    fetchUrl(params: {
-        url: string;
-        extractMode?: "markdown" | "text" | "json";
-        maxChars?: number;
-        query?: string;
-        extract?: boolean;
-    }): Promise<WebFetchResult>;
-    /**
-     * Optional: summarize long content using a small/cheap model.
-     * When provided and summarize=true is requested, called after fetchUrl.
-     * Should return a concise summary (< 500 chars) preserving key information.
-     */
-    summarizeContent?(content: string, query?: string): Promise<string>;
-}
-export declare function createWebFetchTool(deps: WebFetchToolDeps): PortableTool<WebFetchToolParams>;

package/dist/skills/tools/web-fetch-tool.js

@@ -1,92 +0,0 @@
-// ============================================================
-// Web Fetch Tool — fetch and extract web page content.
-// Category: web
-// ============================================================
-export const WEB_FETCH_TOOL_NAME = "web_fetch";
-export const WEB_FETCH_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        url: {
-            type: "string",
-            description: "HTTP or HTTPS URL to fetch.",
-        },
-        extractMode: {
-            type: "string",
-            enum: ["markdown", "text", "json"],
-            description: 'Extraction mode: "markdown" (default), "text", or "json" (LLM-driven structured extraction).',
-        },
-        maxChars: {
-            type: "number",
-            description: "Maximum characters to return (truncates when exceeded).",
-            minimum: 100,
-        },
-        query: {
-            type: "string",
-            description: "Original search query. When provided, returns the most query-relevant sections.",
-        },
-        extract: {
-            type: "boolean",
-            description: "When true, returns structured extraction (title, summary, key facts, entities, topics, sentiment).",
-        },
-        summarize: {
-            type: "boolean",
-            description: "When true, returns a concise summary (< 500 chars) of the page content. " +
-                "Useful for long pages to reduce context usage while preserving key information.",
-        },
-    },
-    required: ["url"],
-};
-const DEFAULT_MAX_CHARS = 50000;
-export function createWebFetchTool(deps) {
-    return {
-        name: WEB_FETCH_TOOL_NAME,
-        label: "Web Fetch",
-        description: "Fetch content from a URL and extract it as markdown, text, or structured JSON. " +
-            "Supports query-based relevance filtering and structured extraction " +
-            "(title, summary, key facts, entities, topics, sentiment).",
-        parameters: WEB_FETCH_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            const result = await deps.fetchUrl({
-                url: params.url,
-                extractMode: params.extractMode,
-                maxChars: params.maxChars ?? DEFAULT_MAX_CHARS,
-                query: params.query,
-                extract: params.extract,
-            });
-            // Summarization: if requested and content is long enough to warrant it
-            if (params.summarize && deps.summarizeContent && result.content.length > 1000) {
-                const summary = await deps.summarizeContent(result.content, params.query);
-                return {
-                    content: [{ type: "text", text: result.title ? `# ${result.title}\n\n${summary}` : summary }],
-                    details: {
-                        type: "web_fetch",
-                        url: params.url,
-                        summarized: true,
-                        originalLength: result.content.length,
-                        summaryLength: summary.length,
-                    },
-                };
-            }
-            const parts = [];
-            if (result.title)
-                parts.push(`# ${result.title}\n`);
-            parts.push(result.content);
-            if (result.relevantExcerpts?.length) {
-                parts.push("\n---\n## Relevant Excerpts\n");
-                for (const excerpt of result.relevantExcerpts) {
-                    parts.push(`- ${excerpt}`);
-                }
-            }
-            return {
-                content: [{ type: "text", text: parts.join("\n") }],
-                details: {
-                    type: "web_fetch",
-                    url: params.url,
-                    extractMode: params.extractMode ?? "markdown",
-                    hasExtraction: !!result.extraction,
-                    extraction: result.extraction,
-                },
-            };
-        },
-    };
-}