qlogicagent 0.3.0 → 0.5.0

package/dist/types/skills/tools/skill-list-tool.d.ts

@@ -1,33 +0,0 @@
-import type { PortableTool } from "../portable-tool.js";
-export declare const SKILL_LIST_TOOL_NAME: "skill_list";
-export interface SkillListToolParams {
-    category?: string;
-}
-export declare const SKILL_LIST_TOOL_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly category: {
-            readonly type: "string";
-            readonly description: "Filter skills by category (e.g. 'devops', 'mlops'). Omit to list all.";
-        };
-    };
-    readonly required: readonly [];
-};
-export interface SkillListItem {
-    name: string;
-    description: string;
-    version?: string;
-    category?: string;
-}
-export interface SkillListOutput {
-    skills: SkillListItem[];
-    categories: string[];
-}
-/**
- * Host-provided skill registry for listing.
- */
-export interface SkillListToolDeps {
-    /** List all available skills, optionally filtered by category. */
-    listSkills(category?: string): Promise<SkillListOutput>;
-}
-export declare function createSkillListTool(deps: SkillListToolDeps): PortableTool<SkillListToolParams>;

package/dist/types/skills/tools/skill-manage-tool.d.ts

@@ -1,73 +0,0 @@
-import type { PortableTool } from "../portable-tool.js";
-export declare const SKILL_MANAGE_TOOL_NAME: "skill_manage";
-export type SkillManageAction = "create" | "edit" | "patch" | "delete" | "write_file" | "remove_file";
-export interface SkillManageToolParams {
-    action: SkillManageAction;
-    name: string;
-    content?: string;
-    category?: string;
-    filePath?: string;
-    fileContent?: string;
-    oldString?: string;
-    newString?: string;
-}
-export declare const SKILL_MANAGE_TOOL_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly action: {
-            readonly type: "string";
-            readonly enum: readonly ["create", "edit", "patch", "delete", "write_file", "remove_file"];
-            readonly description: string;
-        };
-        readonly name: {
-            readonly type: "string";
-            readonly description: "Skill name (lowercase, max 64 chars, kebab-case: letters, digits, hyphens).";
-        };
-        readonly content: {
-            readonly type: "string";
-            readonly description: string;
-        };
-        readonly category: {
-            readonly type: "string";
-            readonly description: "Category/domain (e.g. 'devops', 'mlops'). Used by create to organize skills.";
-        };
-        readonly filePath: {
-            readonly type: "string";
-            readonly description: string;
-        };
-        readonly fileContent: {
-            readonly type: "string";
-            readonly description: "Content for write_file action. Max 1 MiB.";
-        };
-        readonly oldString: {
-            readonly type: "string";
-            readonly description: "Text to find for patch action (must match uniquely in SKILL.md).";
-        };
-        readonly newString: {
-            readonly type: "string";
-            readonly description: "Replacement text for patch action (can be empty to delete).";
-        };
-    };
-    readonly required: readonly ["action", "name"];
-};
-export interface SkillManageResult {
-    success: boolean;
-    message: string;
-    path?: string;
-}
-/**
- * Host-provided skill management backend.
- */
-export interface SkillManageToolDeps {
-    /**
-     * Execute a skill management action.
-     * The host handles file system operations, validation, and security scanning.
-     */
-    manageSkill(params: SkillManageToolParams): Promise<SkillManageResult>;
-    /**
-     * Validate skill name format.
-     * If not provided, tool uses built-in validation.
-     */
-    validateName?(name: string): string | null;
-}
-export declare function createSkillManageTool(deps: SkillManageToolDeps): PortableTool<SkillManageToolParams>;

package/dist/types/skills/tools/skill-view-tool.d.ts

@@ -1,37 +0,0 @@
-import type { PortableTool } from "../portable-tool.js";
-export declare const SKILL_VIEW_TOOL_NAME: "skill_view";
-export interface SkillViewToolParams {
-    name: string;
-    filePath?: string;
-}
-export declare const SKILL_VIEW_TOOL_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly name: {
-            readonly type: "string";
-            readonly description: "Skill name to view (e.g. 'code-review', 'deploy-ecs').";
-        };
-        readonly filePath: {
-            readonly type: "string";
-            readonly description: string;
-        };
-    };
-    readonly required: readonly ["name"];
-};
-export interface SkillViewOutput {
-    name: string;
-    content: string;
-    referenceFiles?: string[];
-    tags?: string[];
-}
-/**
- * Host-provided skill viewer.
- */
-export interface SkillViewToolDeps {
-    /**
-     * Read skill content. Returns the main SKILL.md or a specific file.
-     * Returns null if skill not found.
-     */
-    viewSkill(name: string, filePath?: string): Promise<SkillViewOutput | null>;
-}
-export declare function createSkillViewTool(deps: SkillViewToolDeps): PortableTool<SkillViewToolParams>;

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

@@ -1,49 +0,0 @@
-import type { PortableTool } from "../portable-tool.js";
-export declare const SLEEP_TOOL_NAME: "sleep";
-export interface SleepToolParams {
-    /** Duration to sleep in seconds (1–3600). */
-    duration: number;
-    /** Reason for sleeping — helps the runtime decide whether to interrupt. */
-    reason?: string;
-}
-export declare const SLEEP_TOOL_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly duration: {
-            readonly type: "number";
-            readonly description: "Duration to sleep in seconds (1–3600). Prefer short sleeps (10–60s) to stay responsive.";
-            readonly minimum: 1;
-            readonly maximum: 3600;
-        };
-        readonly reason: {
-            readonly type: "string";
-            readonly description: string;
-        };
-    };
-    readonly required: readonly ["duration"];
-};
-/** The result returned after a sleep completes or is interrupted. */
-export interface SleepResult {
-    /** Actual time slept in seconds (may be less if interrupted). */
-    sleptSeconds: number;
-    /** Whether the sleep was interrupted before completing. */
-    interrupted: boolean;
-    /** The event that caused the interruption (undefined if not interrupted). */
-    interruptReason?: string;
-}
-/**
- * Runtime dependencies injected by the host.
- *
- * The sleep mechanism is host-provided — the tool itself does NOT call
- * setTimeout. The host decides how to implement the wait (timer, event loop
- * integration, tick prompt scheduling, etc.).
- */
-export interface SleepToolDeps {
-    /**
-     * Perform the actual sleep. Must resolve after `durationMs` or when
-     * interrupted (whichever is first). The AbortSignal fires if the user
-     * or the system requests an interrupt.
-     */
-    sleep(durationMs: number, signal: AbortSignal): Promise<SleepResult>;
-}
-export declare function createSleepTool(deps: SleepToolDeps): PortableTool<SleepToolParams>;

package/dist/types/skills/tools/structured-output-tool.d.ts

@@ -1,116 +0,0 @@
-import type { PortableTool } from "../portable-tool.js";
-export declare const STRUCTURED_OUTPUT_TOOL_NAME: "structured_output";
-/** Maximum content size for structured output results. */
-export declare const STRUCTURED_OUTPUT_MAX_CHARS = 100000;
-export interface StructuredOutputToolParams {
-    /** The structured data to return. Must conform to the session's output schema. */
-    data: Record<string, unknown>;
-}
-/**
- * Base schema — accepts any object.
- * When used with createConfiguredStructuredOutputTool, the host overrides
- * this with the actual JSON Schema from `response_format.json_schema`.
- */
-export declare const STRUCTURED_OUTPUT_TOOL_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly data: {
-            readonly type: "object";
-            readonly description: string;
-            readonly additionalProperties: true;
-        };
-    };
-    readonly required: readonly ["data"];
-};
-/** Schema validation error detail. */
-export interface SchemaValidationError {
-    path: string;
-    message: string;
-    keyword?: string;
-}
-/** Result of structured output validation. */
-export interface StructuredOutputResult {
-    valid: boolean;
-    errors?: SchemaValidationError[];
-}
-/**
- * Whether the structured output tool should be enabled for this session.
- * CC equivalent: `isSyntheticOutputToolEnabled`.
- */
-export declare function isStructuredOutputEnabled(opts: {
-    isNonInteractiveSession: boolean;
-}): boolean;
-/**
- * Runtime dependencies injected by the host.
- *
- * The host provides:
- * 1. The JSON Schema to validate against (from session config)
- * 2. A validator function (host may use Ajv, Zod, or any validator)
- * 3. An output sink to deliver the validated data
- *
- * The tool is only available in non-interactive (SDK/API) sessions
- * where a `response_format.json_schema` has been specified.
- */
-export interface StructuredOutputToolDeps {
-    /**
-     * Get the JSON Schema that the output must conform to.
-     * Returns undefined if no schema is configured (tool should not be registered).
-     */
-    getOutputSchema(): Record<string, unknown> | undefined;
-    /**
-     * Validate data against the output schema.
-     * Returns { valid: true } or { valid: false, errors: [...] }.
-     */
-    validateOutput(data: Record<string, unknown>): StructuredOutputResult;
-    /**
-     * Deliver the validated output to the caller.
-     * Called only after successful validation.
-     */
-    deliverOutput(data: Record<string, unknown>): Promise<void>;
-}
-/**
- * Create the base structured output tool with DI-based validation.
- * This is the standard factory for runtime integration.
- */
-export declare function createStructuredOutputTool(deps: StructuredOutputToolDeps): PortableTool<StructuredOutputToolParams>;
-/**
- * Result of creating a configured structured output tool.
- * Success: { tool } — ready-to-use tool with compiled schema.
- * Failure: { error } — schema was invalid.
- */
-export type ConfiguredToolResult = {
-    tool: PortableTool<StructuredOutputToolParams>;
-} | {
-    error: string;
-};
-/**
- * Host-provided schema compilation interface.
- * Allows the host to use any validator (Ajv, Zod, custom).
- */
-export interface SchemaCompiler {
-    /**
-     * Validate that the schema itself is a valid JSON Schema.
-     * Returns null if valid, or an error message string if invalid.
-     */
-    validateSchema(schema: Record<string, unknown>): string | null;
-    /**
-     * Compile the schema into a reusable validator function.
-     * Returns a function that validates data and returns StructuredOutputResult.
-     */
-    compile(schema: Record<string, unknown>): (data: Record<string, unknown>) => StructuredOutputResult;
-}
-/**
- * Create a StructuredOutputTool configured with a specific JSON Schema.
- * Mirrors CC's `createSyntheticOutputTool(jsonSchema)`.
- *
- * Features:
- * - Validates the schema itself at creation time
- * - Compiles the validator for reuse (cached via WeakMap)
- * - Overrides the tool's `parameters` with the provided schema (dynamic input)
- * - Returns { tool } on success or { error } if schema is invalid
- *
- * @param jsonSchema  The JSON Schema to validate output against.
- * @param compiler    Schema compiler/validator provided by the host.
- * @param deliver     Output delivery function (called after successful validation).
- */
-export declare function createConfiguredStructuredOutputTool(jsonSchema: Record<string, unknown>, compiler: SchemaCompiler, deliver: (data: Record<string, unknown>) => Promise<void>): ConfiguredToolResult;

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

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

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

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

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

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