@sesamespace/hivemind 0.8.4 → 0.8.6

package/dist/{chunk-6S5UKFTZ.js → chunk-S4QRR3ZJ.js}

@@ -1,20 +1,123 @@
-import {
-  SesameClient
-} from "./chunk-GPI4RU7N.js";
-
 // packages/runtime/src/llm-client.ts
+import { execSync } from "child_process";
+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
+  };
+}
+function getClaudeCodeOAuthToken() {
+  try {
+    const raw = execSync(
+      'security find-generic-password -s "Claude Code-credentials" -w',
+      { encoding: "utf-8", timeout: 5e3 }
+    ).trim();
+    const data = JSON.parse(raw);
+    const oauth = data?.claudeAiOauth;
+    if (!oauth?.accessToken) return null;
+    if (oauth.expiresAt && Date.now() > oauth.expiresAt) {
+      console.warn("[llm] Claude Code OAuth token expired. Run: claude auth login");
+      return null;
+    }
+    return oauth.accessToken;
+  } catch {
+    return null;
+  }
+}
 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";
+    if (this.provider === "anthropic" && !this.apiKey) {
+      const token = getClaudeCodeOAuthToken();
+      if (token) {
+        this.apiKey = token;
+        if (!this.baseUrl || this.baseUrl.includes("openrouter")) {
+          this.baseUrl = "https://api.anthropic.com";
+        }
+        console.log("[llm] Auth: Claude Max OAuth (from macOS Keychain)");
+      } else {
+        console.warn("[llm] Auth: No API key found for Anthropic provider");
+      }
+    } else if (this.provider === "anthropic") {
+      console.log("[llm] Auth: Anthropic API key (from config/env)");
+    }
   }
   /**
    * Simple chat completion (no tools). Backwards compatible.
@@ -27,6 +130,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 +185,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 +2494,26 @@ 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 (parsed.llm.provider === "anthropic" && !parsed.llm.api_key) {
+    const oauthToken = getClaudeCodeOAuthToken();
+    if (oauthToken) {
+      parsed.llm.api_key = oauthToken;
+      if (!process.env.LLM_BASE_URL && parsed.llm.base_url.includes("openrouter")) {
+        parsed.llm.base_url = "https://api.anthropic.com";
+      }
+      console.log("[config] Auth: Claude Max OAuth (from macOS Keychain)");
+    }
+  }
+  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;
   }
@@ -2380,6 +2558,626 @@ function loadConfig(path) {
   return parsed;
 }
 
+// node_modules/.pnpm/@sesamespace+sdk@0.1.6/node_modules/@sesamespace/sdk/dist/client.js
+import WebSocket from "ws";
+
+// node_modules/.pnpm/@sesamespace+sdk@0.1.6/node_modules/@sesamespace/sdk/dist/auth.js
+import { sign } from "crypto";
+function createAuthSignature(handle, privateKeyBase64url) {
+  const timestamp = Date.now();
+  const message = `AUTH:${handle}:${timestamp}`;
+  const privateKeyDer = Buffer.from(privateKeyBase64url, "base64url");
+  const privateKey = {
+    key: privateKeyDer,
+    format: "der",
+    type: "pkcs8"
+  };
+  const sig = sign(null, Buffer.from(message), privateKey);
+  return {
+    signature: sig.toString("base64url"),
+    timestamp
+  };
+}
+
+// node_modules/.pnpm/@sesamespace+sdk@0.1.6/node_modules/@sesamespace/sdk/dist/client.js
+var SesameClient = class {
+  config;
+  ws = null;
+  eventHandlers = /* @__PURE__ */ new Map();
+  reconnectAttempts = 0;
+  reconnectTimer = null;
+  heartbeatTimer = null;
+  cursors = /* @__PURE__ */ new Map();
+  authenticated = false;
+  constructor(config) {
+    this.config = {
+      autoReconnect: true,
+      maxReconnectAttempts: 10,
+      ...config
+    };
+  }
+  // ── HTTP Methods ──
+  async fetch(path, options = {}) {
+    const headers = {
+      "Content-Type": "application/json",
+      ...options.headers ?? {}
+    };
+    if (this.config.apiKey) {
+      headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+    } else if (this.config.token) {
+      headers["Authorization"] = `Bearer ${this.config.token}`;
+    } else if (this.config.agent) {
+      const { signature, timestamp } = createAuthSignature(this.config.agent.handle, this.config.agent.privateKey);
+      headers["Authorization"] = `Signature ${this.config.agent.handle}.${signature}.${timestamp}`;
+    }
+    const response = await globalThis.fetch(`${this.config.apiUrl}${path}`, {
+      ...options,
+      headers
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: response.statusText }));
+      throw new SesameApiError(response.status, error.error ?? "Request failed");
+    }
+    return response.json();
+  }
+  get(path) {
+    return this.fetch(path);
+  }
+  post(path, body) {
+    return this.fetch(path, {
+      method: "POST",
+      body: body ? JSON.stringify(body) : void 0
+    });
+  }
+  patch(path, body) {
+    return this.fetch(path, {
+      method: "PATCH",
+      body: JSON.stringify(body)
+    });
+  }
+  del(path) {
+    return this.fetch(path, { method: "DELETE" });
+  }
+  // ── Auth ──
+  async login(email, password) {
+    const result = await this.post("/api/v1/auth/login", { email, password });
+    this.config.token = result.accessToken;
+    return result;
+  }
+  // ── Channels ──
+  async listChannels() {
+    const result = await this.get("/api/v1/channels");
+    const channels = result.data ?? result.channels ?? result;
+    return { channels: Array.isArray(channels) ? channels : [] };
+  }
+  async getChannel(id) {
+    const result = await this.get(`/api/v1/channels/${id}`);
+    const channel = result.data ?? result.channel ?? result;
+    return { channel };
+  }
+  async createChannel(data) {
+    const result = await this.post("/api/v1/channels", data);
+    const channel = result.data ?? result.channel ?? result;
+    return { channel };
+  }
+  async getOrCreateDM(principalId) {
+    const result = await this.post("/api/v1/channels/dm", { principalId });
+    const channel = result.data ?? result.channel ?? result;
+    return { channel };
+  }
+  async getUnread() {
+    return this.get("/api/v1/channels/unread");
+  }
+  // ── Messages ──
+  async sendMessage(channelId, options) {
+    const result = await this.post(`/api/v1/channels/${channelId}/messages`, options);
+    const message = this.normalizeMessage(result.data ?? result.message ?? result);
+    if (message.seq) {
+      this.cursors.set(channelId, message.seq);
+    }
+    return { message };
+  }
+  async getMessages(channelId, options) {
+    const params = new URLSearchParams();
+    if (options?.cursor)
+      params.set("cursor", options.cursor.toString());
+    if (options?.limit)
+      params.set("limit", options.limit.toString());
+    if (options?.direction)
+      params.set("direction", options.direction);
+    if (options?.threadRootId)
+      params.set("threadRootId", options.threadRootId);
+    const qs = params.toString();
+    const result = await this.get(`/api/v1/channels/${channelId}/messages${qs ? `?${qs}` : ""}`);
+    const messages = (result.data ?? result.messages ?? []).map((m) => this.normalizeMessage(m));
+    if (messages.length > 0) {
+      const maxSeq = Math.max(...messages.map((m) => m.seq));
+      const current = this.cursors.get(channelId) ?? 0;
+      if (maxSeq > current)
+        this.cursors.set(channelId, maxSeq);
+    }
+    return {
+      messages,
+      cursor: result.pagination?.cursor ? Number(result.pagination.cursor) : 0,
+      hasMore: result.pagination?.hasMore ?? false
+    };
+  }
+  async editMessage(channelId, messageId, content) {
+    const result = await this.patch(`/api/v1/channels/${channelId}/messages/${messageId}`, { content });
+    const message = this.normalizeMessage(result.data ?? result.message ?? result);
+    return { message };
+  }
+  async deleteMessage(channelId, messageId) {
+    await this.del(`/api/v1/channels/${channelId}/messages/${messageId}`);
+  }
+  async markRead(channelId, seq) {
+    await this.post(`/api/v1/channels/${channelId}/messages/read`, { seq });
+  }
+  async addReaction(channelId, messageId, emoji) {
+    await this.post(`/api/v1/channels/${channelId}/messages/${messageId}/reactions`, { emoji });
+  }
+  async removeReaction(channelId, messageId, emoji) {
+    await this.del(`/api/v1/channels/${channelId}/messages/${messageId}/reactions/${encodeURIComponent(emoji)}`);
+  }
+  // ── Vault ──
+  async listVaults() {
+    return this.get("/api/v1/vault/vaults");
+  }
+  async listVaultItems(vaultId) {
+    const qs = vaultId ? `?vaultId=${vaultId}` : "";
+    return this.get(`/api/v1/vault/items${qs}`);
+  }
+  async getVaultItem(id) {
+    return this.get(`/api/v1/vault/items/${id}`);
+  }
+  async createVaultItem(options) {
+    return this.post("/api/v1/vault/items", options);
+  }
+  async revealItem(id, fields) {
+    return this.post(`/api/v1/vault/items/${id}/reveal`, fields ? { fields } : void 0);
+  }
+  async shareItem(itemId, principalId, options) {
+    await this.post(`/api/v1/vault/items/${itemId}/share`, {
+      principalId,
+      ...options
+    });
+  }
+  async revokeShare(itemId, principalId) {
+    await this.del(`/api/v1/vault/items/${itemId}/share/${principalId}`);
+  }
+  async getWallet() {
+    return this.get("/api/v1/vault/wallet");
+  }
+  // ── Leases ──
+  async requestLease(options) {
+    return this.post("/api/v1/vault/leases/request", options);
+  }
+  async approveLease(leaseId, options) {
+    return this.post(`/api/v1/vault/leases/${leaseId}/approve`, options ?? {});
+  }
+  async denyLease(leaseId) {
+    return this.post(`/api/v1/vault/leases/${leaseId}/deny`, {});
+  }
+  async useSecret(leaseId) {
+    return this.post(`/api/v1/vault/leases/${leaseId}/use`, {});
+  }
+  async revokeLease(leaseId) {
+    await this.del(`/api/v1/vault/leases/${leaseId}`);
+  }
+  // ── HTTP helper: PUT ──
+  put(path, body) {
+    return this.fetch(path, {
+      method: "PUT",
+      body: body ? JSON.stringify(body) : void 0
+    });
+  }
+  // ── Agents ──
+  async listAgents() {
+    return this.get("/api/v1/agents");
+  }
+  async provisionAgent(data) {
+    return this.post("/api/v1/agents", data);
+  }
+  async generateApiKey(agentId, label) {
+    const res = await this.post(`/api/v1/agents/${agentId}/api-keys`, { label });
+    return res.data ?? res;
+  }
+  // ── Capabilities ──
+  async registerCapabilities(capabilities) {
+    const agentId = this.getAgentId();
+    const result = await this.put(`/api/v1/agents/${agentId}/capabilities`, { capabilities });
+    return { capabilities: result.data ?? result };
+  }
+  async addCapability(capability) {
+    const agentId = this.getAgentId();
+    const result = await this.post(`/api/v1/agents/${agentId}/capabilities`, capability);
+    return { capability: result.data ?? result };
+  }
+  async getCapabilities(agentId) {
+    const id = agentId ?? this.getAgentId();
+    const result = await this.get(`/api/v1/agents/${id}/capabilities`);
+    return { capabilities: result.data ?? result };
+  }
+  async removeCapability(capabilityId) {
+    const agentId = this.getAgentId();
+    await this.del(`/api/v1/agents/${agentId}/capabilities/${capabilityId}`);
+  }
+  // ── Discovery ──
+  async discoverAgents(query = {}) {
+    const params = new URLSearchParams();
+    if (query.namespace)
+      params.set("namespace", query.namespace);
+    if (query.name)
+      params.set("name", query.name);
+    if (query.capability) {
+      const caps = Array.isArray(query.capability) ? query.capability : [query.capability];
+      for (const cap of caps) {
+        params.append("capability", cap);
+      }
+    }
+    if (query.active !== void 0)
+      params.set("active", String(query.active));
+    const qs = params.toString();
+    const result = await this.get(`/api/v1/agents/discover${qs ? `?${qs}` : ""}`);
+    return { agents: result.data ?? result };
+  }
+  // ── Manifest & Context ──
+  async getManifest() {
+    if (!this._principalId) {
+      const me = await this.get("/api/v1/auth/me");
+      this.setPrincipalId(me.data?.id ?? me.id);
+    }
+    const agentId = this.getAgentId();
+    const result = await this.get(`/api/v1/agents/${agentId}/manifest`);
+    return result.data ?? result;
+  }
+  async getChannelContext(channelId, options) {
+    const agentId = this.getAgentId();
+    const params = new URLSearchParams();
+    if (options?.strategy)
+      params.set("strategy", options.strategy);
+    if (options?.window)
+      params.set("window", String(options.window));
+    const qs = params.toString();
+    const result = await this.get(`/api/v1/agents/${agentId}/channels/${channelId}/context${qs ? `?${qs}` : ""}`);
+    return result.data ?? result;
+  }
+  // ── Channel Config ──
+  async setChannelConfig(channelId, config) {
+    const agentId = this.getAgentId();
+    const result = await this.put(`/api/v1/agents/${agentId}/channels/${channelId}/config`, config);
+    return result.data ?? result;
+  }
+  async getChannelConfig(channelId) {
+    const agentId = this.getAgentId();
+    const result = await this.get(`/api/v1/agents/${agentId}/channels/${channelId}/config`);
+    return result.data ?? result;
+  }
+  async deleteChannelConfig(channelId) {
+    const agentId = this.getAgentId();
+    await this.del(`/api/v1/agents/${agentId}/channels/${channelId}/config`);
+  }
+  // ── Collaboration ──
+  async createCollaborationChannel(options) {
+    const result = await this.createChannel({
+      kind: "topic",
+      name: options.name,
+      description: options.description,
+      memberIds: options.memberIds
+    });
+    const channel = result.data ?? result.channel ?? result;
+    const channelId = channel.id;
+    if (options.context) {
+      await this.put(`/api/v1/channels/${channelId}/context`, { context: options.context });
+    }
+    if (options.visibility) {
+      await this.patch(`/api/v1/channels/${channelId}`, { visibility: options.visibility });
+    }
+    if (options.coordinationMode) {
+      await this.put(`/api/v1/channels/${channelId}/coordination`, {
+        mode: options.coordinationMode
+      });
+    }
+    return { channel };
+  }
+  // ── Tasks ──
+  async createTask(channelId, options) {
+    const result = await this.post(`/api/v1/channels/${channelId}/tasks`, options);
+    return { task: result.data ?? result };
+  }
+  async listTasks(channelId, filters) {
+    const params = new URLSearchParams();
+    if (filters?.status)
+      params.set("status", filters.status);
+    if (filters?.priority)
+      params.set("priority", filters.priority);
+    if (filters?.assigneeId)
+      params.set("assigneeId", filters.assigneeId);
+    const qs = params.toString();
+    const result = await this.get(`/api/v1/channels/${channelId}/tasks${qs ? `?${qs}` : ""}`);
+    return { tasks: result.data ?? result };
+  }
+  async updateTask(channelId, taskId, updates) {
+    const result = await this.patch(`/api/v1/channels/${channelId}/tasks/${taskId}`, updates);
+    return { task: result.data ?? result };
+  }
+  async claimTask(channelId, taskId) {
+    const result = await this.post(`/api/v1/channels/${channelId}/tasks/${taskId}/claim`);
+    return { task: result.data ?? result };
+  }
+  async addTaskAssignee(channelId, taskId, principalId, role) {
+    const result = await this.post(`/api/v1/channels/${channelId}/tasks/${taskId}/assignees`, { principalId, role });
+    return { task: result.data ?? result };
+  }
+  async removeTaskAssignee(channelId, taskId, principalId) {
+    const result = await this.del(`/api/v1/channels/${channelId}/tasks/${taskId}/assignees/${principalId}`);
+    return { task: result.data ?? result };
+  }
+  async createTaskChannel(channelId, taskId, options) {
+    const result = await this.post(`/api/v1/channels/${channelId}/tasks/${taskId}/channel`, options ?? {});
+    return result.data ?? result;
+  }
+  // ── Webhooks ──
+  async createWebhook(options) {
+    const agentId = this.getAgentId();
+    const result = await this.post(`/api/v1/agents/${agentId}/webhooks`, options);
+    return { webhook: result.data ?? result };
+  }
+  async listWebhooks() {
+    const agentId = this.getAgentId();
+    const result = await this.get(`/api/v1/agents/${agentId}/webhooks`);
+    return { webhooks: result.data ?? result };
+  }
+  async updateWebhook(webhookId, updates) {
+    const agentId = this.getAgentId();
+    const result = await this.patch(`/api/v1/agents/${agentId}/webhooks/${webhookId}`, updates);
+    return { webhook: result.data ?? result };
+  }
+  async deleteWebhook(webhookId) {
+    const agentId = this.getAgentId();
+    await this.del(`/api/v1/agents/${agentId}/webhooks/${webhookId}`);
+  }
+  async rotateWebhookSecret(webhookId) {
+    const agentId = this.getAgentId();
+    const result = await this.post(`/api/v1/agents/${agentId}/webhooks/${webhookId}/rotate-secret`);
+    return result.data ?? result;
+  }
+  async listWebhookDeliveries(webhookId, options) {
+    const agentId = this.getAgentId();
+    const params = new URLSearchParams();
+    if (options?.limit)
+      params.set("limit", String(options.limit));
+    if (options?.status)
+      params.set("status", options.status);
+    const qs = params.toString();
+    const result = await this.get(`/api/v1/agents/${agentId}/webhooks/${webhookId}/deliveries${qs ? `?${qs}` : ""}`);
+    return { deliveries: result.data ?? result };
+  }
+  // ── Profile ──
+  async setReadReceiptEmoji(emoji) {
+    const agentId = this.getAgentId();
+    const result = await this.put(`/api/v1/agents/${agentId}/read-receipt-emoji`, { emoji });
+    return { emoji: result.data?.emoji ?? emoji };
+  }
+  async getReadReceiptEmoji() {
+    const agentId = this.getAgentId();
+    const result = await this.get(`/api/v1/agents/${agentId}/read-receipt-emoji`);
+    return { emoji: result.data?.emoji ?? "\u{1F440}" };
+  }
+  // ── Internal helpers ──
+  normalizeMessage(msg) {
+    return {
+      ...msg,
+      content: msg.content ?? msg.plaintext ?? null
+    };
+  }
+  getAgentId() {
+    const principal = this._principalId;
+    if (principal)
+      return principal;
+    throw new SesameApiError(400, "Agent ID not resolved. Call boot() or setPrincipalId(id) first.");
+  }
+  /**
+   * Set the current agent's principal ID (resolved after auth).
+   */
+  setPrincipalId(id) {
+    this._principalId = id;
+  }
+  /**
+   * Bootstrap the agent: resolves identity via /auth/me and loads manifest.
+   */
+  async boot() {
+    const me = await this.get("/api/v1/auth/me");
+    const principal = me.data ?? me;
+    this.setPrincipalId(principal.id);
+    const manifest = await this.getManifest();
+    return manifest;
+  }
+  // ── WebSocket ──
+  /**
+   * Connect to the real-time WebSocket gateway.
+   */
+  connect() {
+    return new Promise((resolve20, reject) => {
+      try {
+        this.ws = new WebSocket(`${this.config.wsUrl}/v1/connect`);
+        this.ws.on("open", () => {
+          this.reconnectAttempts = 0;
+          this.sendAuth();
+        });
+        this.ws.on("message", (data) => {
+          try {
+            const event = JSON.parse(data.toString());
+            if (event.type === "authenticated") {
+              this.authenticated = true;
+              this.startHeartbeat(event.heartbeatIntervalMs ?? 3e4);
+              this.sendReplay();
+              resolve20();
+              return;
+            }
+            if (event.type === "pong")
+              return;
+            if (event.type === "error") {
+              console.error("WS error:", event.message);
+              return;
+            }
+            if (event.type === "message" && event.data) {
+              event.data = this.normalizeMessage(event.data);
+              const seq = event.data.seq;
+              if (seq) {
+                const channelId = event.data.channelId;
+                const current = this.cursors.get(channelId) ?? 0;
+                if (seq > current)
+                  this.cursors.set(channelId, seq);
+              }
+            }
+            this.emit(event);
+          } catch {
+          }
+        });
+        this.ws.on("close", () => {
+          this.authenticated = false;
+          this.stopHeartbeat();
+          if (this.config.autoReconnect) {
+            this.scheduleReconnect();
+          }
+        });
+        this.ws.on("error", (err) => {
+          if (!this.authenticated) {
+            reject(err);
+          }
+        });
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+  /**
+   * Disconnect from the WebSocket gateway.
+   */
+  disconnect() {
+    this.config.autoReconnect = false;
+    this.stopHeartbeat();
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+  /**
+   * Subscribe to WebSocket events.
+   */
+  on(eventType, handler) {
+    if (!this.eventHandlers.has(eventType)) {
+      this.eventHandlers.set(eventType, /* @__PURE__ */ new Set());
+    }
+    this.eventHandlers.get(eventType).add(handler);
+    return () => {
+      this.eventHandlers.get(eventType)?.delete(handler);
+    };
+  }
+  /**
+   * Subscribe to all events.
+   */
+  onAny(handler) {
+    return this.on("*", handler);
+  }
+  emit(event) {
+    this.eventHandlers.get(event.type)?.forEach((h) => h(event));
+    this.eventHandlers.get("*")?.forEach((h) => h(event));
+  }
+  sendAuth() {
+    if (!this.ws)
+      return;
+    if (this.config.apiKey) {
+      this.ws.send(JSON.stringify({ type: "auth", apiKey: this.config.apiKey }));
+    } else if (this.config.token) {
+      this.ws.send(JSON.stringify({ type: "auth", token: this.config.token }));
+    } else if (this.config.agent) {
+      const { signature, timestamp } = createAuthSignature(this.config.agent.handle, this.config.agent.privateKey);
+      this.ws.send(JSON.stringify({
+        type: "auth",
+        signature: {
+          handle: this.config.agent.handle,
+          sig: signature,
+          timestamp
+        }
+      }));
+    }
+  }
+  sendReplay() {
+    if (!this.ws || this.cursors.size === 0)
+      return;
+    const cursors = {};
+    this.cursors.forEach((seq, channelId) => {
+      cursors[channelId] = seq;
+    });
+    this.ws.send(JSON.stringify({ type: "replay", cursors }));
+  }
+  startHeartbeat(intervalMs) {
+    this.stopHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      if (this.ws?.readyState === WebSocket.OPEN) {
+        this.ws.send(JSON.stringify({ type: "ping" }));
+      }
+    }, intervalMs);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  scheduleReconnect() {
+    if (this.reconnectAttempts >= this.config.maxReconnectAttempts) {
+      console.error("Max reconnect attempts reached");
+      return;
+    }
+    const delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts), 3e4);
+    this.reconnectAttempts++;
+    this.reconnectTimer = setTimeout(() => {
+      this.connect().catch(() => {
+        this.scheduleReconnect();
+      });
+    }, delay);
+  }
+  /**
+   * Send a typing indicator for a channel.
+   */
+  sendTyping(channelId) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify({ type: "typing", channelId }));
+    }
+  }
+  /**
+   * Send a message via WebSocket (alternative to HTTP).
+   */
+  sendWsMessage(channelId, content, options) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify({
+        type: "send",
+        channelId,
+        content,
+        ...options
+      }));
+    }
+  }
+};
+var SesameApiError = class extends Error {
+  status;
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "SesameApiError";
+  }
+};
+
+// node_modules/.pnpm/@sesamespace+sdk@0.1.6/node_modules/@sesamespace/sdk/dist/verify-webhook.js
+import { createHmac, timingSafeEqual } from "crypto";
+
 // packages/runtime/src/sesame.ts
 import { readFileSync as readFileSync5 } from "fs";
 import { resolve as resolve4, dirname as dirname3 } from "path";
@@ -2549,7 +3347,7 @@ var SesameClient2 = class {
 };
 
 // packages/runtime/src/skills.ts
-import { execSync } from "child_process";
+import { execSync as execSync2 } from "child_process";
 import { existsSync as existsSync5, readFileSync as readFileSync6, readdirSync as readdirSync3, watch as watch2, mkdirSync as mkdirSync3 } from "fs";
 import { resolve as resolve5 } from "path";
 function shellEscape(value) {
@@ -2618,7 +3416,7 @@ var SkillsEngine = class {
     const setupPath = resolve5(skillDir, "setup.sh");
     if (existsSync5(setupPath)) {
       try {
-        execSync("bash setup.sh", { cwd: skillDir, timeout: 3e4, stdio: "pipe" });
+        execSync2("bash setup.sh", { cwd: skillDir, timeout: 3e4, stdio: "pipe" });
         console.log(`[skills] Ran setup.sh for "${name}"`);
       } catch (err) {
         console.warn(`[skills] setup.sh failed for "${name}":`, err.message);
@@ -2643,7 +3441,7 @@ var SkillsEngine = class {
             async (params) => {
               const cmd = renderCommand(commandTemplate, params, skillDir, this.workspaceDir);
               try {
-                const output = execSync(cmd, {
+                const output = execSync2(cmd, {
                   cwd: skillDir,
                   timeout: 6e4,
                   encoding: "utf-8",
@@ -2682,7 +3480,7 @@ var SkillsEngine = class {
     const teardownPath = resolve5(skill.path, "teardown.sh");
     if (existsSync5(teardownPath)) {
       try {
-        execSync("bash teardown.sh", { cwd: skill.path, timeout: 3e4, stdio: "pipe" });
+        execSync2("bash teardown.sh", { cwd: skill.path, timeout: 3e4, stdio: "pipe" });
         console.log(`[skills] Ran teardown.sh for "${skill.name}"`);
       } catch (err) {
         console.warn(`[skills] teardown.sh failed for "${skill.name}":`, err.message);
@@ -3078,7 +3876,7 @@ var ToolRegistry = class {
 };
 
 // packages/runtime/src/tools/shell.ts
-import { execSync as execSync2 } from "child_process";
+import { execSync as execSync3 } from "child_process";
 import { resolve as resolve7 } from "path";
 var MAX_OUTPUT = 5e4;
 function registerShellTool(registry, workspaceDir) {
@@ -3108,7 +3906,7 @@ function registerShellTool(registry, workspaceDir) {
       const timeout = (params.timeout || 30) * 1e3;
       const cwd = params.workdir ? resolve7(workspaceDir, params.workdir) : workspaceDir;
       try {
-        const output = execSync2(command, {
+        const output = execSync3(command, {
           cwd,
           timeout,
           encoding: "utf-8",
@@ -3981,7 +4779,7 @@ function registerVisionTools(registry) {
 }
 
 // packages/runtime/src/tools/git.ts
-import { execSync as execSync3 } from "child_process";
+import { execSync as execSync4 } from "child_process";
 import { resolve as resolve10, normalize } from "path";
 function resolveRepoPath(workspaceDir, repoPath) {
   if (!repoPath) return workspaceDir;
@@ -3994,7 +4792,7 @@ function resolveRepoPath(workspaceDir, repoPath) {
   return resolved;
 }
 function runGit(args, cwd) {
-  const output = execSync3(`git ${args}`, {
+  const output = execSync4(`git ${args}`, {
     cwd,
     timeout: 3e4,
     encoding: "utf-8",
@@ -4401,7 +5199,7 @@ function registerBrowserTools(registry, workspaceDir) {
 }
 
 // packages/runtime/src/tools/system.ts
-import { execSync as execSync4 } from "child_process";
+import { execSync as execSync5 } from "child_process";
 import * as os from "os";
 var MAX_OUTPUT3 = 5e4;
 function truncate(output) {
@@ -4412,7 +5210,7 @@ function truncate(output) {
   return output;
 }
 function exec(cmd, timeoutS = 10) {
-  return execSync4(cmd, {
+  return execSync5(cmd, {
     encoding: "utf-8",
     timeout: timeoutS * 1e3,
     maxBuffer: 10 * 1024 * 1024,
@@ -5003,13 +5801,13 @@ ${lines.join("\n")}`;
 }
 
 // packages/runtime/src/tools/macos.ts
-import { execSync as execSync5 } from "child_process";
+import { execSync as execSync6 } from "child_process";
 import { resolve as resolve14, normalize as normalize2 } from "path";
 import { mkdirSync as mkdirSync10, existsSync as existsSync13 } from "fs";
 import { randomUUID as randomUUID7 } from "crypto";
 var MAX_OUTPUT4 = 5e4;
 function shellExec(command, timeoutMs) {
-  return execSync5(command, {
+  return execSync6(command, {
     timeout: timeoutMs,
     encoding: "utf-8",
     maxBuffer: 10 * 1024 * 1024,
@@ -5120,7 +5918,7 @@ ${output || err.message}`;
     async (params) => {
       const content = params.content;
       try {
-        execSync5("pbcopy", {
+        execSync6("pbcopy", {
           input: content,
           timeout: 5e3,
           encoding: "utf-8",
@@ -5220,12 +6018,12 @@ function escapeAppleString(s) {
 }
 
 // packages/runtime/src/tools/data.ts
-import { execSync as execSync6 } from "child_process";
+import { execSync as execSync7 } from "child_process";
 import { resolve as resolve15, normalize as normalize3, extname as extname2 } from "path";
 import { mkdirSync as mkdirSync11, existsSync as existsSync14 } from "fs";
 var MAX_OUTPUT5 = 5e4;
 function shellExec2(command, cwd, timeoutMs) {
-  return execSync6(command, {
+  return execSync7(command, {
     cwd,
     timeout: timeoutMs,
     encoding: "utf-8",
@@ -5465,15 +6263,83 @@ function truncate2(text) {
   return text;
 }
 
-// packages/runtime/src/tools/register.ts
+// packages/runtime/src/tools/coding-agent.ts
+import { execSync as execSync8 } 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 {
+        execSync8("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 = execSync8(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 +6347,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 +6360,7 @@ function registerAllTools(hivemindHome, config) {
   registerWatchTools(registry, workspaceDir, dataDir);
   registerMacOSTools(registry, workspaceDir);
   registerDataTools(registry, workspaceDir);
+  registerCodingAgentTools(registry, workspaceDir);
   return registry;
 }
 
@@ -5531,9 +6398,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 +6467,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 +6481,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 +6491,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 +6544,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 +6565,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 {
 }
@@ -5775,11 +6642,11 @@ async function startPipeline(configPath) {
       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",
@@ -5787,7 +6654,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);
@@ -5795,7 +6662,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 {
@@ -5969,8 +6836,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) {
@@ -5981,7 +6848,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",
@@ -5994,7 +6861,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 {
@@ -6011,7 +6878,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;
   }
@@ -6042,20 +6909,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() {
@@ -6178,10 +7045,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);
   });
 }
@@ -6448,6 +7315,7 @@ async function startWorker(config) {
 }
 
 export {
+  getClaudeCodeOAuthToken,
   LLMClient,
   MemoryClient,
   ContextManager,
@@ -6463,7 +7331,8 @@ export {
   EventsWatcher,
   defaultSentinelConfig,
   loadConfig,
-  SesameClient2 as SesameClient,
+  SesameClient,
+  SesameClient2,
   HEALTH_PATH,
   SkillsEngine,
   startPipeline,
@@ -6515,4 +7384,4 @@ smol-toml/dist/index.js:
    * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    *)
 */
-//# sourceMappingURL=chunk-6S5UKFTZ.js.map
+//# sourceMappingURL=chunk-S4QRR3ZJ.js.map