@mindot/will 0.4.0 → 0.5.0

package/dist/cli.js

@@ -3862,6 +3862,11 @@ var MODEL_PRICING = {
   // Legacy aliases kept for backward compat
   "anthropic/claude-haiku-4": { input: 1, output: 5 },
   "anthropic/claude-opus-4": { input: 5, output: 25 },
+  // Z.ai (GLM-5 family). `glm-5.2[1m]` is the same model asking for its 1M
+  // context window — same rate, so it gets its own row rather than relying on
+  // the normalizer (a future long-context tier would price differently).
+  "glm/glm-5.2": { input: 1.4, output: 4.4 },
+  "glm/glm-5.2[1m]": { input: 1.4, output: 4.4 },
   // Google
   "google/gemini-2.0-flash": { input: 0.1, output: 0.4 },
   "google/gemini-2.0-pro": { input: 1.25, output: 5 },
@@ -13153,6 +13158,38 @@ async function withGate(fn, label, gate = llmGate) {
 }
 
 // src/llm/index.ts
+var ANTHROPIC_WIRE = /* @__PURE__ */ new Set(["anthropic", "glm"]);
+function speaksAnthropicWire(provider) {
+  return ANTHROPIC_WIRE.has(provider);
+}
+function defaultBaseFor(provider) {
+  switch (provider) {
+    case "anthropic":
+      return "https://api.anthropic.com/v1";
+    // Z.ai documents the base as `…/api/anthropic` because the Anthropic SDK
+    // appends `/v1/messages`; this client appends `/messages`, so the version
+    // segment belongs here — verified against the live endpoint.
+    case "glm":
+      return "https://api.z.ai/api/anthropic/v1";
+    case "openai":
+      return "https://api.openai.com/v1";
+    case "deepseek":
+      return "https://api.deepseek.com/v1";
+    case "google":
+      return "https://generativelanguage.googleapis.com/v1beta";
+  }
+}
+function defaultModelFor(provider) {
+  return provider === "glm" ? "glm-5.2" : "claude-sonnet-4-5-20250929";
+}
+function anthropicWireHeaders(provider, apiKey) {
+  return {
+    "Content-Type": "application/json",
+    "anthropic-version": "2023-06-01",
+    "x-api-key": apiKey,
+    ...provider === "glm" ? { Authorization: `Bearer ${apiKey}` } : {}
+  };
+}
 var DEFAULT_CALL_META = { category: "executive", attribute: "master", function: "decision" };
 var LLMDirector = class {
   _willId;
@@ -13255,7 +13292,7 @@ var LLMDirector = class {
       this._recordCompletion(systemPrompt, userMessage, tick, result2, Date.now() - start, true);
       return result2;
     }
-    const result = this._provider === "anthropic" ? await this._callAnthropicStream(systemPrompt, userMessage, onChunk, temperature) : await (async () => {
+    const result = speaksAnthropicWire(this._provider) ? await this._callAnthropicStream(systemPrompt, userMessage, onChunk, temperature) : await (async () => {
       const r = await this._callProvider(systemPrompt, userMessage, temperature);
       onChunk(r.text);
       return r;
@@ -13335,11 +13372,7 @@ var LLMDirector = class {
     try {
       res = await fetch(`${this._resolvedBase()}/messages`, {
         method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "anthropic-version": "2023-06-01",
-          "x-api-key": this._apiKey
-        },
+        headers: anthropicWireHeaders(this._provider, this._apiKey),
         body: JSON.stringify({
           model: this._model,
           max_tokens: this._maxOutputTokens,
@@ -13414,7 +13447,7 @@ var LLMDirector = class {
       return result2;
     }
     const result = await withGate(
-      () => this._provider === "anthropic" ? this._callAnthropicStream(systemPrompt, userMessage, () => {
+      () => speaksAnthropicWire(this._provider) ? this._callAnthropicStream(systemPrompt, userMessage, () => {
       }, temperature) : this._callProvider(systemPrompt, userMessage, temperature),
       "executive/direct"
     );
@@ -13426,6 +13459,8 @@ var LLMDirector = class {
     switch (this._provider) {
       case "anthropic":
         return this._callAnthropic(systemPrompt, userMessage, temperature);
+      case "glm":
+        return this._callAnthropic(systemPrompt, userMessage, temperature);
       case "deepseek":
         return this._callOpenAI(systemPrompt, userMessage, temperature);
       case "openai":
@@ -13438,16 +13473,7 @@ var LLMDirector = class {
   }
   /** Default API base URL (including version segment) for a provider. */
   _baseFor(provider) {
-    switch (provider) {
-      case "anthropic":
-        return "https://api.anthropic.com/v1";
-      case "openai":
-        return "https://api.openai.com/v1";
-      case "deepseek":
-        return "https://api.deepseek.com/v1";
-      case "google":
-        return "https://generativelanguage.googleapis.com/v1beta";
-    }
+    return defaultBaseFor(provider);
   }
   /** Resolved API base: explicit override wins, else the provider default. */
   _resolvedBase() {
@@ -13487,15 +13513,11 @@ var LLMDirector = class {
     };
     const res = await this._fetchWithTimeout(`${this._resolvedBase()}/messages`, {
       method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "anthropic-version": "2023-06-01",
-        "x-api-key": this._apiKey
-      },
+      headers: anthropicWireHeaders(this._provider, this._apiKey),
       body: JSON.stringify(body)
     });
     if (!res.ok)
-      throw new Error(`Anthropic API ${res.status}: ${(await res.text()).slice(0, 300)}`);
+      throw new Error(`${this._provider} API ${res.status}: ${(await res.text()).slice(0, 300)}`);
     const data = await res.json(), text = data.content.find((b) => b.type === "text")?.text ?? "";
     return {
       text,
@@ -14275,7 +14297,7 @@ var ExecutiveEngine = class extends AsyncEngine {
     this._gatingState.executiveInterval = rtConfig.executiveInterval;
     this._gatingState.cooldownTicks = rtConfig.cooldownTicks;
     if (!this._llmDirector && this._willId) {
-      const execModel = this._models.executive ?? process.env.WILL_LLM_MODEL ?? "claude-sonnet-4-5-20250929";
+      const execModel = this._models.executive ?? process.env.WILL_LLM_MODEL ?? defaultModelFor(this._llm?.provider ?? process.env.WILL_LLM_PROVIDER ?? "anthropic");
       this._llmDirector = this._directorFor(execModel);
       this._summarizer?.attachLLMDirector(this._directorFor(this._models.summarizer ?? execModel));
     }
@@ -22198,12 +22220,13 @@ async function checkIdentityCoherence(input, reviewer) {
   return { ok: !issues.some((i) => i.severity === "error"), ran: true, issues, raw: text };
 }
 async function reviewIdentityCoherence(input, opts = {}) {
+  const provider = process.env.WILL_LLM_PROVIDER ?? "anthropic";
   const director = new LLMDirector({
     willId: opts.willId ?? "identity-coherence",
-    model: process.env.WILL_LLM_MODEL ?? "claude-sonnet-4-5-20250929",
+    model: process.env.WILL_LLM_MODEL ?? defaultModelFor(provider),
     maxOutputTokens: 512,
     apiKey: process.env.WILL_LLM_API_KEY ?? process.env.ANTHROPIC_API_KEY ?? "",
-    provider: process.env.WILL_LLM_PROVIDER ?? "anthropic",
+    provider,
     sessionLogger: null,
     baseUrl: process.env.WILL_LLM_BASE_URL ?? process.env.OPENAI_BASE_URL,
     // When a per-Will tracker is supplied, the creation-time review records under
@@ -25760,7 +25783,9 @@ var Will = class _Will {
   }
   // ── Internals ──────────────────────────────────────────────
   _buildConfig(id, opts) {
-    const useMock = (opts.llm ?? (process.env.ANTHROPIC_API_KEY ? "anthropic" : "mock")) === "mock";
+    const mode = opts.llm ?? (process.env.ANTHROPIC_API_KEY ? "anthropic" : process.env.ZAI_API_KEY ? "glm" : "mock");
+    const useMock = mode === "mock";
+    const llmConfig = mode === "glm" ? { provider: "glm", ...opts.llmConfig } : opts.llmConfig;
     return {
       id,
       name: opts.name,
@@ -25772,7 +25797,7 @@ var Will = class _Will {
       },
       anatomy: opts.anatomy ?? "mind",
       model: opts.model,
-      llm: opts.llmConfig,
+      llm: llmConfig,
       testMode: useMock,
       persistentMemory: opts.persist ?? false,
       snapshotInterval: 100,
@@ -25955,21 +25980,32 @@ function routeLogsToStderr() {
 function slug2(s) {
   return s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "will";
 }
+function resolveLlmMode() {
+  const explicit = process.env.WILL_LLM;
+  if (explicit) return explicit;
+  if (process.env.ANTHROPIC_API_KEY) return "anthropic";
+  if (process.env.ZAI_API_KEY) return "glm";
+  return "mock";
+}
+function resolveLlmKey(mode) {
+  return process.env.WILL_LLM_API_KEY ?? (mode === "glm" ? process.env.ZAI_API_KEY : process.env.ANTHROPIC_API_KEY);
+}
 async function preflightLLM(anatomy) {
-  const mode = process.env.WILL_LLM ?? (process.env.ANTHROPIC_API_KEY ? "anthropic" : "mock");
+  const mode = resolveLlmMode();
   if (mode === "mock" || anatomy === "reflex") return;
-  const key = process.env.WILL_LLM_API_KEY ?? process.env.ANTHROPIC_API_KEY;
+  const key = resolveLlmKey(mode);
   if (!key) {
-    console.error("[will] WILL_LLM=anthropic but no ANTHROPIC_API_KEY / WILL_LLM_API_KEY is set.");
+    const expected = mode === "glm" ? "ZAI_API_KEY" : "ANTHROPIC_API_KEY";
+    console.error(`[will] WILL_LLM=${mode} but no ${expected} / WILL_LLM_API_KEY is set.`);
     console.error("[will] The Will would boot, perceive, and never speak. Set a key, or run keyless with WILL_LLM=mock.");
     process.exit(2);
   }
-  const base = process.env.WILL_LLM_BASE_URL ?? "https://api.anthropic.com/v1";
-  const model = process.env.WILL_LLM_MODEL ?? "claude-haiku-4-5-20251001";
+  const base = process.env.WILL_LLM_BASE_URL ?? defaultBaseFor(mode);
+  const model = process.env.WILL_LLM_MODEL ?? (mode === "glm" ? defaultModelFor("glm") : "claude-haiku-4-5-20251001");
   try {
     const res = await fetch(`${base}/messages`, {
       method: "POST",
-      headers: { "content-type": "application/json", "anthropic-version": "2023-06-01", "x-api-key": key },
+      headers: anthropicWireHeaders(mode, key),
       body: JSON.stringify({ model, max_tokens: 1, messages: [{ role: "user", content: "ping" }] }),
       signal: AbortSignal.timeout(2e4)
     });
@@ -26474,21 +26510,200 @@ async function createDiscordClient() {
   });
 }
 
+// src/channels/whatsapp.ts
+var WHATSAPP_MESSAGE_LIMIT = 65536;
+var isGroupJid = (jid) => jid.endsWith("@g.us");
+var bareId = (jid) => jid.split("@")[0].split(":")[0];
+var dmJidFor = (userId) => `${userId}@s.whatsapp.net`;
+function textOf(m) {
+  const msg = m.message;
+  return msg?.conversation ?? msg?.extendedTextMessage?.text ?? msg?.imageMessage?.caption ?? msg?.videoMessage?.caption ?? "";
+}
+async function connectWhatsApp(will, opts = {}) {
+  const log = opts.log ?? ((m) => console.error(`[will:whatsapp] ${m}`));
+  const roster = new ChannelRoster(opts.rosterPath ?? `.will/${will.id}.whatsapp.json`);
+  const allowed = opts.chats?.length ? new Set(opts.chats) : null;
+  let closed = false;
+  const socket = opts.socket ?? await createWhatsAppSocket({
+    authPath: opts.authPath ?? `.will/${will.id}.wa-auth`,
+    log,
+    stillOpen: () => !closed
+  });
+  let lastActiveChatId = opts.homeChatId ?? null;
+  socket.ev.on("messages.upsert", ({ messages, type }) => {
+    if (type && type !== "notify") return;
+    for (const m of messages) void onMessage(m);
+  });
+  async function onMessage(m) {
+    const jid = m.key.remoteJid;
+    if (!jid || m.key.fromMe || !m.message || m.messageStubType) return;
+    if (jid.endsWith("@broadcast") || jid.endsWith("@newsletter")) return;
+    if (allowed && !allowed.has(jid)) return;
+    const isGroup = isGroupJid(jid);
+    const senderJid = isGroup ? m.key.participant : jid;
+    if (!senderJid) return;
+    const selfId = socket.user ? bareId(socket.user.id) : null;
+    const mentioned = m.message.extendedTextMessage?.contextInfo?.mentionedJid ?? [];
+    const addressed = !isGroup || selfId != null && mentioned.some((j) => bareId(j) === selfId);
+    if (opts.mentionOnly && !addressed) return;
+    const userId = bareId(senderJid);
+    const entityId = `whatsapp:${userId}`;
+    const speaker = m.pushName ?? void 0;
+    roster.record({
+      entityId,
+      userId,
+      ...speaker ? { displayName: speaker } : {},
+      ...isGroup ? { lastChannelId: jid } : { dmChannelId: jid }
+    });
+    if (isGroup) lastActiveChatId = jid;
+    if (addressed) await socket.sendPresenceUpdate?.("composing", jid).catch(() => {
+    });
+    const text = textOf(m);
+    if (!text.trim()) return;
+    await will.perceive({
+      text,
+      from: entityId,
+      thread: `whatsapp:${jid}`,
+      ...speaker ? { speaker } : {}
+    });
+  }
+  will.on("message", (m) => {
+    if (!closed) void deliver(m);
+  });
+  async function deliver(m) {
+    const peer = m.to ? roster.resolve(m.to) : void 0;
+    const chunks = chunkText(m.content, WHATSAPP_MESSAGE_LIMIT);
+    const derivedDm = m.to?.startsWith("whatsapp:") ? dmJidFor(m.to.slice("whatsapp:".length)) : void 0;
+    const targets = [peer?.lastChannelId, peer?.dmChannelId, derivedDm, opts.homeChatId ?? void 0, lastActiveChatId ?? void 0];
+    for (const jid of targets) {
+      if (!jid) continue;
+      try {
+        for (const chunk of chunks) await socket.sendMessage(jid, { text: chunk });
+        return;
+      } catch {
+      }
+    }
+    log(`no route for utterance to '${m.to}' \u2014 dropped (${m.content.length} chars)`);
+  }
+  return {
+    kind: "whatsapp",
+    async start() {
+      log(`${will.name} is present on WhatsApp${socket.user ? ` as ${bareId(socket.user.id)}` : ""}`);
+    },
+    async close() {
+      if (closed) return;
+      closed = true;
+      roster.flush();
+      try {
+        socket.end?.();
+      } catch {
+      }
+    }
+  };
+}
+async function createWhatsAppSocket(o) {
+  let baileys;
+  try {
+    baileys = await import('baileys');
+  } catch {
+    throw new Error("baileys is not installed (it is an optionalDependency) \u2014 run `bun add baileys` / `npm i baileys` and retry.");
+  }
+  const { default: makeWASocket, useMultiFileAuthState, DisconnectReason } = baileys;
+  const noop = () => {
+  };
+  const logger2 = {
+    level: "silent",
+    child() {
+      return logger2;
+    },
+    trace: noop,
+    debug: noop,
+    info: noop,
+    warn: noop,
+    error: noop,
+    fatal: noop
+  };
+  const subscribers = [];
+  let inner = null;
+  const facade = {
+    get user() {
+      return inner?.user ? { id: inner.user.id, name: inner.user.name ?? void 0 } : null;
+    },
+    ev: { on: (_e, fn) => {
+      subscribers.push(fn);
+    } },
+    sendMessage: (jid, content) => {
+      if (!inner) return Promise.reject(new Error("whatsapp socket not connected"));
+      return inner.sendMessage(jid, content);
+    },
+    sendPresenceUpdate: (state2, jid) => inner?.sendPresenceUpdate(state2, jid) ?? Promise.resolve(),
+    end: () => inner?.end(void 0)
+  };
+  const { state, saveCreds } = await useMultiFileAuthState(o.authPath);
+  await new Promise((resolveOpen, rejectOpen) => {
+    let opened = false;
+    function connect2() {
+      const sock = makeWASocket({ auth: state, logger: logger2 });
+      inner = sock;
+      sock.ev.on("creds.update", saveCreds);
+      sock.ev.on("messages.upsert", (u) => {
+        for (const fn of subscribers) fn(u);
+      });
+      sock.ev.on("connection.update", (update) => {
+        const { connection, lastDisconnect, qr } = update;
+        if (qr) void printQr(qr, o.log);
+        if (connection === "open" && !opened) {
+          opened = true;
+          resolveOpen();
+        }
+        if (connection === "close") {
+          const code = lastDisconnect?.error?.output?.statusCode;
+          if (code === DisconnectReason.loggedOut) {
+            const err = new Error("WhatsApp unlinked this device (logged out) \u2014 delete the auth dir and pair again.");
+            o.log(err.message);
+            if (!opened) rejectOpen(err);
+            return;
+          }
+          if (o.stillOpen()) {
+            o.log(`connection closed (status ${code ?? "?"}) \u2014 reconnecting\u2026`);
+            setTimeout(connect2, 3e3);
+          }
+        }
+      });
+    }
+    connect2();
+  });
+  return facade;
+}
+async function printQr(qr, log) {
+  log("pair this device: WhatsApp \u2192 Settings \u2192 Linked devices \u2192 Link a device");
+  try {
+    const qrt = await import('qrcode-terminal');
+    (qrt.default ?? qrt).generate(qr, { small: true });
+  } catch {
+    log(`qrcode-terminal not installed \u2014 raw pairing code:
+${qr}`);
+  }
+}
+
 // src/cli.ts
 routeLogsToStderr();
-var USAGE = `usage: will <mcp | serve | discord>
+var USAGE = `usage: will <mcp | serve | discord | whatsapp>
 
-  mcp      host a persistent mind over MCP stdio (Claude Desktop / Claude Code)
-  serve    host a persistent mind over HTTP (any language; WILL_PORT, default 7777)
-  discord  put a persistent mind in a Discord server (DISCORD_BOT_TOKEN; optional
-           WILL_DISCORD_CHANNELS, WILL_DISCORD_MENTION_ONLY, WILL_DISCORD_HOME_CHANNEL)
+  mcp       host a persistent mind over MCP stdio (Claude Desktop / Claude Code)
+  serve     host a persistent mind over HTTP (any language; WILL_PORT, default 7777)
+  discord   put a persistent mind in a Discord server (DISCORD_BOT_TOKEN; optional
+            WILL_DISCORD_CHANNELS, WILL_DISCORD_MENTION_ONLY, WILL_DISCORD_HOME_CHANNEL)
+  whatsapp  put a persistent mind on WhatsApp \u2014 QR-pairs as a linked device; no token.
+            UNOFFICIAL protocol (ban risk; use a spare number \u2014 docs/channels/whatsapp.md).
+            Optional WILL_WHATSAPP_CHATS, WILL_WHATSAPP_MENTION_ONLY, WILL_WHATSAPP_HOME_CHAT
 
 Shared env: WILL_NAME, WILL_IDENTITY, WILL_TIER, WILL_LLM, WILL_TICK_MS,
 WILL_SEED, WILL_PMA_PATH, WILL_MCP_SERVERS. The mind persists across runs via
 its PMA artifact.`;
 async function main() {
   const sub = process.argv[2];
-  if (sub !== "mcp" && sub !== "serve" && sub !== "discord") {
+  if (sub !== "mcp" && sub !== "serve" && sub !== "discord" && sub !== "whatsapp") {
     console.error(sub ? `unknown subcommand: ${sub}
 
 ${USAGE}` : USAGE);
@@ -26520,6 +26735,21 @@ ${USAGE}` : USAGE);
     console.error(`[will] ${name} is present on Discord (tick ${tickMs}ms, anatomy ${anatomy}) \u2014 it speaks when it decides to.`);
     return;
   }
+  if (sub === "whatsapp") {
+    const csv = (v) => v?.split(",").map((s) => s.trim()).filter(Boolean);
+    const stem = pmaPath.replace(/(\.pma)?\.json$/, "");
+    const bridge = await connectWhatsApp(will, {
+      chats: csv(process.env.WILL_WHATSAPP_CHATS),
+      mentionOnly: /^(1|true|yes)$/i.test(process.env.WILL_WHATSAPP_MENTION_ONLY ?? ""),
+      homeChatId: process.env.WILL_WHATSAPP_HOME_CHAT,
+      authPath: stem + ".wa-auth",
+      rosterPath: stem + ".whatsapp.json"
+    });
+    onCleanup(() => bridge.close());
+    await bridge.start();
+    console.error(`[will] ${name} is present on WhatsApp (tick ${tickMs}ms, anatomy ${anatomy}) \u2014 it speaks when it decides to.`);
+    return;
+  }
   const port = parseInt(process.env.WILL_PORT ?? "7777");
   const host = process.env.WILL_HOST ?? "127.0.0.1";
   const server = buildWillHttpServer(will, { pmaPath });