@sesamespace/hivemind 0.8.3 → 0.8.5

package/dist/{chunk-VCITLDMK.js → chunk-Q5ZO5WXM.js}

@@ -3,18 +3,92 @@ import {
 } from "./chunk-GPI4RU7N.js";
 
 // packages/runtime/src/llm-client.ts
+function convertMessagesForAnthropic(messages) {
+  let system = "";
+  const converted = [];
+  for (const msg of messages) {
+    if (msg.role === "system") {
+      system = msg.content ?? "";
+      continue;
+    }
+    if (msg.role === "tool") {
+      converted.push({
+        role: "user",
+        content: [{
+          type: "tool_result",
+          tool_use_id: msg.tool_call_id,
+          content: msg.content ?? ""
+        }]
+      });
+      continue;
+    }
+    if (msg.role === "assistant" && msg.tool_calls) {
+      const content = [];
+      if (msg.content) content.push({ type: "text", text: msg.content });
+      for (const tc of msg.tool_calls) {
+        content.push({
+          type: "tool_use",
+          id: tc.id,
+          name: tc.function.name,
+          input: JSON.parse(tc.function.arguments)
+        });
+      }
+      converted.push({ role: "assistant", content });
+      continue;
+    }
+    converted.push({ role: msg.role, content: msg.content ?? "" });
+  }
+  return { system, messages: converted };
+}
+function convertToolsForAnthropic(tools) {
+  return tools.map((t) => ({
+    name: t.function.name,
+    description: t.function.description,
+    input_schema: t.function.parameters
+  }));
+}
+function parseAnthropicResponse(data) {
+  let textContent = "";
+  const toolCalls = [];
+  for (const block of data.content) {
+    if (block.type === "text") textContent += block.text;
+    if (block.type === "tool_use") {
+      toolCalls.push({
+        id: block.id,
+        type: "function",
+        function: {
+          name: block.name,
+          arguments: JSON.stringify(block.input)
+        }
+      });
+    }
+  }
+  return {
+    content: textContent,
+    model: data.model,
+    tool_calls: toolCalls.length > 0 ? toolCalls : void 0,
+    finish_reason: data.stop_reason === "tool_use" ? "tool_calls" : "stop",
+    usage: data.usage ? {
+      prompt_tokens: data.usage.input_tokens,
+      completion_tokens: data.usage.output_tokens,
+      total_tokens: data.usage.input_tokens + data.usage.output_tokens
+    } : void 0
+  };
+}
 var LLMClient = class {
   baseUrl;
   model;
   maxTokens;
   temperature;
   apiKey;
+  provider;
   constructor(config) {
     this.baseUrl = config.base_url;
     this.model = config.model;
     this.maxTokens = config.max_tokens;
     this.temperature = config.temperature;
     this.apiKey = config.api_key ?? "";
+    this.provider = config.provider ?? "openai";
   }
   /**
    * Simple chat completion (no tools). Backwards compatible.
@@ -27,6 +101,13 @@ var LLMClient = class {
    * Returns tool_calls if the model wants to use tools.
    */
   async chatWithTools(messages, tools) {
+    if (this.provider === "anthropic") {
+      return this.chatAnthropic(messages, tools);
+    }
+    return this.chatOpenAI(messages, tools);
+  }
+  // --- OpenAI-compatible path (OpenRouter, etc.) ---
+  async chatOpenAI(messages, tools) {
     const body = {
       model: this.model,
       messages,
@@ -75,6 +156,54 @@ var LLMClient = class {
     }
     throw lastError ?? new Error("LLM request failed after retries");
   }
+  // --- Anthropic Messages API path ---
+  async chatAnthropic(messages, tools) {
+    const { system, messages: convertedMessages } = convertMessagesForAnthropic(messages);
+    const body = {
+      model: this.model,
+      max_tokens: this.maxTokens,
+      temperature: this.temperature,
+      messages: convertedMessages
+    };
+    if (system) {
+      body.system = system;
+    }
+    if (tools && tools.length > 0) {
+      body.tools = convertToolsForAnthropic(tools);
+      body.tool_choice = { type: "auto" };
+    }
+    const RETRYABLE_CODES = [429, 500, 502, 503, 529];
+    const MAX_RETRIES = 3;
+    let lastError = null;
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+      if (attempt > 0) {
+        const delayMs = Math.pow(2, attempt) * 1e3;
+        console.log(`[llm] Retry ${attempt}/${MAX_RETRIES} after ${delayMs}ms...`);
+        await new Promise((r) => setTimeout(r, delayMs));
+      }
+      const resp = await fetch(`${this.baseUrl}/v1/messages`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": this.apiKey,
+          "anthropic-version": "2023-06-01"
+        },
+        body: JSON.stringify(body)
+      });
+      if (!resp.ok) {
+        const text = await resp.text();
+        lastError = new Error(`Anthropic request failed: ${resp.status} ${text}`);
+        if (RETRYABLE_CODES.includes(resp.status) && attempt < MAX_RETRIES) {
+          console.warn(`[llm] Retryable error ${resp.status}: ${text.slice(0, 200)}`);
+          continue;
+        }
+        throw lastError;
+      }
+      const data = await resp.json();
+      return parseAnthropicResponse(data);
+    }
+    throw lastError ?? new Error("Anthropic request failed after retries");
+  }
 };
 
 // packages/runtime/src/memory-client.ts
@@ -2336,6 +2465,16 @@ function loadConfig(path) {
   if (process.env.LLM_API_KEY) {
     parsed.llm.api_key = process.env.LLM_API_KEY;
   }
+  if (process.env.ANTHROPIC_API_KEY && !parsed.llm.api_key) {
+    parsed.llm.api_key = process.env.ANTHROPIC_API_KEY;
+    if (!parsed.llm.provider) parsed.llm.provider = "anthropic";
+    if (!process.env.LLM_BASE_URL && parsed.llm.base_url.includes("openrouter")) {
+      parsed.llm.base_url = "https://api.anthropic.com";
+    }
+  }
+  if (process.env.LLM_PROVIDER) {
+    parsed.llm.provider = process.env.LLM_PROVIDER;
+  }
   if (process.env.LLM_BASE_URL) {
     parsed.llm.base_url = process.env.LLM_BASE_URL;
   }
@@ -5465,15 +5604,83 @@ function truncate2(text) {
   return text;
 }
 
-// packages/runtime/src/tools/register.ts
+// packages/runtime/src/tools/coding-agent.ts
+import { execSync as execSync7 } from "child_process";
 import { resolve as resolve16 } from "path";
+var MAX_OUTPUT6 = 5e4;
+function registerCodingAgentTools(registry, workspaceDir) {
+  registry.register(
+    "coding_agent",
+    "Spawn Claude Code CLI to perform a coding task. Use for writing code, debugging, refactoring, or any task that benefits from an AI coding assistant with full filesystem access. Requires the 'claude' CLI to be installed.",
+    {
+      type: "object",
+      properties: {
+        task: {
+          type: "string",
+          description: "The coding task or prompt to send to Claude Code"
+        },
+        workdir: {
+          type: "string",
+          description: "Working directory (relative to workspace). Defaults to workspace root."
+        },
+        timeout: {
+          type: "number",
+          description: "Timeout in seconds. Default: 300"
+        }
+      },
+      required: ["task"]
+    },
+    async (params) => {
+      const task = params.task;
+      const timeoutSeconds = params.timeout || 300;
+      const cwd = params.workdir ? resolve16(workspaceDir, params.workdir) : workspaceDir;
+      try {
+        execSync7("which claude", { stdio: "ignore" });
+      } catch {
+        return "Error: 'claude' CLI not found. Install Claude Code first: https://docs.anthropic.com/en/docs/claude-code";
+      }
+      const escapedTask = task.replace(/'/g, "'\\''");
+      const command = `claude --dangerously-skip-permissions -p '${escapedTask}'`;
+      try {
+        const output = execSync7(command, {
+          cwd,
+          timeout: timeoutSeconds * 1e3,
+          encoding: "utf-8",
+          maxBuffer: 10 * 1024 * 1024,
+          // 10MB
+          shell: "/bin/sh",
+          env: {
+            ...process.env,
+            PATH: `/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:${process.env.PATH}`
+          }
+        });
+        const trimmed = output.length > MAX_OUTPUT6 ? output.slice(0, MAX_OUTPUT6) + `
+... (truncated, ${output.length} total chars)` : output;
+        return trimmed || "(no output)";
+      } catch (err) {
+        if (err.killed) {
+          return `Error: Claude Code timed out after ${timeoutSeconds}s`;
+        }
+        const stderr = err.stderr?.toString() || "";
+        const stdout = err.stdout?.toString() || "";
+        const output = (stdout + "\n" + stderr).trim();
+        const code = err.status ?? "unknown";
+        return `Claude Code failed (exit code ${code}):
+${output || err.message}`;
+      }
+    }
+  );
+}
+
+// packages/runtime/src/tools/register.ts
+import { resolve as resolve17 } from "path";
 import { mkdirSync as mkdirSync12, existsSync as existsSync15 } from "fs";
 function registerAllTools(hivemindHome, config) {
   const registry = new ToolRegistry();
   if (config?.enabled === false) {
     return registry;
   }
-  const workspaceDir = resolve16(hivemindHome, config?.workspace || "workspace");
+  const workspaceDir = resolve17(hivemindHome, config?.workspace || "workspace");
   if (!existsSync15(workspaceDir)) {
     mkdirSync12(workspaceDir, { recursive: true });
   }
@@ -5481,7 +5688,7 @@ function registerAllTools(hivemindHome, config) {
   registerFileTools(registry, workspaceDir);
   registerWebTools(registry, { braveApiKey: config?.braveApiKey });
   registerMemoryTools(registry, config?.memoryDaemonUrl || "http://localhost:3434");
-  const dataDir = resolve16(hivemindHome, "data");
+  const dataDir = resolve17(hivemindHome, "data");
   registerEventTools(registry, dataDir);
   if (config?.configPath && !process.env.SPAWN_TASK) {
     registerSpawnTools(registry, hivemindHome, dataDir, config.configPath);
@@ -5494,6 +5701,7 @@ function registerAllTools(hivemindHome, config) {
   registerWatchTools(registry, workspaceDir, dataDir);
   registerMacOSTools(registry, workspaceDir);
   registerDataTools(registry, workspaceDir);
+  registerCodingAgentTools(registry, workspaceDir);
   return registry;
 }
 
@@ -5531,9 +5739,9 @@ function registerMessagingTools(registry, sesame) {
 
 // packages/runtime/src/tools/skills-tools.ts
 import { existsSync as existsSync16, mkdirSync as mkdirSync13, writeFileSync as writeFileSync6, rmSync } from "fs";
-import { resolve as resolve17 } from "path";
+import { resolve as resolve18 } from "path";
 function registerSkillsTools(registry, skillsEngine, workspaceDir) {
-  const skillsDir = resolve17(workspaceDir, "skills");
+  const skillsDir = resolve18(workspaceDir, "skills");
   registry.register(
     "skill_list",
     "List all loaded skills with their registered tools and status.",
@@ -5600,7 +5808,7 @@ ${lines.join("\n\n")}`;
       const name = params.name;
       const description = params.description;
       const tools = params.tools;
-      const skillDir = resolve17(skillsDir, name);
+      const skillDir = resolve18(skillsDir, name);
       if (existsSync16(skillDir)) {
         return `Error: Skill directory "${name}" already exists. Use skill_reload to update it.`;
       }
@@ -5614,7 +5822,7 @@ description: "${description}"
 
 ${description}
 `;
-      writeFileSync6(resolve17(skillDir, "SKILL.md"), skillMd);
+      writeFileSync6(resolve18(skillDir, "SKILL.md"), skillMd);
       if (tools && tools.length > 0) {
         const toolsDef = {
           tools: tools.map((t) => ({
@@ -5624,7 +5832,7 @@ ${description}
             command: t.command
           }))
         };
-        writeFileSync6(resolve17(skillDir, "tools.json"), JSON.stringify(toolsDef, null, 2) + "\n");
+        writeFileSync6(resolve18(skillDir, "tools.json"), JSON.stringify(toolsDef, null, 2) + "\n");
       }
       try {
         await skillsEngine.loadSkill(name);
@@ -5677,7 +5885,7 @@ Path: ${skillDir}`;
     },
     async (params) => {
       const name = params.name;
-      const skillDir = resolve17(skillsDir, name);
+      const skillDir = resolve18(skillsDir, name);
       if (!existsSync16(skillDir)) {
         return `Error: Skill directory "${name}" does not exist.`;
       }
@@ -5698,12 +5906,12 @@ Path: ${skillDir}`;
 
 // packages/runtime/src/pipeline.ts
 import { readFileSync as readFileSync12, writeFileSync as writeFileSync7, unlinkSync as unlinkSync3 } from "fs";
-import { resolve as resolve18, dirname as dirname7 } from "path";
+import { resolve as resolve19, dirname as dirname7 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var PACKAGE_VERSION = "unknown";
 try {
   const __dirname2 = dirname7(fileURLToPath3(import.meta.url));
-  const pkg = JSON.parse(readFileSync12(resolve18(__dirname2, "../package.json"), "utf-8"));
+  const pkg = JSON.parse(readFileSync12(resolve19(__dirname2, "../package.json"), "utf-8"));
   PACKAGE_VERSION = pkg.version ?? "unknown";
 } catch {
 }
@@ -5768,12 +5976,18 @@ async function startPipeline(configPath) {
   } else {
     memoryConnected = true;
     console.log("[hivemind] Memory daemon connected");
+    try {
+      await memory.createContext("global", "Global context \u2014 identity, preferences, cross-cutting knowledge");
+      console.log("[hivemind] Global context registered with memory daemon");
+    } catch {
+      console.log("[hivemind] Global context already exists in memory daemon");
+    }
   }
-  const requestLogger = new RequestLogger(resolve18(dirname7(configPath), "data", "dashboard.db"));
+  const requestLogger = new RequestLogger(resolve19(dirname7(configPath), "data", "dashboard.db"));
   startDashboardServer(requestLogger, config.memory);
   const agent = new Agent(config);
   agent.setRequestLogger(requestLogger);
-  const hivemindHome = process.env.HIVEMIND_HOME || resolve18(process.env.HOME || "/root", "hivemind");
+  const hivemindHome = process.env.HIVEMIND_HOME || resolve19(process.env.HOME || "/root", "hivemind");
   const toolRegistry = registerAllTools(hivemindHome, {
     enabled: true,
     workspace: config.agent.workspace || "workspace",
@@ -5781,7 +5995,7 @@ async function startPipeline(configPath) {
     memoryDaemonUrl: config.memory.daemon_url,
     configPath
   });
-  const workspaceDir = resolve18(hivemindHome, config.agent.workspace || "workspace");
+  const workspaceDir = resolve19(hivemindHome, config.agent.workspace || "workspace");
   const skillsEngine = new SkillsEngine(workspaceDir, toolRegistry);
   await skillsEngine.loadAll();
   registerSkillsTools(toolRegistry, skillsEngine, workspaceDir);
@@ -5789,7 +6003,7 @@ async function startPipeline(configPath) {
   process.on("exit", () => skillsEngine.stopWatching());
   agent.setToolRegistry(toolRegistry);
   console.log(`[hivemind] Context manager initialized (active: ${agent.getActiveContext()})`);
-  const dataDir = resolve18(hivemindHome, "data");
+  const dataDir = resolve19(hivemindHome, "data");
   if (config.sesame.api_key) {
     await startSesameLoop(config, agent, toolRegistry, dataDir);
   } else {
@@ -5963,8 +6177,8 @@ ${response.content}
       console.error("Error:", err.message);
     }
   });
-  return new Promise((resolve19) => {
-    rl.on("close", resolve19);
+  return new Promise((resolve20) => {
+    rl.on("close", resolve20);
   });
 }
 async function runSpawnTask(config, configPath) {
@@ -5975,7 +6189,7 @@ async function runSpawnTask(config, configPath) {
   const spawnDir = process.env.SPAWN_DIR;
   console.log(`[spawn] Sub-agent starting (id: ${spawnId}, context: ${context})`);
   const agent = new Agent(config, context);
-  const hivemindHome = process.env.HIVEMIND_HOME || resolve18(process.env.HOME || "/root", "hivemind");
+  const hivemindHome = process.env.HIVEMIND_HOME || resolve19(process.env.HOME || "/root", "hivemind");
   const toolRegistry = registerAllTools(hivemindHome, {
     enabled: true,
     workspace: config.agent.workspace || "workspace",
@@ -5988,7 +6202,7 @@ async function runSpawnTask(config, configPath) {
     const result = response.content;
     console.log(`[spawn] Task completed (context: ${response.context})`);
     if (spawnDir) {
-      writeFileSync7(resolve18(spawnDir, "result.txt"), result);
+      writeFileSync7(resolve19(spawnDir, "result.txt"), result);
     }
     if (channelId && config.sesame.api_key) {
       try {
@@ -6005,7 +6219,7 @@ async function runSpawnTask(config, configPath) {
     const errorMsg = `[SPAWN ERROR] ${err.message}`;
     console.error(`[spawn] ${errorMsg}`);
     if (spawnDir) {
-      writeFileSync7(resolve18(spawnDir, "result.txt"), errorMsg);
+      writeFileSync7(resolve19(spawnDir, "result.txt"), errorMsg);
     }
     process.exitCode = 1;
   }
@@ -6036,20 +6250,20 @@ var WorkerServer = class {
   }
   /** Start listening. */
   async start() {
-    return new Promise((resolve19, reject) => {
+    return new Promise((resolve20, reject) => {
       this.server = createServer4((req, res) => this.handleRequest(req, res));
       this.server.on("error", reject);
-      this.server.listen(this.port, () => resolve19());
+      this.server.listen(this.port, () => resolve20());
     });
   }
   /** Stop the server. */
   async stop() {
-    return new Promise((resolve19) => {
+    return new Promise((resolve20) => {
       if (!this.server) {
-        resolve19();
+        resolve20();
         return;
       }
-      this.server.close(() => resolve19());
+      this.server.close(() => resolve20());
     });
   }
   getPort() {
@@ -6172,10 +6386,10 @@ var WorkerServer = class {
   }
 };
 function readBody(req) {
-  return new Promise((resolve19, reject) => {
+  return new Promise((resolve20, reject) => {
     const chunks = [];
     req.on("data", (chunk) => chunks.push(chunk));
-    req.on("end", () => resolve19(Buffer.concat(chunks).toString("utf-8")));
+    req.on("end", () => resolve20(Buffer.concat(chunks).toString("utf-8")));
     req.on("error", reject);
   });
 }
@@ -6509,4 +6723,4 @@ smol-toml/dist/index.js:
    * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    *)
 */
-//# sourceMappingURL=chunk-VCITLDMK.js.map
+//# sourceMappingURL=chunk-Q5ZO5WXM.js.map