@zeroroot-ai/zerocool-claude 0.5.2 → 0.6.1

package/dist/tools/gibson-tools.js

@@ -1,89 +0,0 @@
-import { callGibsonTool, listGibsonPlugins, listGibsonTools, queryGibsonPlugin, } from "@zeroroot-ai/sdk";
-import { z } from "zod";
-import { failure, text } from "./result.js";
-/**
- * Gibson tools and plugins as MCP tools (zerocool-plugins#9).
- *
- * Discovered tools register individually, one MCP tool per Gibson tool, named
- * `gibson_<tool>`, so the model sees each with its own description. The
- * catalog carries no JSON Schema, only a proto message type name, so a wrapper
- * takes one free-form `input` object and names the expected type. A generic
- * `gibson_call_tool` is always present: discovery is `Unimplemented` on some
- * daemons (gibson#1186), and the operator may know a tool by name.
- */
-export function toolKey(name) {
-    return `gibson_${name.replace(/[^a-zA-Z0-9_]/g, "_")}`;
-}
-function formatToolResult(name, result) {
-    if (result.error) {
-        return failure(`${name} failed`, `Gibson tool ${name} failed [${result.error.code}]: ${result.error.message}${result.error.retryable ? " (retryable)" : ""}`);
-    }
-    const body = typeof result.output === "string" ? result.output : JSON.stringify(result.output, null, 2);
-    return text(name, body ?? "(no output)");
-}
-export function registerDiscoveredTool(server, session, t) {
-    const schemaNote = t.inputMessageType ? ` Input must match the Gibson message type ${t.inputMessageType}.` : "";
-    server.registerTool(toolKey(t.name), {
-        description: `${t.description || `Gibson tool "${t.name}"`}${schemaNote} Runs through the Gibson harness (authorized and metered).`,
-        inputSchema: {
-            input: z.record(z.string(), z.any()).describe(`Input object for the ${t.name} tool.`),
-            timeout_ms: z.number().optional().describe("Per-call timeout in milliseconds."),
-        },
-    }, async (args) => formatToolResult(t.name, await callGibsonTool(session.clients.component, {
-        name: t.name,
-        input: args.input,
-        ...(args.timeout_ms ? { timeoutMs: args.timeout_ms } : {}),
-    })));
-}
-/** Register the generic tools, then one tool per discovered Gibson tool. */
-export async function registerGibsonTools(server, session) {
-    const component = session.clients.component;
-    server.registerTool("gibson_call_tool", {
-        description: "Invoke a Gibson tool by name through the harness. Use this when you know a tool's name " +
-            "but it is not in your tool list. Gibson tool discovery is not available on every daemon.",
-        inputSchema: {
-            name: z.string().describe("Registered Gibson tool name."),
-            input: z.record(z.string(), z.any()).describe("Input object matching the tool's input schema."),
-            timeout_ms: z.number().optional().describe("Per-call timeout in milliseconds."),
-        },
-    }, async (args) => formatToolResult(args.name, await callGibsonTool(component, { name: args.name, input: args.input, ...(args.timeout_ms ? { timeoutMs: args.timeout_ms } : {}) })));
-    server.registerTool("gibson_list_tools", {
-        description: "List the Gibson tools and plugins available to this tenant, with the input message type each tool expects.",
-        inputSchema: {},
-    }, async () => {
-        const [discovery, plugins] = await Promise.all([listGibsonTools(component), listGibsonPlugins(component).catch(() => [])]);
-        const lines = [];
-        if (discovery.unavailable)
-            lines.push(`Tool discovery is unavailable: ${discovery.unavailable}.`);
-        else if (discovery.tools.length === 0)
-            lines.push("No Gibson tools are registered for this tenant.");
-        else {
-            lines.push("Gibson tools:");
-            for (const t of discovery.tools) {
-                lines.push(`- ${t.name} (${t.version}): ${t.description || "no description"}`);
-                if (t.inputMessageType)
-                    lines.push(`    input: ${t.inputMessageType}`);
-            }
-        }
-        if (plugins.length > 0) {
-            lines.push("", "Gibson plugins:");
-            for (const p of plugins)
-                lines.push(`- ${p.name} (${p.version}): ${p.description || "no description"}`);
-        }
-        return text("", lines.join("\n"));
-    });
-    server.registerTool("gibson_query_plugin", {
-        description: "Call a method on a tenant Gibson plugin (a connector or an integration) through the harness.",
-        inputSchema: {
-            plugin: z.string().describe("Plugin name."),
-            method: z.string().describe("Method name."),
-            params: z.record(z.string(), z.any()).optional().describe("Method parameters."),
-        },
-    }, async (args) => formatToolResult(`${args.plugin}.${args.method}`, await queryGibsonPlugin(component, { plugin: args.plugin, method: args.method, params: args.params ?? {} })));
-    const discovery = await listGibsonTools(component);
-    if (discovery.unavailable)
-        return { discovered: 0, note: discovery.unavailable };
-    for (const t of discovery.tools)
-        registerDiscoveredTool(server, session, t);
-    return { discovered: discovery.tools.length };
-}

package/dist/tools/memory.d.ts

@@ -1,14 +0,0 @@
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import type { Gibson } from "../session.js";
-/**
- * Memory and knowledge (gibson#1593, decisions 9 and 10).
- *
- * `remember` is `Observe(MemoryObservation)`: the memory lands in the tenant
- * World as a Timeline event and the projector writes the graph node. It exists
- * only in the live posture, because the World is written under a mission.
- *
- * `recall` reads the graph. In the live posture it reads as the task, in the
- * component posture as the component. The model decides when a lookup is worth
- * a round trip, and the query it writes beats anything derived from the prompt.
- */
-export declare function registerMemoryTools(server: McpServer, g: Gibson): void;

package/dist/tools/memory.js

@@ -1,96 +0,0 @@
-import { formatKnowledgeForPrompt, isSeamUnavailable, remember, WorldEntityKind } from "@zeroroot-ai/sdk";
-import { z } from "zod";
-import { failure, text } from "./result.js";
-/**
- * Memory and knowledge (gibson#1593, decisions 9 and 10).
- *
- * `remember` is `Observe(MemoryObservation)`: the memory lands in the tenant
- * World as a Timeline event and the projector writes the graph node. It exists
- * only in the live posture, because the World is written under a mission.
- *
- * `recall` reads the graph. In the live posture it reads as the task, in the
- * component posture as the component. The model decides when a lookup is worth
- * a round trip, and the query it writes beats anything derived from the prompt.
- */
-export function registerMemoryTools(server, g) {
-    if (g.knowledge) {
-        const knowledge = g.knowledge;
-        server.registerTool("recall", {
-            description: "Search this tenant's Gibson knowledge graph for memories, prior findings, targets and " +
-                "security facts recorded by earlier sessions and runs. Use it before you start on an " +
-                "unfamiliar area, or to check whether something was already recorded.",
-            inputSchema: {
-                query: z.string().describe("What to look for, in natural language."),
-                limit: z.number().int().min(1).max(50).optional().describe("Maximum hits. Defaults to 10."),
-                node_types: z
-                    .array(z.string())
-                    .optional()
-                    .describe('Restrict to node types, e.g. ["Observation"] for memories or ["Finding"].'),
-            },
-        }, async (args) => {
-            let hits;
-            try {
-                hits = await knowledge.query({
-                    text: args.query,
-                    topK: args.limit ?? 10,
-                    ...(args.node_types ? { nodeTypes: args.node_types } : {}),
-                });
-            }
-            catch (e) {
-                if (isSeamUnavailable(e)) {
-                    return text("recall unavailable", "The Gibson knowledge graph is not available on this daemon (gibson#1186). Continue without prior context.");
-                }
-                return failure("recall failed", e.message);
-            }
-            if (hits.length === 0)
-                return text("no matches", `Nothing in the tenant graph matches "${args.query}".`);
-            return text(`${hits.length} match${hits.length === 1 ? "" : "es"}`, formatKnowledgeForPrompt(hits));
-        });
-    }
-    if (g.live) {
-        const harness = g.live.harness;
-        server.registerTool("remember", {
-            description: "Keep a fact for later sessions, in this tenant's Gibson knowledge graph. Use it for a " +
-                "convention, a decision, a layout fact or a gotcha you would want back next time. Not for " +
-                "progress notes. A security finding goes to submit_finding instead.",
-            inputSchema: {
-                text: z.string().describe("The fact, in one or two sentences."),
-                kind: z.string().optional().describe('A short category: "convention", "decision", "layout", "gotcha".'),
-                tags: z.array(z.string()).optional().describe("Lower-case labels that help recall."),
-                source_ref: z.string().optional().describe("Where it came from: a path, a URL, or a work id."),
-            },
-        }, async (args) => {
-            try {
-                await remember(harness, { text: args.text, kind: args.kind, tags: args.tags, sourceRef: args.source_ref });
-            }
-            catch (e) {
-                return failure("remember failed", e.message);
-            }
-            return text("remembered", `Recorded in the tenant graph under mission ${g.live.missionId}.`);
-        });
-        server.registerTool("world_view", {
-            description: "Read this mission's slice of the tenant World: the hosts, domains, credentials, accounts " +
-                "and findings the platform knows about the target. Pass handles from a previous call in " +
-                "focus to zoom into entities.",
-            inputSchema: {
-                focus: z.array(z.string()).optional().describe("Entity handles from an earlier world_view call."),
-            },
-        }, async (args) => {
-            try {
-                const res = await harness.client.worldView({ context: harness.context, focus: args.focus ?? [] });
-                if (res.error)
-                    return failure("world_view refused", res.error.message);
-                if (res.entities.length === 0)
-                    return text("empty slice", "The World holds nothing for this target yet.");
-                const lines = res.entities.map((e) => {
-                    const attrs = Object.entries(e.attributes).map(([k, v]) => `${k}=${v}`).join(", ");
-                    return `- [${e.handle}] ${WorldEntityKind[e.kind] ?? e.kind} ${e.label}${attrs ? ` (${attrs})` : ""}`;
-                });
-                return text(`${res.entities.length} entit${res.entities.length === 1 ? "y" : "ies"}${res.truncated ? " (truncated)" : ""}`, lines.join("\n"));
-            }
-            catch (e) {
-                return failure("world_view failed", e.message);
-            }
-        });
-    }
-}

package/dist/tools/result.d.ts

@@ -1,5 +0,0 @@
-import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-/** One text block. MCP has no title/metadata split, so the title leads the text. */
-export declare function text(title: string, body: string, isError?: boolean): CallToolResult;
-/** Error text for a failure the model can act on. */
-export declare function failure(title: string, body: string): CallToolResult;

package/dist/tools/result.js

@@ -1,8 +0,0 @@
-/** One text block. MCP has no title/metadata split, so the title leads the text. */
-export function text(title, body, isError = false) {
-    return { content: [{ type: "text", text: title ? `${title}\n\n${body}` : body }], ...(isError ? { isError } : {}) };
-}
-/** Error text for a failure the model can act on. */
-export function failure(title, body) {
-    return text(title, body, true);
-}

package/dist/tools/status.d.ts

@@ -1,5 +0,0 @@
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import type { Gibson } from "../session.js";
-/** One tool that says what posture this session runs in and why. */
-export declare function registerStatusTool(server: McpServer, current: () => Gibson): void;
-export declare function describeGibson(g: Gibson): string;

package/dist/tools/status.js

@@ -1,21 +0,0 @@
-import { text } from "./result.js";
-/** One tool that says what posture this session runs in and why. */
-export function registerStatusTool(server, current) {
-    server.registerTool("gibson_status", { description: "Show how this session is connected to Gibson: standalone, component, or a live mission, and what is missing if anything.", inputSchema: {} }, async () => text("", describeGibson(current())));
-}
-export function describeGibson(g) {
-    const lines = [`posture: ${g.mode}`, `agent: ${g.agentName}`];
-    if (g.session)
-        lines.push(`component_scope: ${g.session.componentScope}`, `instance: ${g.session.instance.current()}`);
-    if (g.live) {
-        const exp = g.live.harness.expiresAt();
-        lines.push(`mission: ${g.live.missionId}`, `work: ${g.live.workId}`, `grant expires: ${exp ? new Date(exp).toISOString() : "unknown"}`);
-    }
-    if (g.settings.platformURL)
-        lines.push(`platform: ${g.settings.platformURL}`);
-    if (g.settings.targetId)
-        lines.push(`target: ${g.settings.targetId}`);
-    if (g.reason)
-        lines.push(`note: ${g.reason}`);
-    return lines.join("\n");
-}