qlogicagent 0.5.2 → 0.6.0

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

@@ -0,0 +1,104 @@
+import type { PortableTool } from "../portable-tool.js";
+export declare const TASK_TOOL_NAME: "task";
+export type TaskAction = "create" | "get" | "list" | "output" | "stop";
+export type TaskStatus = "pending" | "running" | "completed" | "failed" | "stopped";
+export interface TaskToolParams {
+    action: TaskAction;
+    /** Task ID (required for get/output/stop) */
+    taskId?: string;
+    /** Task prompt (required for create) */
+    prompt?: string;
+    /** Short description (3-7 words, for create) */
+    description?: string;
+    /** Allowed tools for the background agent */
+    allowedTools?: string[];
+    /** Working directory for the task */
+    cwd?: string;
+    /** Model override for the task agent */
+    model?: string;
+    /** Max output lines to return (for output action, default 100) */
+    maxLines?: number;
+}
+export declare const TASK_TOOL_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly action: {
+            readonly type: "string";
+            readonly enum: readonly ["create", "get", "list", "output", "stop"];
+            readonly description: string;
+        };
+        readonly taskId: {
+            readonly type: "string";
+            readonly description: "Task ID. Required for get/output/stop.";
+        };
+        readonly prompt: {
+            readonly type: "string";
+            readonly description: string;
+        };
+        readonly description: {
+            readonly type: "string";
+            readonly description: "Short (3-7 word) description of the task. Used for tracking and display.";
+        };
+        readonly allowedTools: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly description: "Restrict background agent to only these tools. If omitted, inherits parent's tools.";
+        };
+        readonly cwd: {
+            readonly type: "string";
+            readonly description: "Working directory for the background task (absolute path).";
+        };
+        readonly model: {
+            readonly type: "string";
+            readonly description: "Model override for the task agent (e.g. 'sonnet', 'opus').";
+        };
+        readonly maxLines: {
+            readonly type: "number";
+            readonly description: "Max output lines to return for the 'output' action (default: 100).";
+            readonly minimum: 1;
+            readonly maximum: 2000;
+        };
+    };
+    readonly required: readonly ["action"];
+};
+export interface TaskInfo {
+    taskId: string;
+    status: TaskStatus;
+    description?: string;
+    prompt?: string;
+    createdAt: number;
+    completedAt?: number;
+    result?: string;
+    error?: string;
+}
+export interface TaskResult {
+    success: boolean;
+    task?: TaskInfo;
+    tasks?: TaskInfo[];
+    output?: string;
+    error?: string;
+}
+/** Host-provided task management backend. */
+export interface TaskToolDeps {
+    /** Create a new background agent task. Returns the created task info. */
+    createTask(params: {
+        prompt: string;
+        description?: string;
+        allowedTools?: string[];
+        cwd?: string;
+        model?: string;
+    }): Promise<TaskInfo>;
+    /** Get a task by ID. Returns null if not found. */
+    getTask(taskId: string): Promise<TaskInfo | null>;
+    /** List all tasks (optionally filtered by status). */
+    listTasks(filter?: {
+        status?: TaskStatus;
+    }): Promise<TaskInfo[]>;
+    /** Get output/logs from a task. */
+    getTaskOutput(taskId: string, maxLines?: number): Promise<string>;
+    /** Stop a running task. Returns true if stopped successfully. */
+    stopTask(taskId: string): Promise<boolean>;
+}
+export declare function createTaskTool(deps: TaskToolDeps): PortableTool<TaskToolParams>;

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

@@ -0,0 +1,89 @@
+import type { PortableTool } from "../portable-tool.js";
+export declare const TEAM_TOOL_NAME: "team";
+export type TeamAction = "create" | "delete" | "list" | "status";
+export interface TeamMember {
+    name: string;
+    role: string;
+    tools?: string[];
+}
+export interface TeamToolParams {
+    action: TeamAction;
+    /** Team name (required for create/delete) */
+    teamName?: string;
+    /** Team description */
+    description?: string;
+    /** Members to include (for create) */
+    members?: TeamMember[];
+}
+export declare const TEAM_TOOL_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly action: {
+            readonly type: "string";
+            readonly enum: readonly ["create", "delete", "list", "status"];
+            readonly description: "Team action: create (new team), delete (disband), list (all teams), status (team details).";
+        };
+        readonly teamName: {
+            readonly type: "string";
+            readonly description: "Team name. Required for create/delete/status.";
+        };
+        readonly description: {
+            readonly type: "string";
+            readonly description: "Team description/objective. Used for create.";
+        };
+        readonly members: {
+            readonly type: "array";
+            readonly description: "Team members with roles and tool restrictions.";
+            readonly items: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly name: {
+                        readonly type: "string";
+                        readonly description: "Agent name/role identifier.";
+                    };
+                    readonly role: {
+                        readonly type: "string";
+                        readonly description: "Role description (e.g. 'frontend developer').";
+                    };
+                    readonly tools: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly description: "Allowed tools for this member.";
+                    };
+                };
+                readonly required: readonly ["name", "role"];
+            };
+        };
+    };
+    readonly required: readonly ["action"];
+};
+export interface Team {
+    name: string;
+    description?: string;
+    leadId: string;
+    members: TeamMember[];
+    createdAt: string;
+}
+export interface TeamResult {
+    success: boolean;
+    team?: Team;
+    teams?: Team[];
+    error?: string;
+}
+/**
+ * Host-provided team management backend.
+ * Creates agent teams where members coordinate via send_message.
+ */
+export interface TeamToolDeps {
+    createTeam(params: {
+        teamName: string;
+        description?: string;
+        members?: TeamMember[];
+    }): Promise<TeamResult>;
+    deleteTeam(teamName: string): Promise<TeamResult>;
+    listTeams(): Promise<TeamResult>;
+    getTeamStatus(teamName: string): Promise<TeamResult>;
+}
+export declare function createTeamTool(deps: TeamToolDeps): PortableTool<TeamToolParams>;

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

@@ -0,0 +1,51 @@
+import type { PortableTool } from "../portable-tool.js";
+export declare const TOOL_SEARCH_TOOL_NAME: "tool_search";
+export interface ToolSearchToolParams {
+    query: string;
+    maxResults?: number;
+}
+export declare const TOOL_SEARCH_TOOL_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly query: {
+            readonly type: "string";
+            readonly description: string;
+        };
+        readonly maxResults: {
+            readonly type: "number";
+            readonly description: "Maximum number of results to return (default: 5).";
+        };
+    };
+    readonly required: readonly ["query"];
+};
+export interface DeferredToolInfo {
+    name: string;
+    description: string;
+    /** Optional search hint for better discovery */
+    searchHint?: string;
+}
+export interface ToolSearchOutput {
+    matches: DeferredToolInfo[];
+    query: string;
+    totalDeferred: number;
+}
+/**
+ * Host-provided deferred tool registry.
+ * The host manages which tools are loaded vs deferred,
+ * and handles activation when selected.
+ */
+export interface ToolSearchToolDeps {
+    /**
+     * Search deferred tools by query.
+     * Supports "select:name" for direct activation and keyword search.
+     */
+    searchTools(query: string, options?: {
+        maxResults?: number;
+    }): Promise<ToolSearchOutput>;
+    /**
+     * Activate a deferred tool so it appears in subsequent turns.
+     * Returns true if activation succeeded.
+     */
+    activateTool?(name: string): Promise<boolean>;
+}
+export declare function createToolSearchTool(deps: ToolSearchToolDeps): PortableTool<ToolSearchToolParams>;

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

@@ -0,0 +1,38 @@
+import type { PortableTool } from "../portable-tool.js";
+export declare const TTS_TOOL_NAME: "tts";
+export interface TtsToolParams {
+    text: string;
+    channel?: string;
+}
+export declare const TTS_TOOL_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly text: {
+            readonly type: "string";
+            readonly description: "Text to convert to speech.";
+        };
+        readonly channel: {
+            readonly type: "string";
+            readonly description: "Optional channel id to pick output format (e.g. telegram).";
+        };
+    };
+    readonly required: readonly ["text"];
+};
+export interface TtsResult {
+    audioPath: string;
+    provider?: string;
+    voiceCompatible?: boolean;
+    mediaUrls: string[];
+}
+/** Deps injected by the host runtime for TTS. */
+export interface TtsToolDeps {
+    /**
+     * Convert text to speech via the configured backend.
+     * The host handles voice selection, format conversion, and storage.
+     */
+    textToSpeech(params: {
+        text: string;
+        channel?: string;
+    }): Promise<TtsResult>;
+}
+export declare function createTtsTool(deps: TtsToolDeps): PortableTool<TtsToolParams>;

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

@@ -0,0 +1,69 @@
+import type { PortableTool } from "../portable-tool.js";
+export declare const VIDEO_EDIT_TOOL_NAME: "video_edit";
+export interface VideoEditToolParams {
+    prompt: string;
+    source_videos: string[];
+    reference_images?: string[];
+    duration?: number;
+    aspect_ratio?: string;
+    resolution?: string;
+}
+export declare const VIDEO_EDIT_TOOL_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly prompt: {
+            readonly type: "string";
+            readonly description: string;
+        };
+        readonly source_videos: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly minItems: 1;
+            readonly maxItems: 3;
+            readonly description: "Video(s) to edit (1-3 URLs). Order: [0]=视频1, [1]=视频2, [2]=视频3.";
+        };
+        readonly reference_images: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly description: "Optional reference images for element replacement (up to 9).";
+        };
+        readonly duration: {
+            readonly type: "number";
+            readonly description: "Output duration in seconds (4-15s). Default: same as source.";
+        };
+        readonly aspect_ratio: {
+            readonly type: "string";
+            readonly description: "Output aspect ratio: 16:9, 9:16, 1:1, 4:3, 3:4, 21:9. Default: same as source.";
+        };
+        readonly resolution: {
+            readonly type: "string";
+            readonly description: "Output resolution: '480p' or '720p'. Default: '720p'.";
+        };
+    };
+    readonly required: readonly ["prompt", "source_videos"];
+};
+export interface VideoEditResult {
+    mediaUrls: string[];
+    model?: string;
+    durationMs?: number;
+}
+/** Deps injected by the host runtime for video editing. */
+export interface VideoEditToolDeps {
+    /**
+     * Edit a video via the configured backend (Seedance 2.0, etc.).
+     * The host handles URL resolution, model routing, and storage.
+     */
+    editVideo(params: {
+        prompt: string;
+        sourceVideos: string[];
+        referenceImages?: string[];
+        duration?: number;
+        aspectRatio?: string;
+        resolution?: string;
+    }): Promise<VideoEditResult>;
+}
+export declare function createVideoEditTool(deps: VideoEditToolDeps): PortableTool<VideoEditToolParams>;

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

@@ -0,0 +1,62 @@
+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/types/skills/tools/video-merge-tool.d.ts

@@ -0,0 +1,105 @@
+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/types/skills/tools/video-upscale-tool.d.ts

@@ -0,0 +1,45 @@
+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/types/skills/tools/web-fetch-tool.d.ts

@@ -0,0 +1,78 @@
+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>;