qlogicagent 2.13.3 → 2.13.5

package/dist/skills/tools/ask-user-tool.d.ts

@@ -0,0 +1,80 @@
+import type { PortableTool } from "../portable-tool.js";
+export declare const ASK_USER_TOOL_NAME: "ask_user";
+export interface AskUserOption {
+    label: string;
+    description?: string;
+}
+export interface AskUserQuestion {
+    question: string;
+    header: string;
+    options?: AskUserOption[];
+    multiSelect?: boolean;
+}
+export interface AskUserToolParams {
+    questions: AskUserQuestion[];
+}
+export declare const ASK_USER_TOOL_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly questions: {
+            readonly type: "array";
+            readonly minItems: 1;
+            readonly maxItems: 4;
+            readonly description: "1-4 clarifying questions to ask the user.";
+            readonly items: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly question: {
+                        readonly type: "string";
+                        readonly description: "The question text. Should end with '?'.";
+                    };
+                    readonly header: {
+                        readonly type: "string";
+                        readonly description: "Short identifier/tag for this question (max 50 chars).";
+                    };
+                    readonly options: {
+                        readonly type: "array";
+                        readonly description: "2-4 options for the user to choose from. Omit for free text.";
+                        readonly items: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly label: {
+                                    readonly type: "string";
+                                    readonly description: "Display label (1-5 words).";
+                                };
+                                readonly description: {
+                                    readonly type: "string";
+                                    readonly description: "Brief explanation of this option.";
+                                };
+                            };
+                            readonly required: readonly ["label"];
+                        };
+                    };
+                    readonly multiSelect: {
+                        readonly type: "boolean";
+                        readonly description: "Allow selecting multiple options (default: false).";
+                    };
+                };
+                readonly required: readonly ["question", "header"];
+            };
+        };
+    };
+    readonly required: readonly ["questions"];
+};
+export interface AskUserAnswer {
+    question: string;
+    answer: string;
+}
+/**
+ * Host-provided user interaction backend.
+ * The host renders the questions in the UI and collects answers.
+ */
+export interface AskUserToolDeps {
+    /**
+     * Present questions to the user and collect answers.
+     * Returns a map of question text → answer text.
+     * If the user declines, returns null.
+     */
+    askUser(questions: AskUserQuestion[]): Promise<Record<string, string> | null>;
+}
+export declare function createAskUserTool(deps: AskUserToolDeps): PortableTool<AskUserToolParams>;

package/dist/skills/tools/ask-user-tool.js

@@ -0,0 +1,121 @@
+// ============================================================
+// Ask User Tool — ask the user clarifying questions.
+// Reference: claude-code-haha/src/tools/AskUserQuestionTool/AskUserQuestionTool.tsx
+// Category: interaction
+// ============================================================
+export const ASK_USER_TOOL_NAME = "ask_user";
+export const ASK_USER_TOOL_SCHEMA = {
+    type: "object",
+    properties: {
+        questions: {
+            type: "array",
+            minItems: 1,
+            maxItems: 4,
+            description: "1-4 clarifying questions to ask the user.",
+            items: {
+                type: "object",
+                properties: {
+                    question: {
+                        type: "string",
+                        description: "The question text. Should end with '?'.",
+                    },
+                    header: {
+                        type: "string",
+                        description: "Short identifier/tag for this question (max 50 chars).",
+                    },
+                    options: {
+                        type: "array",
+                        description: "2-4 options for the user to choose from. Omit for free text.",
+                        items: {
+                            type: "object",
+                            properties: {
+                                label: {
+                                    type: "string",
+                                    description: "Display label (1-5 words).",
+                                },
+                                description: {
+                                    type: "string",
+                                    description: "Brief explanation of this option.",
+                                },
+                            },
+                            required: ["label"],
+                        },
+                    },
+                    multiSelect: {
+                        type: "boolean",
+                        description: "Allow selecting multiple options (default: false).",
+                    },
+                },
+                required: ["question", "header"],
+            },
+        },
+    },
+    required: ["questions"],
+};
+export function createAskUserTool(deps) {
+    return {
+        name: ASK_USER_TOOL_NAME,
+        label: "Ask User",
+        description: "Ask the user clarifying questions when you need more information to proceed. " +
+            "Supports free text questions and multiple-choice options. " +
+            "Use this when the user's intent is ambiguous or you need confirmation.",
+        parameters: ASK_USER_TOOL_SCHEMA,
+        execute: async (_toolCallId, params) => {
+            // Validate questions count
+            if (!params.questions || params.questions.length === 0) {
+                return {
+                    content: [{ type: "text", text: "Error: at least one question is required." }],
+                    details: { type: "ask_user", error: "no_questions" },
+                };
+            }
+            if (params.questions.length > 4) {
+                return {
+                    content: [{ type: "text", text: "Error: maximum 4 questions allowed." }],
+                    details: { type: "ask_user", error: "too_many_questions" },
+                };
+            }
+            // Validate unique question texts
+            const questionTexts = params.questions.map((q) => q.question);
+            if (new Set(questionTexts).size !== questionTexts.length) {
+                return {
+                    content: [{ type: "text", text: "Error: all questions must have unique text." }],
+                    details: { type: "ask_user", error: "duplicate_questions" },
+                };
+            }
+            // Validate options count and label uniqueness per question
+            for (const q of params.questions) {
+                if (q.options && (q.options.length < 2 || q.options.length > 4)) {
+                    return {
+                        content: [{ type: "text", text: `Error: question "${q.header}" must have 2-4 options (got ${q.options.length}).` }],
+                        details: { type: "ask_user", error: "invalid_option_count" },
+                    };
+                }
+                if (q.options) {
+                    const labels = q.options.map((o) => o.label);
+                    if (new Set(labels).size !== labels.length) {
+                        return {
+                            content: [{ type: "text", text: `Error: question "${q.header}" has duplicate option labels.` }],
+                            details: { type: "ask_user", error: "duplicate_option_labels" },
+                        };
+                    }
+                }
+            }
+            const answers = await deps.askUser(params.questions);
+            if (answers === null) {
+                return {
+                    content: [{ type: "text", text: "User declined to answer questions." }],
+                    details: { type: "ask_user", declined: true },
+                };
+            }
+            const lines = ["User answered:"];
+            for (const q of params.questions) {
+                const answer = answers[q.question] ?? "(no answer)";
+                lines.push(`- ${q.header}: ${answer}`);
+            }
+            return {
+                content: [{ type: "text", text: lines.join("\n") }],
+                details: { type: "ask_user", answers, questionCount: params.questions.length },
+            };
+        },
+    };
+}

package/dist/skills/tools/brief-tool.d.ts

@@ -0,0 +1,74 @@
+import type { PortableTool } from "../portable-tool.js";
+export declare const BRIEF_TOOL_NAME: "send_user_message";
+export type BriefMessageStatus = "normal" | "proactive";
+export interface BriefAttachment {
+    /** Absolute or workspace-relative path */
+    path: string;
+    /** Size in bytes (filled by host) */
+    size?: number;
+    /** Whether the file is an image */
+    isImage?: boolean;
+    /** Upload UUID (host may upload for web preview) */
+    fileUuid?: string;
+}
+export interface BriefToolParams {
+    /** Markdown-formatted message to display to the user */
+    message: string;
+    /** File attachments to include with the message */
+    attachments?: string[];
+    /** Message status — 'proactive' for unsolicited updates */
+    status?: BriefMessageStatus;
+}
+export declare const BRIEF_TOOL_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly message: {
+            readonly type: "string";
+            readonly description: string;
+            readonly minLength: 1;
+        };
+        readonly attachments: {
+            readonly type: "array";
+            readonly description: "Optional file paths to attach (images, documents, etc.).";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly maxItems: 10;
+        };
+        readonly status: {
+            readonly type: "string";
+            readonly enum: readonly ["normal", "proactive"];
+            readonly description: string;
+        };
+    };
+    readonly required: readonly ["message"];
+};
+export interface BriefDeliveryResult {
+    delivered: boolean;
+    attachments?: BriefAttachment[];
+    sentAt?: string;
+    error?: string;
+}
+/**
+ * Host-provided message delivery backend.
+ */
+export interface BriefToolDeps {
+    /** Deliver the message to the user's UI */
+    deliverMessage(params: {
+        message: string;
+        attachments?: string[];
+        status: BriefMessageStatus;
+    }): Promise<BriefDeliveryResult>;
+    /** Validate and resolve attachment paths. Returns resolved attachments or error. */
+    resolveAttachments?(paths: string[]): Promise<BriefAttachment[] | {
+        error: string;
+    }>;
+}
+/** Check if brief mode is active (host determines this) */
+export interface BriefModeConfig {
+    /** Whether the agent is in brief/chat mode */
+    isBriefMode: boolean;
+    /** Whether the user opted in via UI/CLI */
+    userOptIn?: boolean;
+}
+export declare function createBriefTool(deps: BriefToolDeps): PortableTool<BriefToolParams>;

package/dist/skills/tools/brief-tool.js

@@ -0,0 +1,95 @@
+// ============================================================
+// Brief Tool — "SendUserMessage" equivalent from Claude Code.
+//
+// In brief/chat mode, agent output is not directly visible to
+// the user. Only messages sent through this tool are displayed.
+// This enables clean separation of internal reasoning vs
+// user-facing communication.
+//
+// Reference: claude-code-haha/src/tools/BriefTool/BriefTool.ts
+// Category: interaction
+// ============================================================
+export const BRIEF_TOOL_NAME = "send_user_message";
+export const BRIEF_TOOL_SCHEMA = {
+    type: "object",
+    properties: {
+        message: {
+            type: "string",
+            description: "The message to send to the user. Supports Markdown formatting. " +
+                "This is the ONLY way to communicate with the user in brief/chat mode.",
+            minLength: 1,
+        },
+        attachments: {
+            type: "array",
+            description: "Optional file paths to attach (images, documents, etc.).",
+            items: { type: "string" },
+            maxItems: 10,
+        },
+        status: {
+            type: "string",
+            enum: ["normal", "proactive"],
+            description: "Message status. Use 'proactive' when providing unsolicited information " +
+                "(e.g., monitoring alerts, task completion notifications).",
+        },
+    },
+    required: ["message"],
+};
+export function createBriefTool(deps) {
+    return {
+        name: BRIEF_TOOL_NAME,
+        label: "Send User Message",
+        description: "Send a message to the user. In brief/chat mode this is the ONLY way " +
+            "your messages are visible. Supports Markdown and file attachments. " +
+            "Use 'proactive' status for unsolicited updates (monitoring alerts, " +
+            "task completions). Keep messages concise and useful.",
+        parameters: BRIEF_TOOL_SCHEMA,
+        isConcurrencySafe: true,
+        isReadOnly: true,
+        searchHint: "send message user brief chat communicate display output",
+        execute: async (_toolCallId, params) => {
+            if (!params.message || params.message.trim().length === 0) {
+                return {
+                    content: [{ type: "text", text: "Error: message cannot be empty." }],
+                    details: { type: "brief", error: "empty_message" },
+                };
+            }
+            // Resolve attachments if provided
+            let resolvedAttachments;
+            if (params.attachments && params.attachments.length > 0) {
+                if (deps.resolveAttachments) {
+                    const resolved = await deps.resolveAttachments(params.attachments);
+                    if ("error" in resolved) {
+                        return {
+                            content: [{ type: "text", text: `Attachment error: ${resolved.error}` }],
+                            details: { type: "brief", error: "attachment_resolution_failed" },
+                        };
+                    }
+                    resolvedAttachments = resolved;
+                }
+            }
+            const status = params.status || "normal";
+            const result = await deps.deliverMessage({
+                message: params.message.trim(),
+                attachments: params.attachments,
+                status,
+            });
+            if (!result.delivered) {
+                return {
+                    content: [{ type: "text", text: `Message delivery failed: ${result.error || "unknown error"}` }],
+                    details: { type: "brief", delivered: false, error: result.error },
+                };
+            }
+            // Minimal confirmation — avoids re-echoing message in context (saves tokens)
+            return {
+                content: [{ type: "text", text: "Message delivered to user." }],
+                details: {
+                    type: "brief",
+                    delivered: true,
+                    status,
+                    hasAttachments: (resolvedAttachments?.length ?? 0) > 0,
+                    sentAt: result.sentAt,
+                },
+            };
+        },
+    };
+}

package/dist/skills/tools/browser-tool.d.ts

@@ -0,0 +1,114 @@
+import type { PortableTool } from "../portable-tool.js";
+export declare const BROWSER_TOOL_NAME: "browser";
+export type BrowserAction = "navigate" | "click" | "type" | "scroll" | "snapshot" | "screenshot" | "console" | "cdp";
+export interface BrowserToolParams {
+    /** Browser action to perform */
+    action: BrowserAction;
+    /** URL for navigate action */
+    url?: string;
+    /** Element reference (e.g. "@e5") for click/type actions */
+    ref?: string;
+    /** Text to type */
+    text?: string;
+    /** Scroll direction */
+    direction?: "up" | "down" | "left" | "right";
+    /** CDP method name for raw cdp action */
+    method?: string;
+    /** CDP params object */
+    params?: Record<string, unknown>;
+    /** JavaScript expression for console eval */
+    expression?: string;
+    /** Whether to include full accessibility tree */
+    full?: boolean;
+}
+export declare const BROWSER_TOOL_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly action: {
+            readonly type: "string";
+            readonly enum: readonly ["navigate", "click", "type", "scroll", "snapshot", "screenshot", "console", "cdp"];
+            readonly description: string;
+        };
+        readonly url: {
+            readonly type: "string";
+            readonly description: "URL to navigate to. Required for 'navigate' action.";
+        };
+        readonly ref: {
+            readonly type: "string";
+            readonly description: "Element reference like \"@e5\" from a previous snapshot. Required for click/type.";
+        };
+        readonly text: {
+            readonly type: "string";
+            readonly description: "Text to type into the referenced element. Required for 'type' action.";
+        };
+        readonly direction: {
+            readonly type: "string";
+            readonly enum: readonly ["up", "down", "left", "right"];
+            readonly description: "Scroll direction. Required for 'scroll' action.";
+        };
+        readonly method: {
+            readonly type: "string";
+            readonly description: "CDP method name (e.g. 'Page.reload'). Required for 'cdp' action.";
+        };
+        readonly params: {
+            readonly type: "object";
+            readonly description: "Parameters for the CDP method. Optional for 'cdp' action.";
+        };
+        readonly expression: {
+            readonly type: "string";
+            readonly description: "JavaScript expression to evaluate. Used with 'console' action.";
+        };
+        readonly full: {
+            readonly type: "boolean";
+            readonly description: "Include full accessibility tree (default: compact). Used with 'snapshot'.";
+        };
+    };
+    readonly required: readonly ["action"];
+};
+export interface BrowserSnapshot {
+    elements: Array<{
+        ref: string;
+        role: string;
+        name: string;
+        text?: string;
+    }>;
+    url: string;
+    title: string;
+}
+export interface BrowserScreenshot {
+    base64: string;
+    mimeType: string;
+    width: number;
+    height: number;
+}
+/**
+ * Host-provided browser automation backend.
+ * The host manages Chrome/Chromium lifecycle and CDP connections.
+ */
+export interface BrowserToolDeps {
+    navigate(url: string): Promise<{
+        snapshot: BrowserSnapshot;
+    }>;
+    click(ref: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    type(ref: string, text: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    scroll(direction: "up" | "down" | "left" | "right"): Promise<{
+        success: boolean;
+    }>;
+    snapshot(full?: boolean): Promise<BrowserSnapshot>;
+    screenshot(): Promise<BrowserScreenshot>;
+    consoleEval(expression?: string): Promise<{
+        result?: string;
+        messages?: string[];
+        errors?: string[];
+    }>;
+    cdp(method: string, params?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /** Validate URL safety (SSRF prevention). Returns error message if blocked, null if safe. */
+    validateUrl(url: string): string | null;
+}
+export declare function createBrowserTool(deps: BrowserToolDeps): PortableTool<BrowserToolParams>;

package/dist/skills/tools/browser-tool.js

@@ -0,0 +1,160 @@
+// ============================================================
+// Browser Tool — CDP-based browser automation.
+// Reference: hermes-agent-main/tools/browser_tool.py
+//            hermes-agent-main/tools/browser_cdp_tool.py
+// Category: web
+// ============================================================
+export const BROWSER_TOOL_NAME = "browser";
+export const BROWSER_TOOL_SCHEMA = {
+    type: "object",
+    properties: {
+        action: {
+            type: "string",
+            enum: ["navigate", "click", "type", "scroll", "snapshot", "screenshot", "console", "cdp"],
+            description: "Browser action: navigate (go to URL), click (element by ref), type (text into element), " +
+                "scroll (direction), snapshot (accessibility tree), screenshot (visual capture), " +
+                "console (eval JS / read logs), cdp (raw CDP command).",
+        },
+        url: {
+            type: "string",
+            description: "URL to navigate to. Required for 'navigate' action.",
+        },
+        ref: {
+            type: "string",
+            description: 'Element reference like "@e5" from a previous snapshot. Required for click/type.',
+        },
+        text: {
+            type: "string",
+            description: "Text to type into the referenced element. Required for 'type' action.",
+        },
+        direction: {
+            type: "string",
+            enum: ["up", "down", "left", "right"],
+            description: "Scroll direction. Required for 'scroll' action.",
+        },
+        method: {
+            type: "string",
+            description: "CDP method name (e.g. 'Page.reload'). Required for 'cdp' action.",
+        },
+        params: {
+            type: "object",
+            description: "Parameters for the CDP method. Optional for 'cdp' action.",
+        },
+        expression: {
+            type: "string",
+            description: "JavaScript expression to evaluate. Used with 'console' action.",
+        },
+        full: {
+            type: "boolean",
+            description: "Include full accessibility tree (default: compact). Used with 'snapshot'.",
+        },
+    },
+    required: ["action"],
+};
+export function createBrowserTool(deps) {
+    return {
+        name: BROWSER_TOOL_NAME,
+        label: "Browser",
+        description: "Control a headless browser via Chrome DevTools Protocol. " +
+            "Actions: navigate (URL), click/type (element refs from snapshot), " +
+            "scroll, snapshot (accessibility tree), screenshot (visual), " +
+            "console (JS eval/logs), cdp (raw CDP commands). " +
+            "Use snapshot to get element refs before click/type.",
+        parameters: BROWSER_TOOL_SCHEMA,
+        execute: async (_toolCallId, params) => {
+            switch (params.action) {
+                case "navigate": {
+                    if (!params.url) {
+                        return { content: [{ type: "text", text: "Error: url is required for navigate action." }], details: { type: "browser", error: "missing_url" } };
+                    }
+                    const blocked = deps.validateUrl(params.url);
+                    if (blocked) {
+                        return { content: [{ type: "text", text: `Blocked: ${blocked}` }], details: { type: "browser", error: "url_blocked" } };
+                    }
+                    const nav = await deps.navigate(params.url);
+                    const lines = [`Navigated to: ${nav.snapshot.url}`, `Title: ${nav.snapshot.title}`, "", `Elements: ${nav.snapshot.elements.length}`];
+                    if (nav.snapshot.elements.length <= 30) {
+                        for (const e of nav.snapshot.elements) {
+                            lines.push(`  ${e.ref} [${e.role}] ${e.name}${e.text ? `: "${e.text}"` : ""}`);
+                        }
+                    }
+                    else {
+                        lines.push("(use snapshot action for full element list)");
+                    }
+                    return { content: [{ type: "text", text: lines.join("\n") }], details: { type: "browser", action: "navigate", url: params.url } };
+                }
+                case "click": {
+                    if (!params.ref) {
+                        return { content: [{ type: "text", text: "Error: ref is required for click (e.g. '@e5')." }], details: { type: "browser", error: "missing_ref" } };
+                    }
+                    const click = await deps.click(params.ref);
+                    if (!click.success) {
+                        return { content: [{ type: "text", text: `Click failed: ${click.error || "unknown"}` }], details: { type: "browser", error: "click_failed" } };
+                    }
+                    return { content: [{ type: "text", text: `Clicked ${params.ref}` }], details: { type: "browser", action: "click", ref: params.ref } };
+                }
+                case "type": {
+                    if (!params.ref || !params.text) {
+                        return { content: [{ type: "text", text: "Error: ref and text are required for type action." }], details: { type: "browser", error: "missing_params" } };
+                    }
+                    const typed = await deps.type(params.ref, params.text);
+                    if (!typed.success) {
+                        return { content: [{ type: "text", text: `Type failed: ${typed.error || "unknown"}` }], details: { type: "browser", error: "type_failed" } };
+                    }
+                    return { content: [{ type: "text", text: `Typed "${params.text}" into ${params.ref}` }], details: { type: "browser", action: "type", ref: params.ref } };
+                }
+                case "scroll": {
+                    if (!params.direction) {
+                        return { content: [{ type: "text", text: "Error: direction is required for scroll." }], details: { type: "browser", error: "missing_direction" } };
+                    }
+                    await deps.scroll(params.direction);
+                    return { content: [{ type: "text", text: `Scrolled ${params.direction}` }], details: { type: "browser", action: "scroll", direction: params.direction } };
+                }
+                case "snapshot": {
+                    const snap = await deps.snapshot(params.full);
+                    const lines = [`URL: ${snap.url}`, `Title: ${snap.title}`, "", `Accessibility tree (${snap.elements.length} elements):`, ""];
+                    for (const e of snap.elements) {
+                        lines.push(`${e.ref} [${e.role}] ${e.name}${e.text ? ` — "${e.text}"` : ""}`);
+                    }
+                    return { content: [{ type: "text", text: lines.join("\n") }], details: { type: "browser", action: "snapshot", elementCount: snap.elements.length } };
+                }
+                case "screenshot": {
+                    const shot = await deps.screenshot();
+                    return {
+                        content: [{ type: "image", data: shot.base64, mimeType: shot.mimeType }],
+                        details: { type: "browser", action: "screenshot", width: shot.width, height: shot.height },
+                    };
+                }
+                case "console": {
+                    const c = await deps.consoleEval(params.expression);
+                    const lines = [];
+                    if (c.result !== undefined)
+                        lines.push(`Result: ${c.result}`);
+                    if (c.messages?.length) {
+                        lines.push("Console messages:");
+                        c.messages.forEach((m) => lines.push(`  ${m}`));
+                    }
+                    if (c.errors?.length) {
+                        lines.push("JS errors:");
+                        c.errors.forEach((e) => lines.push(`  ${e}`));
+                    }
+                    return { content: [{ type: "text", text: lines.join("\n") || "(no output)" }], details: { type: "browser", action: "console" } };
+                }
+                case "cdp": {
+                    if (!params.method) {
+                        return { content: [{ type: "text", text: "Error: method is required for cdp action." }], details: { type: "browser", error: "missing_method" } };
+                    }
+                    const result = await deps.cdp(params.method, params.params);
+                    // Plain-text summary for LLM (avoid raw JSON blob); full result in details
+                    const keys = result && typeof result === "object" ? Object.keys(result) : [];
+                    const summary = keys.length > 0
+                        ? `CDP ${params.method} succeeded. Response keys: ${keys.join(", ")}`
+                        : `CDP ${params.method} succeeded.`;
+                    return { content: [{ type: "text", text: summary }], details: { type: "browser", action: "cdp", method: params.method, result } };
+                }
+                default:
+                    return { content: [{ type: "text", text: `Error: unknown action "${params.action}".` }], details: { type: "browser", error: "unknown_action" } };
+            }
+        },
+    };
+}