qlogicagent 0.2.1 → 0.4.0

package/dist/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/skills/tools/skill-view-tool.js

@@ -1,72 +0,0 @@
-// ============================================================
-// Skill View Tool — view full skill content.
-// Reference: hermes-agent-2026.4.30/tools/skills_tool.py (skill_view)
-// Category: skill
-// ============================================================
-export const SKILL_VIEW_TOOL_NAME = "skill_view";
-export const SKILL_VIEW_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        name: {
-            type: "string",
-            description: "Skill name to view (e.g. 'code-review', 'deploy-ecs').",
-        },
-        filePath: {
-            type: "string",
-            description: "Optional: view a specific file within the skill (e.g. 'references/api.md'). " +
-                "Omit to view the main SKILL.md.",
-        },
-    },
-    required: ["name"],
-};
-export function createSkillViewTool(deps) {
-    return {
-        name: SKILL_VIEW_TOOL_NAME,
-        label: "View Skill",
-        description: "View the full content of a skill (instructions, configuration, reference files). " +
-            "Use skill_list to discover available skills first.",
-        parameters: SKILL_VIEW_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            if (!params.name || params.name.trim().length === 0) {
-                return {
-                    content: [{ type: "text", text: "Error: skill name is required." }],
-                    details: { type: "skill_view", error: "empty_name" },
-                };
-            }
-            const result = await deps.viewSkill(params.name.trim(), params.filePath);
-            if (!result) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `Skill "${params.name}" not found. Use skill_list to see available skills.`,
-                        }],
-                    details: { type: "skill_view", error: "not_found", name: params.name },
-                };
-            }
-            const lines = [];
-            if (params.filePath) {
-                lines.push(`## ${result.name} / ${params.filePath}`);
-            }
-            else {
-                lines.push(`## Skill: ${result.name}`);
-                if (result.tags && result.tags.length > 0) {
-                    lines.push(`Tags: ${result.tags.join(", ")}`);
-                }
-                if (result.referenceFiles && result.referenceFiles.length > 0) {
-                    lines.push(`Reference files: ${result.referenceFiles.join(", ")}`);
-                }
-            }
-            lines.push("");
-            lines.push(result.content);
-            return {
-                content: [{ type: "text", text: lines.join("\n") }],
-                details: {
-                    type: "skill_view",
-                    name: result.name,
-                    filePath: params.filePath,
-                    referenceFiles: result.referenceFiles,
-                },
-            };
-        },
-    };
-}

package/dist/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/skills/tools/sleep-tool.js

@@ -1,81 +0,0 @@
-// ============================================================
-// Sleep Tool — lightweight wait with tick/interrupt support.
-// Reference: claude-code-haha/src/tools/SleepTool/prompt.ts
-// Category: autonomous / proactive mode
-// ============================================================
-export const SLEEP_TOOL_NAME = "sleep";
-export const SLEEP_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        duration: {
-            type: "number",
-            description: "Duration to sleep in seconds (1–3600). Prefer short sleeps (10–60s) to stay responsive.",
-            minimum: 1,
-            maximum: 3600,
-        },
-        reason: {
-            type: "string",
-            description: "Brief reason for sleeping. Examples: \"waiting for build to finish\", " +
-                "\"nothing to do\", \"user asked to rest\".",
-        },
-    },
-    required: ["duration"],
-};
-export function createSleepTool(deps) {
-    return {
-        name: SLEEP_TOOL_NAME,
-        label: "Sleep",
-        shouldDefer: true,
-        isConcurrencySafe: true,
-        isReadOnly: true,
-        searchHint: "wait sleep rest idle tick proactive",
-        description: [
-            "Wait for a specified duration. The user can interrupt the sleep at any time.",
-            "",
-            "Use this when:",
-            "• You have nothing useful to do right now",
-            "• You're waiting for an external process to complete",
-            "• The user tells you to sleep or rest",
-            "• You receive a <tick> check-in with no actionable work",
-            "",
-            "Prefer this over `exec(sleep ...)` — it doesn't hold a shell process.",
-            "You can call this concurrently with other tools — it won't interfere with them.",
-            "",
-            "Each wake-up costs an API call, but the prompt cache expires after 5 minutes " +
-                "of inactivity — balance accordingly.",
-        ].join("\n"),
-        parameters: SLEEP_TOOL_SCHEMA,
-        execute: async (_toolCallId, params, signal) => {
-            const durationSec = Math.max(1, Math.min(3600, Math.round(params.duration)));
-            const durationMs = durationSec * 1000;
-            // Create a child AbortController so we can forward the outer signal
-            const controller = new AbortController();
-            const onAbort = () => controller.abort();
-            signal?.addEventListener("abort", onAbort, { once: true });
-            // Handle pre-aborted signal
-            if (signal?.aborted)
-                controller.abort();
-            try {
-                const result = await deps.sleep(durationMs, controller.signal);
-                const lines = [];
-                if (result.interrupted) {
-                    lines.push(`Sleep interrupted after ${result.sleptSeconds}s.`);
-                    if (result.interruptReason) {
-                        lines.push(`Reason: ${result.interruptReason}`);
-                    }
-                    lines.push("Check for new messages or tasks.");
-                }
-                else {
-                    lines.push(`Slept for ${result.sleptSeconds}s. Waking up.`);
-                }
-                return {
-                    content: [{ type: "text", text: lines.join("\n") }],
-                    details: { ...result, requestedSeconds: durationSec },
-                };
-            }
-            finally {
-                signal?.removeEventListener("abort", onAbort);
-            }
-        },
-    };
-}

package/dist/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/skills/tools/structured-output-tool.js

@@ -1,176 +0,0 @@
-// ============================================================
-// Structured Output Tool — validated JSON schema output for
-// non-interactive (SDK/API) sessions.
-// Reference: claude-code-haha/src/tools/SyntheticOutputTool/SyntheticOutputTool.ts
-// Category: output / structured
-// ============================================================
-export const STRUCTURED_OUTPUT_TOOL_NAME = "structured_output";
-/** Maximum content size for structured output results. */
-export const STRUCTURED_OUTPUT_MAX_CHARS = 100_000;
-/**
- * Base schema — accepts any object.
- * When used with createConfiguredStructuredOutputTool, the host overrides
- * this with the actual JSON Schema from `response_format.json_schema`.
- */
-export const STRUCTURED_OUTPUT_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        data: {
-            type: "object",
-            description: "The structured JSON data to return as this turn's output. " +
-                "Must conform to the output schema specified for this session.",
-            additionalProperties: true,
-        },
-    },
-    required: ["data"],
-};
-/**
- * Whether the structured output tool should be enabled for this session.
- * CC equivalent: `isSyntheticOutputToolEnabled`.
- */
-export function isStructuredOutputEnabled(opts) {
-    return opts.isNonInteractiveSession;
-}
-/**
- * Create the base structured output tool with DI-based validation.
- * This is the standard factory for runtime integration.
- */
-export function createStructuredOutputTool(deps) {
-    return {
-        name: STRUCTURED_OUTPUT_TOOL_NAME,
-        label: "Structured Output",
-        shouldDefer: false,
-        isConcurrencySafe: true,
-        isReadOnly: true,
-        searchHint: "return the final response as structured JSON",
-        maxResultSizeChars: STRUCTURED_OUTPUT_MAX_CHARS,
-        description: [
-            "Return your final response as structured JSON data.",
-            "",
-            "Use this tool ONLY when the session requests structured output (via response_format).",
-            "You MUST call this tool exactly once at the end of your response to provide the structured output.",
-            "The data you provide must conform to the output JSON Schema specified for this session.",
-            "",
-            "Rules:",
-            "• Call this exactly once at the end of your turn to deliver results",
-            "• The data must be a valid JSON object matching the required schema",
-            "• If validation fails, you'll see the errors — fix your data and try again",
-            "• This is typically the last tool call in a turn",
-        ].join("\n"),
-        parameters: STRUCTURED_OUTPUT_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            const schema = deps.getOutputSchema();
-            if (!schema) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: "Error: No output schema configured for this session. " +
-                                "structured_output is only available when response_format.json_schema is specified.",
-                        }],
-                    details: { valid: false, error: "no_schema" },
-                };
-            }
-            const validation = deps.validateOutput(params.data);
-            if (!validation.valid) {
-                const errorLines = (validation.errors ?? []).map((e) => `  • ${e.path || "/"}: ${e.message}`);
-                return {
-                    content: [{
-                            type: "text",
-                            text: [
-                                "Output does not match required schema:",
-                                ...errorLines,
-                            ].join("\n"),
-                        }],
-                    details: { valid: false, errors: validation.errors },
-                };
-            }
-            // Validation passed — deliver the output
-            await deps.deliverOutput(params.data);
-            return {
-                content: [{ type: "text", text: "Structured output provided successfully." }],
-                details: { valid: true, structured_output: params.data },
-            };
-        },
-    };
-}
-/** WeakMap cache for compiled schema tools (mirrors CC's toolCache). */
-const configuredToolCache = new WeakMap();
-/**
- * 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 function createConfiguredStructuredOutputTool(jsonSchema, compiler, deliver) {
-    const cached = configuredToolCache.get(jsonSchema);
-    if (cached)
-        return cached;
-    const result = buildConfiguredTool(jsonSchema, compiler, deliver);
-    configuredToolCache.set(jsonSchema, result);
-    return result;
-}
-function buildConfiguredTool(jsonSchema, compiler, deliver) {
-    try {
-        // Step 1: Validate the schema itself
-        const schemaError = compiler.validateSchema(jsonSchema);
-        if (schemaError) {
-            return { error: `Invalid JSON Schema: ${schemaError}` };
-        }
-        // Step 2: Compile the validator
-        const validate = compiler.compile(jsonSchema);
-        // Step 3: Build the tool with dynamic input schema
-        const tool = {
-            name: STRUCTURED_OUTPUT_TOOL_NAME,
-            label: "Structured Output",
-            shouldDefer: false,
-            isConcurrencySafe: true,
-            isReadOnly: true,
-            searchHint: "return the final response as structured JSON",
-            maxResultSizeChars: STRUCTURED_OUTPUT_MAX_CHARS,
-            description: [
-                "Use this tool to return your final response in the requested structured format.",
-                "You MUST call this tool exactly once at the end of your response to provide the structured output.",
-            ].join(" "),
-            // Dynamic: override with the actual JSON Schema so LLM gets type guidance
-            parameters: {
-                type: "object",
-                properties: {
-                    data: jsonSchema,
-                },
-                required: ["data"],
-            },
-            execute: async (_toolCallId, params) => {
-                const validation = validate(params.data);
-                if (!validation.valid) {
-                    const errors = (validation.errors ?? [])
-                        .map((e) => `${e.path || "root"}: ${e.message}`)
-                        .join(", ");
-                    return {
-                        content: [{
-                                type: "text",
-                                text: `Output does not match required schema: ${errors}`,
-                            }],
-                        details: { valid: false, errors: validation.errors },
-                    };
-                }
-                await deliver(params.data);
-                return {
-                    content: [{ type: "text", text: "Structured output provided successfully." }],
-                    details: { valid: true, structured_output: params.data },
-                };
-            },
-        };
-        return { tool };
-    }
-    catch (e) {
-        return { error: e instanceof Error ? e.message : String(e) };
-    }
-}

package/dist/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>;