@massa-ai/core 1.2.1

package/dist/tools/delete_memory.js

@@ -0,0 +1,51 @@
+/**
+ * Delete Memory Tool
+ *
+ * Thin MCP tool layer — delegates to MemoryController.
+ * Hard-deletes the memory and severs its graph edges. Soft-delete is a
+ * Phase 1 concern (needs a deleted_at column + recall filtering).
+ */
+import { logger } from "@massa-ai/shared";
+import { MemoryController } from "../controllers/memory-controller.js";
+import { serializeToolResponse } from "./serialize.js";
+export class DeleteMemoryTool {
+    name = "delete_memory";
+    description = "Delete a memory by id (hard delete). Also removes its graph edges.";
+    inputSchema = {
+        type: "object",
+        properties: {
+            id: { type: "string", description: "ID of the memory to delete" },
+            format: {
+                type: "string",
+                enum: ["json", "toon"],
+                description: "Output format (json or toon)",
+                default: "toon",
+            },
+            fields: {
+                type: "array",
+                items: { type: "string" },
+                description: "Projection — keep only these keys (dotted paths supported, e.g. ['nodes.symbol']). Absent/empty → full data.",
+            },
+        },
+        required: ["id"],
+    };
+    controller;
+    constructor() {
+        this.controller = MemoryController.getInstance();
+    }
+    async handle(params) {
+        const { id, format = "toon", fields } = params;
+        try {
+            const result = await this.controller.delete(id);
+            return serializeToolResponse(result, { format, fields });
+        }
+        catch (error) {
+            logger.error("Failed to delete memory", error, { id });
+            return {
+                success: false,
+                error: `Failed to delete memory: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+}
+//# sourceMappingURL=delete_memory.js.map

package/dist/tools/delete_memory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete_memory.js","sourceRoot":"","sources":["../../src/tools/delete_memory.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC1C,OAAO,EAAE,gBAAgB,EAAE,MAAM,qCAAqC,CAAC;AACvE,OAAO,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAQvD,MAAM,OAAO,gBAAgB;IAC3B,IAAI,GAAG,eAAe,CAAC;IACvB,WAAW,GACT,oEAAoE,CAAC;IACvE,WAAW,GAAG;QACZ,IAAI,EAAE,QAAQ;QACd,UAAU,EAAE;YACV,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,4BAA4B,EAAE;YACjE,MAAM,EAAE;gBACN,IAAI,EAAE,QAAQ;gBACd,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC;gBACtB,WAAW,EAAE,8BAA8B;gBAC3C,OAAO,EAAE,MAAM;aAChB;YACD,MAAM,EAAE;gBACN,IAAI,EAAE,OAAO;gBACb,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;gBACzB,WAAW,EACT,8GAA8G;aACjH;SACF;QACD,QAAQ,EAAE,CAAC,IAAI,CAAC;KACjB,CAAC;IAEM,UAAU,CAAmB;IAErC;QACE,IAAI,CAAC,UAAU,GAAG,gBAAgB,CAAC,WAAW,EAAE,CAAC;IACnD,CAAC;IAED,KAAK,CAAC,MAAM,CAAC,MAAe;QAC1B,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,GAAG,MAA4B,CAAC;QAErE,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;YAEhD,OAAO,qBAAqB,CAAC,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;QAC3D,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,KAAK,CAAC,yBAAyB,EAAE,KAAc,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;YAChE,OAAO;gBACL,OAAO,EAAE,KAAK;gBACd,KAAK,EAAE,4BAA4B,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE;aAC5F,CAAC;QACJ,CAAC;IACH,CAAC;CACF"}

package/dist/tools/enum-validation.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Shared enum/finite-set validation for tool handlers.
+ *
+ * Replaces silent-fallback `default:` branches with a teaching error that
+ * lists the valid values, so clients learn the contract instead of silently
+ * receiving an empty or wrong-shaped response.
+ *
+ * Precedent: `get_analytics.ts:109-114` returned `{success:false, error}` on
+ * an unknown `type`. This module extends that pattern to every tool handler
+ * with an enum/finite-set param and standardizes the error shape as a throw
+ * (not a return) so the MCP/HTTP transport can map it to a 400.
+ */
+/**
+ * Error thrown by tool handlers when a user-supplied param is invalid.
+ *
+ * `statusCode` defaults to 400 (bad request). The MCP layer maps this to
+ * `isError: true`; the HTTP layer maps it to the matching HTTP status.
+ */
+export declare class ToolError extends Error {
+    readonly statusCode: number;
+    constructor(message: string, statusCode?: number);
+}
+/**
+ * Validate that `value` is a string member of the finite set `validValues`.
+ *
+ * On success, returns `value` narrowed to `T`. On failure, throws a
+ * `ToolError` whose message lists every valid value, so the caller can surface
+ * the teaching error to the agent/client without a separate lookup.
+ *
+ * @example
+ *   const scope = validateEnum("scope", p.scope, ["unstaged","staged","committed","all"] as const);
+ *
+ * Throws `ToolError("Invalid <paramName> value: <received>. Valid values: <a, b, c>.")`
+ * when `value` is not a string or not a member of `validValues`.
+ */
+export declare function validateEnum<T extends string>(paramName: string, value: unknown, validValues: readonly T[]): T;
+//# sourceMappingURL=enum-validation.d.ts.map

package/dist/tools/enum-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enum-validation.d.ts","sourceRoot":"","sources":["../../src/tools/enum-validation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;;;;GAKG;AACH,qBAAa,SAAU,SAAQ,KAAK;IAClC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;gBAEhB,OAAO,EAAE,MAAM,EAAE,UAAU,GAAE,MAAY;CAKtD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,MAAM,EAC3C,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,OAAO,EACd,WAAW,EAAE,SAAS,CAAC,EAAE,GACxB,CAAC,CAOH"}

package/dist/tools/enum-validation.js

@@ -0,0 +1,46 @@
+/**
+ * Shared enum/finite-set validation for tool handlers.
+ *
+ * Replaces silent-fallback `default:` branches with a teaching error that
+ * lists the valid values, so clients learn the contract instead of silently
+ * receiving an empty or wrong-shaped response.
+ *
+ * Precedent: `get_analytics.ts:109-114` returned `{success:false, error}` on
+ * an unknown `type`. This module extends that pattern to every tool handler
+ * with an enum/finite-set param and standardizes the error shape as a throw
+ * (not a return) so the MCP/HTTP transport can map it to a 400.
+ */
+/**
+ * Error thrown by tool handlers when a user-supplied param is invalid.
+ *
+ * `statusCode` defaults to 400 (bad request). The MCP layer maps this to
+ * `isError: true`; the HTTP layer maps it to the matching HTTP status.
+ */
+export class ToolError extends Error {
+    statusCode;
+    constructor(message, statusCode = 400) {
+        super(message);
+        this.name = "ToolError";
+        this.statusCode = statusCode;
+    }
+}
+/**
+ * Validate that `value` is a string member of the finite set `validValues`.
+ *
+ * On success, returns `value` narrowed to `T`. On failure, throws a
+ * `ToolError` whose message lists every valid value, so the caller can surface
+ * the teaching error to the agent/client without a separate lookup.
+ *
+ * @example
+ *   const scope = validateEnum("scope", p.scope, ["unstaged","staged","committed","all"] as const);
+ *
+ * Throws `ToolError("Invalid <paramName> value: <received>. Valid values: <a, b, c>.")`
+ * when `value` is not a string or not a member of `validValues`.
+ */
+export function validateEnum(paramName, value, validValues) {
+    if (typeof value !== "string" || !validValues.includes(value)) {
+        throw new ToolError(`Invalid ${paramName} value: ${String(value)}. Valid values: ${validValues.join(", ")}.`);
+    }
+    return value;
+}
+//# sourceMappingURL=enum-validation.js.map

package/dist/tools/enum-validation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enum-validation.js","sourceRoot":"","sources":["../../src/tools/enum-validation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;;;;GAKG;AACH,MAAM,OAAO,SAAU,SAAQ,KAAK;IACzB,UAAU,CAAS;IAE5B,YAAY,OAAe,EAAE,aAAqB,GAAG;QACnD,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,WAAW,CAAC;QACxB,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;IAC/B,CAAC;CACF;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,YAAY,CAC1B,SAAiB,EACjB,KAAc,EACd,WAAyB;IAEzB,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,KAAU,CAAC,EAAE,CAAC;QACnE,MAAM,IAAI,SAAS,CACjB,WAAW,SAAS,WAAW,MAAM,CAAC,KAAK,CAAC,mBAAmB,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CACzF,CAAC;IACJ,CAAC;IACD,OAAO,KAAU,CAAC;AACpB,CAAC"}

package/dist/tools/execute.d.ts

@@ -0,0 +1,57 @@
+/**
+ * execute tool (ctx_execute) — run code in a detected runtime.
+ *
+ * Thin MCP handler: schema + delegation to the ExecutorController. The
+ * controller owns the PolyglotExecutor instance and applies the intent
+ * progressive-disclosure pass on large outputs.
+ */
+import type { ToolResponse, IToolHandler } from "@massa-ai/shared";
+import type { Language } from "../services/executor/runtime.js";
+export interface ExecuteParams {
+    language: Language;
+    code: string;
+    timeout?: number;
+    background?: boolean;
+    cwd?: string;
+    intent?: string;
+}
+export declare class ExecuteTool implements IToolHandler {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            language: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            code: {
+                type: string;
+                description: string;
+            };
+            timeout: {
+                type: string;
+                description: string;
+            };
+            background: {
+                type: string;
+                description: string;
+                default: boolean;
+            };
+            cwd: {
+                type: string;
+                description: string;
+            };
+            intent: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    private run;
+    constructor(run: (params: ExecuteParams) => Promise<ToolResponse>);
+    handle(params: unknown): Promise<ToolResponse>;
+}
+//# sourceMappingURL=execute.d.ts.map

package/dist/tools/execute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute.d.ts","sourceRoot":"","sources":["../../src/tools/execute.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACnE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAEhE,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,QAAQ,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,WAAY,YAAW,YAAY;IAC9C,IAAI,SAAa;IACjB,WAAW,SAKgC;IAE3C,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAyCT;IAEF,OAAO,CAAC,GAAG,CAAmD;gBAElD,GAAG,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK,OAAO,CAAC,YAAY,CAAC;IAI3D,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,YAAY,CAAC;CAGrD"}

package/dist/tools/execute.js

@@ -0,0 +1,64 @@
+/**
+ * execute tool (ctx_execute) — run code in a detected runtime.
+ *
+ * Thin MCP handler: schema + delegation to the ExecutorController. The
+ * controller owns the PolyglotExecutor instance and applies the intent
+ * progressive-disclosure pass on large outputs.
+ */
+export class ExecuteTool {
+    name = "execute";
+    description = "Run code in a detected polyglot sandbox runtime (js/ts/python/shell/" +
+        "ruby/go/rust/php/perl/r). Returns stdout/stderr. Local-dev trust model: " +
+        "code runs on the host as the current user — no OS-level isolation. " +
+        "Timeout default 30s, cap 300s. Pass `intent` to trim large outputs to " +
+        "only the sections matching your query.";
+    inputSchema = {
+        type: "object",
+        properties: {
+            language: {
+                type: "string",
+                enum: [
+                    "javascript",
+                    "typescript",
+                    "python",
+                    "shell",
+                    "ruby",
+                    "go",
+                    "rust",
+                    "php",
+                    "perl",
+                    "r",
+                ],
+                description: "Language/runtime to execute the code in.",
+            },
+            code: { type: "string", description: "Source code to execute." },
+            timeout: {
+                type: "number",
+                description: "Max runtime in ms (default 30000, hard cap 300000).",
+            },
+            background: {
+                type: "boolean",
+                description: "Detach instead of killing on timeout (default false).",
+                default: false,
+            },
+            cwd: {
+                type: "string",
+                description: "Working directory (defaults to project root).",
+            },
+            intent: {
+                type: "string",
+                description: "Optional query. When output > ~5KB, only sections matching this " +
+                    "intent are returned (plus vocabulary hints). Absent = verbatim output.",
+            },
+        },
+        required: ["language", "code"],
+    };
+    run;
+    constructor(run) {
+        this.run = run;
+    }
+    async handle(params) {
+        return this.run(params);
+    }
+}
+//# sourceMappingURL=execute.js.map

package/dist/tools/execute.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute.js","sourceRoot":"","sources":["../../src/tools/execute.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAcH,MAAM,OAAO,WAAW;IACtB,IAAI,GAAG,SAAS,CAAC;IACjB,WAAW,GACT,sEAAsE;QACtE,0EAA0E;QAC1E,qEAAqE;QACrE,wEAAwE;QACxE,wCAAwC,CAAC;IAE3C,WAAW,GAAG;QACZ,IAAI,EAAE,QAAQ;QACd,UAAU,EAAE;YACV,QAAQ,EAAE;gBACR,IAAI,EAAE,QAAQ;gBACd,IAAI,EAAE;oBACJ,YAAY;oBACZ,YAAY;oBACZ,QAAQ;oBACR,OAAO;oBACP,MAAM;oBACN,IAAI;oBACJ,MAAM;oBACN,KAAK;oBACL,MAAM;oBACN,GAAG;iBACJ;gBACD,WAAW,EAAE,0CAA0C;aACxD;YACD,IAAI,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,yBAAyB,EAAE;YAChE,OAAO,EAAE;gBACP,IAAI,EAAE,QAAQ;gBACd,WAAW,EAAE,qDAAqD;aACnE;YACD,UAAU,EAAE;gBACV,IAAI,EAAE,SAAS;gBACf,WAAW,EAAE,uDAAuD;gBACpE,OAAO,EAAE,KAAK;aACf;YACD,GAAG,EAAE;gBACH,IAAI,EAAE,QAAQ;gBACd,WAAW,EAAE,+CAA+C;aAC7D;YACD,MAAM,EAAE;gBACN,IAAI,EAAE,QAAQ;gBACd,WAAW,EACT,kEAAkE;oBAClE,wEAAwE;aAC3E;SACF;QACD,QAAQ,EAAE,CAAC,UAAU,EAAE,MAAM,CAAC;KAC/B,CAAC;IAEM,GAAG,CAAmD;IAE9D,YAAY,GAAqD;QAC/D,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;IACjB,CAAC;IAED,KAAK,CAAC,MAAM,CAAC,MAAe;QAC1B,OAAO,IAAI,CAAC,GAAG,CAAC,MAAuB,CAAC,CAAC;IAC3C,CAAC;CACF"}

package/dist/tools/execute_file.d.ts

@@ -0,0 +1,52 @@
+/**
+ * execute_file tool (ctx_execute_file) — read a file into a sandboxed var and
+ * run code over it.
+ *
+ * Enforces project-boundary containment + a deny-glob guard (the controller
+ * performs these checks before delegating to the executor). Only what the code
+ * prints enters the conversation; the file bytes stay in the sandbox process.
+ */
+import type { ToolResponse, IToolHandler } from "@massa-ai/shared";
+import type { Language } from "../services/executor/runtime.js";
+export interface ExecuteFileParams {
+    path: string;
+    language: Language;
+    code: string;
+    timeout?: number;
+    intent?: string;
+}
+export declare class ExecuteFileTool implements IToolHandler {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            path: {
+                type: string;
+                description: string;
+            };
+            language: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            code: {
+                type: string;
+                description: string;
+            };
+            timeout: {
+                type: string;
+                description: string;
+            };
+            intent: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    private run;
+    constructor(run: (params: ExecuteFileParams) => Promise<ToolResponse>);
+    handle(params: unknown): Promise<ToolResponse>;
+}
+//# sourceMappingURL=execute_file.d.ts.map

package/dist/tools/execute_file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute_file.d.ts","sourceRoot":"","sources":["../../src/tools/execute_file.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACnE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAEhE,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,QAAQ,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,eAAgB,YAAW,YAAY;IAClD,IAAI,SAAkB;IACtB,WAAW,SAGuC;IAElD,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;MAuCT;IAEF,OAAO,CAAC,GAAG,CAAuD;gBAEtD,GAAG,EAAE,CAAC,MAAM,EAAE,iBAAiB,KAAK,OAAO,CAAC,YAAY,CAAC;IAI/D,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,YAAY,CAAC;CAGrD"}

package/dist/tools/execute_file.js

@@ -0,0 +1,61 @@
+/**
+ * execute_file tool (ctx_execute_file) — read a file into a sandboxed var and
+ * run code over it.
+ *
+ * Enforces project-boundary containment + a deny-glob guard (the controller
+ * performs these checks before delegating to the executor). Only what the code
+ * prints enters the conversation; the file bytes stay in the sandbox process.
+ */
+export class ExecuteFileTool {
+    name = "execute_file";
+    description = "Read a file into a sandboxed FILE_CONTENT variable and run code over it. " +
+        "Only what your code prints enters the conversation. Enforces project-root " +
+        "containment + a secrets deny-glob by default.";
+    inputSchema = {
+        type: "object",
+        properties: {
+            path: {
+                type: "string",
+                description: "Project-relative (or absolute, under root) file path.",
+            },
+            language: {
+                type: "string",
+                enum: [
+                    "javascript",
+                    "typescript",
+                    "python",
+                    "shell",
+                    "ruby",
+                    "go",
+                    "rust",
+                    "php",
+                    "perl",
+                    "r",
+                ],
+                description: "Language/runtime to execute the code in.",
+            },
+            code: {
+                type: "string",
+                description: "Code to run over the file. FILE_CONTENT (text) and file_path " +
+                    "(absolute path) are in scope.",
+            },
+            timeout: {
+                type: "number",
+                description: "Max runtime in ms (default 30000, hard cap 300000).",
+            },
+            intent: {
+                type: "string",
+                description: "Optional intent query to trim large outputs.",
+            },
+        },
+        required: ["path", "language", "code"],
+    };
+    run;
+    constructor(run) {
+        this.run = run;
+    }
+    async handle(params) {
+        return this.run(params);
+    }
+}
+//# sourceMappingURL=execute_file.js.map

package/dist/tools/execute_file.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute_file.js","sourceRoot":"","sources":["../../src/tools/execute_file.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAaH,MAAM,OAAO,eAAe;IAC1B,IAAI,GAAG,cAAc,CAAC;IACtB,WAAW,GACT,2EAA2E;QAC3E,4EAA4E;QAC5E,+CAA+C,CAAC;IAElD,WAAW,GAAG;QACZ,IAAI,EAAE,QAAQ;QACd,UAAU,EAAE;YACV,IAAI,EAAE;gBACJ,IAAI,EAAE,QAAQ;gBACd,WAAW,EAAE,uDAAuD;aACrE;YACD,QAAQ,EAAE;gBACR,IAAI,EAAE,QAAQ;gBACd,IAAI,EAAE;oBACJ,YAAY;oBACZ,YAAY;oBACZ,QAAQ;oBACR,OAAO;oBACP,MAAM;oBACN,IAAI;oBACJ,MAAM;oBACN,KAAK;oBACL,MAAM;oBACN,GAAG;iBACJ;gBACD,WAAW,EAAE,0CAA0C;aACxD;YACD,IAAI,EAAE;gBACJ,IAAI,EAAE,QAAQ;gBACd,WAAW,EACT,+DAA+D;oBAC/D,+BAA+B;aAClC;YACD,OAAO,EAAE;gBACP,IAAI,EAAE,QAAQ;gBACd,WAAW,EAAE,qDAAqD;aACnE;YACD,MAAM,EAAE;gBACN,IAAI,EAAE,QAAQ;gBACd,WAAW,EAAE,8CAA8C;aAC5D;SACF;QACD,QAAQ,EAAE,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,CAAC;KACvC,CAAC;IAEM,GAAG,CAAuD;IAElE,YAAY,GAAyD;QACnE,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;IACjB,CAAC;IAED,KAAK,CAAC,MAAM,CAAC,MAAe;QAC1B,OAAO,IAAI,CAAC,GAAG,CAAC,MAA2B,CAAC,CAAC;IAC/C,CAAC;CACF"}

package/dist/tools/fetch_and_index.d.ts

@@ -0,0 +1,71 @@
+/**
+ * fetch_and_index tool — SSRF-guarded web fetch + HTML→md conversion + index.
+ *
+ * Thin handler (mirrors BatchExecuteTool's shape): validates nothing itself and
+ * delegates to an injected `run` function. The Tools API route binds `run` to
+ * `WebController.fetchAndIndex` after resolving the async vector store; tests
+ * bind it to a captured stub.
+ *
+ * Params (single OR batch):
+ *   - url + source         → single fetch
+ *   - requests[]           → batch (wins over url when both supplied)
+ *   - concurrency (1-8)    → parallel fetch phase (cpu-capped for batch)
+ *   - force                → bypass TTL cache
+ *   - ttl                  → per-call cache window override (ms; 0 = bypass)
+ *
+ * Indexing is always SERIAL per URL (single-writer safety) even when fetches
+ * race in the run-pool. Returns per-URL status + chunk counts.
+ */
+import type { ToolResponse, IToolHandler } from "@massa-ai/shared";
+import type { FetchAndIndexParams } from "../services/web/web-controller.js";
+export declare class FetchAndIndexTool implements IToolHandler {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            url: {
+                type: string;
+                description: string;
+            };
+            source: {
+                type: string;
+                description: string;
+            };
+            requests: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        url: {
+                            type: string;
+                            description: string;
+                        };
+                        source: {
+                            type: string;
+                            description: string;
+                        };
+                    };
+                    required: string[];
+                };
+                description: string;
+            };
+            concurrency: {
+                type: string;
+                description: string;
+            };
+            force: {
+                type: string;
+                description: string;
+            };
+            ttl: {
+                type: string;
+                description: string;
+            };
+        };
+    };
+    private run;
+    constructor(run: (params: FetchAndIndexParams) => Promise<ToolResponse>);
+    handle(params: unknown): Promise<ToolResponse>;
+}
+//# sourceMappingURL=fetch_and_index.d.ts.map

package/dist/tools/fetch_and_index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch_and_index.d.ts","sourceRoot":"","sources":["../../src/tools/fetch_and_index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACnE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AAE7E,qBAAa,iBAAkB,YAAW,YAAY;IACpD,IAAI,SAAqB;IACzB,WAAW,SAImB;IAE9B,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA2CT;IAEF,OAAO,CAAC,GAAG,CAAyD;gBAExD,GAAG,EAAE,CAAC,MAAM,EAAE,mBAAmB,KAAK,OAAO,CAAC,YAAY,CAAC;IAIjE,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,YAAY,CAAC;CAGrD"}

package/dist/tools/fetch_and_index.js

@@ -0,0 +1,74 @@
+/**
+ * fetch_and_index tool — SSRF-guarded web fetch + HTML→md conversion + index.
+ *
+ * Thin handler (mirrors BatchExecuteTool's shape): validates nothing itself and
+ * delegates to an injected `run` function. The Tools API route binds `run` to
+ * `WebController.fetchAndIndex` after resolving the async vector store; tests
+ * bind it to a captured stub.
+ *
+ * Params (single OR batch):
+ *   - url + source         → single fetch
+ *   - requests[]           → batch (wins over url when both supplied)
+ *   - concurrency (1-8)    → parallel fetch phase (cpu-capped for batch)
+ *   - force                → bypass TTL cache
+ *   - ttl                  → per-call cache window override (ms; 0 = bypass)
+ *
+ * Indexing is always SERIAL per URL (single-writer safety) even when fetches
+ * race in the run-pool. Returns per-URL status + chunk counts.
+ */
+export class FetchAndIndexTool {
+    name = "fetch_and_index";
+    description = "Fetch URL(s), convert HTML to markdown (JSON → key-path chunks), and " +
+        "index them for search. SSRF-guarded: loopback/private/link-local/IMDS " +
+        "IPs are blocked, including redirect-to-internal. Parallel fetch, serial " +
+        "index. TTL-cached (~24h).";
+    inputSchema = {
+        type: "object",
+        properties: {
+            url: {
+                type: "string",
+                description: "Single URL to fetch and index (single-shape).",
+            },
+            source: {
+                type: "string",
+                description: "Label for the indexed content when using single `url`.",
+            },
+            requests: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        url: { type: "string", description: "URL to fetch." },
+                        source: {
+                            type: "string",
+                            description: "Label for this URL's indexed content.",
+                        },
+                    },
+                    required: ["url"],
+                },
+                description: "Batch shape: array of {url, source?}. Use with concurrency>1 for " +
+                    "parallel fetch. Output preserves input order.",
+            },
+            concurrency: {
+                type: "number",
+                description: "Max URLs fetched in parallel (1-8, default 1). Capped by cpu count.",
+            },
+            force: {
+                type: "boolean",
+                description: "Skip cache and re-fetch even if recently indexed.",
+            },
+            ttl: {
+                type: "number",
+                description: "Override cache freshness window (ms). 0 bypasses cache like force.",
+            },
+        },
+    };
+    run;
+    constructor(run) {
+        this.run = run;
+    }
+    async handle(params) {
+        return this.run(params);
+    }
+}
+//# sourceMappingURL=fetch_and_index.js.map

package/dist/tools/fetch_and_index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch_and_index.js","sourceRoot":"","sources":["../../src/tools/fetch_and_index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAKH,MAAM,OAAO,iBAAiB;IAC5B,IAAI,GAAG,iBAAiB,CAAC;IACzB,WAAW,GACT,uEAAuE;QACvE,wEAAwE;QACxE,0EAA0E;QAC1E,2BAA2B,CAAC;IAE9B,WAAW,GAAG;QACZ,IAAI,EAAE,QAAQ;QACd,UAAU,EAAE;YACV,GAAG,EAAE;gBACH,IAAI,EAAE,QAAQ;gBACd,WAAW,EAAE,+CAA+C;aAC7D;YACD,MAAM,EAAE;gBACN,IAAI,EAAE,QAAQ;gBACd,WAAW,EAAE,wDAAwD;aACtE;YACD,QAAQ,EAAE;gBACR,IAAI,EAAE,OAAO;gBACb,KAAK,EAAE;oBACL,IAAI,EAAE,QAAQ;oBACd,UAAU,EAAE;wBACV,GAAG,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,eAAe,EAAE;wBACrD,MAAM,EAAE;4BACN,IAAI,EAAE,QAAQ;4BACd,WAAW,EAAE,uCAAuC;yBACrD;qBACF;oBACD,QAAQ,EAAE,CAAC,KAAK,CAAC;iBAClB;gBACD,WAAW,EACT,mEAAmE;oBACnE,+CAA+C;aAClD;YACD,WAAW,EAAE;gBACX,IAAI,EAAE,QAAQ;gBACd,WAAW,EACT,qEAAqE;aACxE;YACD,KAAK,EAAE;gBACL,IAAI,EAAE,SAAS;gBACf,WAAW,EAAE,mDAAmD;aACjE;YACD,GAAG,EAAE;gBACH,IAAI,EAAE,QAAQ;gBACd,WAAW,EACT,oEAAoE;aACvE;SACF;KACF,CAAC;IAEM,GAAG,CAAyD;IAEpE,YAAY,GAA2D;QACrE,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;IACjB,CAAC;IAED,KAAK,CAAC,MAAM,CAAC,MAAe;QAC1B,OAAO,IAAI,CAAC,GAAG,CAAC,MAA6B,CAAC,CAAC;IACjD,CAAC;CACF"}

package/dist/tools/get_analytics.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Get Analytics Tool
+ *
+ * Retrieves search analytics and performance metrics
+ */
+import { IToolHandler } from "@massa-ai/shared";
+import { ToolResponse } from "@massa-ai/shared";
+export declare class GetAnalyticsTool implements IToolHandler {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            type: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            projectId: {
+                type: string;
+                description: string;
+            };
+            query: {
+                type: string;
+                description: string;
+            };
+            limit: {
+                type: string;
+                description: string;
+                default: number;
+            };
+        };
+        required: string[];
+    };
+    constructor();
+    handle(params: unknown): Promise<ToolResponse>;
+}
+//# sourceMappingURL=get_analytics.d.ts.map

package/dist/tools/get_analytics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get_analytics.d.ts","sourceRoot":"","sources":["../../src/tools/get_analytics.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAYhD,qBAAa,gBAAiB,YAAW,YAAY;IACnD,IAAI,SAAmB;IACvB,WAAW,SAC+E;IAC1F,WAAW;;;;;;;;;;;;;;;;;;;;;;;MAyBT;;IAII,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,YAAY,CAAC;CA0FrD"}