niahere 0.5.0 → 0.5.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "niahere",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "A personal AI assistant daemon — chat, scheduled jobs, persona system, extensible via skills.",
   "type": "module",
   "scripts": {
@@ -44,9 +44,9 @@
   "license": "MIT",
   "private": false,
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.3.190",
-    "@anthropic-ai/sdk": "^0.105.0",
-    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@anthropic-ai/claude-agent-sdk": "0.3.220",
+    "@anthropic-ai/sdk": "0.115.0",
+    "@modelcontextprotocol/sdk": "1.30.0",
     "@slack/bolt": "^4.6.0",
     "cron-parser": "^5.5.0",
     "grammy": "^1.41.1",

package/src/agent/backends/claude-normalize.ts

@@ -1,6 +1,21 @@
 import type { AgentEvent, Normalizer } from "../types";
 import { truncate } from "../../utils/format-activity";
 import { isRetryable, scopeOf, parseFailure } from "../failure";
+import type { FailoverScope } from "../types";
+
+/**
+ * Terminal reasons that mean the turn died. The SDK used to report several of
+ * these as `completed`, so a dead turn landed in the audit as a successful run.
+ * The value is how far the chain should skip; undefined means stop.
+ */
+const DEAD_TURNS: Record<string, FailoverScope | undefined> = {
+  api_error: "provider",
+  budget_exhausted: undefined,
+  malformed_tool_use_exhausted: undefined,
+  structured_output_retry_exhausted: undefined,
+  tool_deferred_unavailable: undefined,
+  turn_setup_failed: undefined,
+};
 
 /**
  * Pure reducer: Claude Agent SDK messages → normalized `AgentEvent`s.
@@ -41,6 +56,17 @@ export class SdkNormalizer implements Normalizer {
       return [];
     }
 
+    if (msg.type === "system" && msg.subtype === "compact_boundary") {
+      // Long sessions compact silently; surface it so the transcript records
+      // that history was summarized and how much was dropped.
+      const meta = msg.compact_metadata ?? {};
+      const trigger = meta.trigger === "manual" ? "manual" : "auto";
+      const pre = meta.pre_tokens ?? 0;
+      const post = meta.post_tokens;
+      const shrink = post !== undefined ? `${pre} → ${post} tokens` : `${pre} tokens`;
+      return [{ type: "thinking", delta: `context compacted (${trigger}, ${shrink})` }];
+    }
+
     if (msg.type === "system") {
       // Subagent/task lifecycle (subtype init handled above).
       if (msg.subtype === "task_started" && msg.description) {
@@ -98,6 +124,16 @@ export class SdkNormalizer implements Normalizer {
   }
 
   private consumeResult(msg: any): AgentEvent {
+    const deadTurn = msg.terminal_reason as string | undefined;
+    if (!msg.is_error && deadTurn && deadTurn in DEAD_TURNS) {
+      return {
+        type: "error",
+        message: (msg.errors?.join(", ") as string) || `turn ended: ${deadTurn}`,
+        retryable: false,
+        failover: DEAD_TURNS[deadTurn],
+        terminalReason: deadTurn,
+      };
+    }
     if (!msg.is_error) {
       return {
         type: "result",
@@ -126,7 +162,11 @@ export class SdkNormalizer implements Normalizer {
       type: "error",
       message: raw,
       retryable: isRetryable(raw),
-      failover: scopeOf(parseFailure(raw), "provider"),
+      // api_error_status is the reliable signal; prose is the fallback.
+      failover: scopeOf(
+        { ...parseFailure(raw), status: typeof msg.api_error_status === "number" ? msg.api_error_status : undefined },
+        "provider",
+      ),
       terminalReason: msg.terminal_reason,
     };
   }

package/src/agent/backends/claude.ts

@@ -1,4 +1,5 @@
 import { query } from "@anthropic-ai/claude-agent-sdk";
+import { asError } from "../../utils/errors";
 import { randomUUID } from "crypto";
 import { existsSync } from "fs";
 import { join } from "path";
@@ -126,7 +127,7 @@ class ClaudeSession implements AgentSession {
           res = await this.iterator!.next();
         } catch (err) {
           if (this.aborted) throw new Error(this.aborted);
-          throw err instanceof Error ? err : new Error(String(err));
+          throw asError(err);
         }
         if (this.aborted) throw new Error(this.aborted);
         if (res.done) {

package/src/agent/backends/codex-normalize.ts

@@ -14,6 +14,10 @@ import { scopeOf, parseFailure } from "../failure";
  * skill budget) and are dropped.
  */
 export class CodexNormalizer implements Normalizer {
+  /** The model this run was launched on, for usage attribution — codex's own
+   *  events don't name it. */
+  constructor(private readonly model?: string) {}
+
   private threadId = "";
   private agentText = "";
   private failed = false;
@@ -35,20 +39,30 @@ export class CodexNormalizer implements Normalizer {
         return this.fail(typeof e.message === "string" ? e.message : "");
       case "turn.failed":
         return this.fail(typeof e.error?.message === "string" ? e.error.message : "");
-      case "turn.completed":
+      case "turn.completed": {
+        const input = e.usage?.input_tokens ?? 0;
+        const output = e.usage?.output_tokens ?? 0;
         return [
           {
             type: "result",
             text: this.agentText,
-            usage: {
-              tokens: {
-                input: e.usage?.input_tokens ?? 0,
-                output: e.usage?.output_tokens ?? 0,
+            usage: { tokens: { input, output } },
+            backendSessionId: this.threadId,
+            // Same shape the Claude path emits, so one accumulator serves both
+            // and a failed-over turn is attributable to the provider that ran it.
+            metadata: {
+              model_usage: {
+                [this.model || "default"]: {
+                  provider: "codex",
+                  inputTokens: input,
+                  outputTokens: output,
+                  cacheReadInputTokens: e.usage?.cached_input_tokens ?? 0,
+                },
               },
             },
-            backendSessionId: this.threadId,
           },
         ];
+      }
       default:
         return [];
     }

package/src/agent/backends/codex.ts

@@ -7,6 +7,7 @@ import type { McpSourceContext } from "../../mcp";
 import { CodexNormalizer } from "./codex-normalize";
 import { mintRun, revokeRun } from "../mcp-endpoint";
 import { scopeOf, parseFailure } from "../failure";
+import { ignore } from "../../utils/errors";
 
 /**
  * Resolve the codex binary's absolute path. The daemon runs under launchd with a
@@ -200,7 +201,7 @@ class CodexSession implements AgentSession {
     // Started now, not after exit: an undrained pipe blocks the child.
     const stderr = drainStderr(proc.stderr);
 
-    const normalizer = new CodexNormalizer();
+    const normalizer = new CodexNormalizer(this.ctx.model);
     const stdout = proc.stdout.getReader();
     const lines = readLines(stdout)[Symbol.asyncIterator]();
     let sawTerminal = false;
@@ -256,7 +257,7 @@ class CodexSession implements AgentSession {
         };
       }
     } finally {
-      await stdout.cancel().catch(() => {});
+      await ignore(stdout.cancel(), "cancel codex stdout reader");
       revokeRun(token);
       this.proc = null;
     }

package/src/agent/failure.ts

@@ -82,8 +82,10 @@ function scopeOfStatus(status: number, message: string): FailoverScope | undefin
  */
 export function scopeOf(failure: Failure, blank?: FailoverScope): FailoverScope | undefined {
   const t = failure.message.trim();
-  if (!t || t.toLowerCase() === "unknown error") return blank;
+  // A status is authoritative even when the message is empty — the prose that
+  // accompanies a 429 or 529 is routinely unhelpful.
   if (failure.status !== undefined) return scopeOfStatus(failure.status, t);
+  if (!t || t.toLowerCase() === "unknown error") return blank;
   if (MODEL_SCOPED.some((p) => p.test(t))) return "model";
   if (PROVIDER_SCOPED.some((p) => p.test(t))) return "provider";
   return undefined;

package/src/agent/mcp-endpoint.ts

@@ -4,6 +4,7 @@ import { randomBytes, randomUUID } from "crypto";
 import type { NiaTool } from "../mcp/tools/types";
 import type { McpSourceContext } from "../mcp";
 import { log } from "../utils/log";
+import { ignore } from "../utils/errors";
 import { gateSideEffects } from "../mcp/gate";
 
 /**
@@ -93,8 +94,8 @@ export function revokeRun(token: string): void {
   const entry = runs.get(token);
   if (!entry) return;
   runs.delete(token);
-  entry.transport.close().catch(() => {});
-  entry.server.close().catch(() => {});
+  void ignore(entry.transport.close(), "close run transport");
+  void ignore(entry.server.close(), "close run server");
 }
 
 /** Test/diagnostic: number of live runs. */

package/src/channels/common/chat-session.ts

@@ -54,3 +54,63 @@ export async function rotateRoom(
 export function chainLock(state: ChatState, fn: () => Promise<void>): void {
   state.lock = state.lock.then(fn, fn);
 }
+
+/** Seam so the registry is testable without a database. */
+export interface SessionOpener {
+  open(prefix: string, build: EngineFactory): Promise<ChatState>;
+  rotate(prefix: string, prev: ChatState | undefined, build: EngineFactory): Promise<ChatState>;
+}
+
+const defaultOpener: SessionOpener = { open: openChatEngine, rotate: rotateRoom };
+
+/**
+ * A channel's per-sender chat sessions. Every message-driven channel keeps one
+ * of these keyed by sender, and they all want the same four things: open on
+ * first use, reuse after, rotate on `/reset`, close everything on shutdown.
+ */
+export class ChatSessions<K> {
+  private readonly states = new Map<K, ChatState>();
+
+  constructor(
+    private readonly prefixFor: (key: K) => string,
+    private readonly build: EngineFactory,
+    private readonly opener: SessionOpener = defaultOpener,
+  ) {}
+
+  /** `build` overrides the default options for this call — Slack needs it to
+   *  thread watch behavior and thread context into a newly opened engine. */
+  async get(key: K, build: EngineFactory = this.build): Promise<ChatState> {
+    const existing = this.states.get(key);
+    if (existing) return existing;
+    const state = await this.opener.open(this.prefixFor(key), build);
+    this.states.set(key, state);
+    return state;
+  }
+
+  /** Start a fresh room for this sender, closing the previous one. */
+  async rotate(key: K, build: EngineFactory = this.build): Promise<ChatState> {
+    const state = await this.opener.rotate(this.prefixFor(key), this.states.get(key), build);
+    this.states.set(key, state);
+    return state;
+  }
+
+  /** The cached session, without opening one. */
+  peek(key: K): ChatState | undefined {
+    return this.states.get(key);
+  }
+
+  /** Whether a session is already open — Slack uses it to tell a live thread
+   *  from one it should ignore. */
+  has(key: K): boolean {
+    return this.states.has(key);
+  }
+
+  keys(): Iterable<K> {
+    return this.states.keys();
+  }
+
+  closeAll(): void {
+    for (const state of this.states.values()) state.engine.close();
+    this.states.clear();
+  }
+}

package/src/channels/phone/consult.ts

@@ -6,6 +6,7 @@
  * Heavyweight (multi-second latency) by design — keep usage selective.
  */
 import Anthropic from "@anthropic-ai/sdk";
+import { errMsg } from "../../utils/errors";
 import { loadIdentity } from "../../chat/identity";
 import { log } from "../../utils/log";
 
@@ -38,6 +39,6 @@ export async function consultClaude(question: string, callerLabel: string): Prom
     return "(no answer)";
   } catch (err) {
     log.error({ err }, "phone: consult_claude failed");
-    return `error consulting Claude: ${err instanceof Error ? err.message : String(err)}`;
+    return `error consulting Claude: ${errMsg(err)}`;
   }
 }

package/src/channels/phone/index.ts

@@ -25,6 +25,7 @@ import type { ServerWebSocket } from "bun";
 import type { Channel, Outbound, PhoneConfig, TwilioConfig } from "../../types";
 import { getConfig } from "../../utils/config";
 import { log } from "../../utils/log";
+import { ignore } from "../../utils/errors";
 import { getChannel } from "../registry";
 import { Session, Message } from "../../db/models";
 import { runMigrations } from "../../db/migrate";
@@ -194,9 +195,10 @@ class PhoneChannel implements Channel {
 
     if (!allowed) {
       log.warn({ from, callSid }, "phone: rejecting unauthorized caller");
-      getChannel("telegram")
-        ?.deliver({ text: `Phone: rejected call from ${from} (CallSid ${callSid})` })
-        .catch(() => {});
+      const notice = getChannel("telegram")?.deliver({
+        text: `Phone: rejected call from ${from} (CallSid ${callSid})`,
+      });
+      if (notice) void ignore(notice, "notify rejected caller");
       return twimlResponse(sayAndHangupTwiML("Sorry, this line is not currently accepting calls. Goodbye."));
     }
 

package/src/channels/phone/relay.ts

@@ -12,6 +12,7 @@
  *   const result = await relay.completion;
  */
 import { log } from "../../utils/log";
+import { errMsg } from "../../utils/errors";
 
 export interface PhoneToolDefinition {
   name: string;
@@ -57,6 +58,17 @@ export interface RelayOpts {
   model: string;
   voice: string;
   context: CallContext;
+  /** Injectable so the bridge is testable without dialing OpenAI. */
+  openAiWsFactory?: (url: string, key: string) => OpenAiSocket;
+}
+
+/** The slice of the realtime socket the relay drives. */
+export interface OpenAiSocket extends WebSocketLike {
+  addEventListener(type: string, listener: (ev: any) => void): void;
+}
+
+function connectOpenAi(url: string, key: string): OpenAiSocket {
+  return new WebSocket(url, { headers: { Authorization: `Bearer ${key}` } } as any) as unknown as OpenAiSocket;
 }
 
 export interface WebSocketLike {
@@ -76,7 +88,7 @@ export interface RelayHandle {
 }
 
 export function createRelay(opts: RelayOpts): RelayHandle {
-  const { twilioWs, openAiKey, model, voice, context } = opts;
+  const { twilioWs, openAiKey, model, voice, context, openAiWsFactory = connectOpenAi } = opts;
   const transcript: TranscriptTurn[] = [];
   let endedReason: RelayEndReason = "twilio_stop";
   let errorMsg: string | undefined;
@@ -84,9 +96,7 @@ export function createRelay(opts: RelayOpts): RelayHandle {
   let pendingAssistantText = "";
 
   const openAiUrl = `wss://api.openai.com/v1/realtime?model=${encodeURIComponent(model)}`;
-  const openAiWs = new WebSocket(openAiUrl, {
-    headers: { Authorization: `Bearer ${openAiKey}` },
-  } as any);
+  const openAiWs = openAiWsFactory(openAiUrl, openAiKey);
 
   /** Whether a response is currently in flight on the OpenAI side. */
   let responseActive = false;
@@ -268,7 +278,7 @@ export function createRelay(opts: RelayOpts): RelayHandle {
           try {
             output = await tool.handler(args);
           } catch (err) {
-            output = `error: ${err instanceof Error ? err.message : String(err)}`;
+            output = `error: ${errMsg(err)}`;
             log.error({ err, callSid: context.callSid, toolName }, "phone tool handler failed");
           }
         }

package/src/channels/slack.ts

@@ -5,11 +5,14 @@ import { relativeTime } from "../utils/format";
 import { runMigrations } from "../db/migrate";
 import { Session, Message } from "../db/models";
 import { log } from "../utils/log";
+import { errMsg, ignore } from "../utils/errors";
 import { getMcpServers } from "../mcp";
-import { chainLock, openChatEngine, rotateRoom } from "./common/chat-session";
+import { ChatSessions, chainLock } from "./common/chat-session";
 import { SlackAttachmentCache } from "./slack/attachments";
 import { SlackWatchReloader } from "./slack/watch";
 
+const logActivity = (status: string) => log.debug({ status }, "slack engine activity");
+
 /** Strip markdown backticks so sentinel tokens like [NO_REPLY] match even when the LLM wraps them. */
 function cleanSentinel(text: string): string {
   return text.replace(/`/g, "").trim();
@@ -75,7 +78,7 @@ class SlackChannel implements Channel {
 
     this.dmUserId = config.channels.slack.dm_user_id;
 
-    const chats = new Map<string, ChatState>();
+    const chats = new ChatSessions<string>(roomPrefix, buildEngineOpts());
     const channelNames = new Map<string, string>();
 
     async function resolveChannelName(app: App, channelId: string): Promise<string> {
@@ -111,30 +114,20 @@ class SlackChannel implements Channel {
       });
     }
 
-    async function getState(
+    const getState = (
       key: string,
       watchBehavior?: { channel: string; behavior: string },
       slackCtx?: SlackContext,
-    ): Promise<ChatState> {
-      let state = chats.get(key);
-      if (state) return state;
-      state = await openChatEngine(roomPrefix(key), buildEngineOpts(watchBehavior, slackCtx));
-      chats.set(key, state);
-      return state;
-    }
+    ): Promise<ChatState> => chats.get(key, buildEngineOpts(watchBehavior, slackCtx));
 
-    async function restartChat(
+    const restartChat = (
       key: string,
       watchBehavior?: { channel: string; behavior: string },
       slackCtx?: SlackContext,
-    ): Promise<ChatState> {
-      const state = await rotateRoom(roomPrefix(key), chats.get(key), buildEngineOpts(watchBehavior, slackCtx));
-      chats.set(key, state);
-      return state;
-    }
+    ): Promise<ChatState> => chats.rotate(key, buildEngineOpts(watchBehavior, slackCtx));
 
     function withLock(key: string, fn: () => Promise<void>): void {
-      const state = chats.get(key);
+      const state = chats.peek(key);
       if (!state) {
         fn().catch((err) => log.error({ err, key }, "unhandled error in locked handler"));
         return;
@@ -177,13 +170,11 @@ class SlackChannel implements Channel {
         withLock(key, async () => {
           try {
             const { result } = await state.engine.send(subcommand, {
-              onActivity(status) {
-                log.debug({ status }, "slack engine activity");
-              },
+              onActivity: logActivity,
             });
             await respond(result.trim() || "(no response)");
           } catch (err) {
-            const errText = err instanceof Error ? err.message : String(err);
+            const errText = errMsg(err);
             await respond(`[error] ${errText}`);
           }
         });
@@ -437,9 +428,7 @@ class SlackChannel implements Channel {
           const { result, messageId, signal } = await state.engine.send(
             text,
             {
-              onActivity(status) {
-                log.debug({ status }, "slack engine activity");
-              },
+              onActivity: logActivity,
             },
             attachments,
           );
@@ -448,7 +437,7 @@ class SlackChannel implements Channel {
             await reactToSlackMessage(client, msg.channel, msg.ts, "skull").catch((err) =>
               log.debug({ err, channel: msg.channel }, "slack: failed to add provider-down reaction"),
             );
-            if (messageId) await Message.updateDeliveryStatus(messageId, "sent").catch(() => {});
+            if (messageId) await ignore(Message.updateDeliveryStatus(messageId, "sent"), "record sent delivery status");
             log.info({ channel: msg.channel, key, reaction: "skull" }, "slack provider failure sent as reaction");
             return;
           }
@@ -468,7 +457,7 @@ class SlackChannel implements Channel {
                 "slack: [NO_REPLY] sentinel mixed with content; suppressing send",
               );
             }
-            if (messageId) await Message.updateDeliveryStatus(messageId, "sent").catch(() => {});
+            if (messageId) await ignore(Message.updateDeliveryStatus(messageId, "sent"), "record sent delivery status");
             return;
           }
 
@@ -482,26 +471,27 @@ class SlackChannel implements Channel {
             } else {
               await say(reply);
             }
-            if (messageId) await Message.updateDeliveryStatus(messageId, "sent").catch(() => {});
+            if (messageId) await ignore(Message.updateDeliveryStatus(messageId, "sent"), "record sent delivery status");
             log.info({ channel: msg.channel, key, chars: reply.length }, "slack reply sent");
           } catch (sendErr) {
-            if (messageId) await Message.updateDeliveryStatus(messageId, "failed").catch(() => {});
+            if (messageId) await ignore(Message.updateDeliveryStatus(messageId, "failed"), "record failed delivery status");
             throw sendErr;
           }
         } catch (err) {
-          const errText = err instanceof Error ? err.message : String(err);
+          const errText = errMsg(err);
           log.error({ err, channel: msg.channel }, "slack message processing failed");
 
           if (replyThreadTs) {
-            await client.chat
-              .postMessage({
+            await ignore(
+              client.chat.postMessage({
                 channel: msg.channel,
                 text: `[error] ${errText}`,
                 thread_ts: replyThreadTs,
-              })
-              .catch(() => {});
+              }),
+              "reply engine error in thread",
+            );
           } else {
-            await say(`[error] ${errText}`).catch(() => {});
+            await ignore(say(`[error] ${errText}`), "reply engine error");
           }
         } finally {
           await client.reactions

package/src/channels/sms.ts

@@ -16,25 +16,29 @@
  */
 import { getMcpServers } from "../mcp";
 import { runMigrations } from "../db/migrate";
-import type { Channel, ChatState, Outbound, TwilioConfig } from "../types";
+import type { Channel, Outbound, TwilioConfig } from "../types";
 import { getConfig } from "../utils/config";
 import { log } from "../utils/log";
+import { errMsg, ignore } from "../utils/errors";
 import { sendMessage as twilioSendMessage } from "./twilio/rest";
 import { getTwilioServer } from "./twilio/server";
-import { chainLock, openChatEngine } from "./common/chat-session";
-
-const EMPTY_TWIML = '<?xml version="1.0" encoding="UTF-8"?><Response></Response>';
+import { ChatSessions, chainLock } from "./common/chat-session";
+import { ackTwiml, deliveryStatusAck, isAllowedSender } from "./twilio/shared";
 
 class SmsChannel implements Channel {
   name = "sms" as const;
   private readonly twilio: TwilioConfig;
   /** Cached resolved "from" number: sms.from_number || phone.from_number */
   private readonly fromNumber: string;
-  private readonly chats = new Map<string, ChatState>();
+  private readonly chats: ChatSessions<string>;
 
   constructor(twilio: TwilioConfig, fromNumber: string) {
     this.twilio = twilio;
     this.fromNumber = fromNumber;
+    this.chats = new ChatSessions((remote) => `sms-${remote}`, () => ({
+      channel: "sms",
+      mcpServers: getMcpServers(),
+    }));
   }
 
   async start(): Promise<void> {
@@ -70,8 +74,7 @@ class SmsChannel implements Channel {
   }
 
   async stop(): Promise<void> {
-    for (const state of this.chats.values()) state.engine.close();
-    this.chats.clear();
+    this.chats.closeAll();
   }
 
   /** Outbound — used by send_message MCP tool. SMS is text-only; media is dropped with a warning. */
@@ -92,12 +95,12 @@ class SmsChannel implements Channel {
     const from = params.From || "";
     const body = params.Body || "";
 
-    if (!this.isAllowed(from)) {
+    if (!isAllowedSender(this.twilio, from)) {
       log.warn({ from }, "sms: rejecting non-allowlisted sender");
-      return new Response(EMPTY_TWIML, { status: 200, headers: { "Content-Type": "text/xml" } });
+      return ackTwiml();
     }
 
-    const state = await this.getState(from);
+    const state = await this.chats.get(from);
     // Ack the webhook immediately; reply via REST asynchronously to avoid
     // Twilio's ~15s webhook timeout when the engine takes longer.
     chainLock(state, async () => {
@@ -107,24 +110,15 @@ class SmsChannel implements Channel {
         await this.sendTo(from, reply);
       } catch (err) {
         log.error({ err, from }, "sms: engine error");
-        await this.sendTo(from, `[error] ${err instanceof Error ? err.message : String(err)}`).catch(() => {});
+        await ignore(this.sendTo(from, `[error] ${errMsg(err)}`), "reply engine error");
       }
     });
 
-    return new Response(EMPTY_TWIML, { status: 200, headers: { "Content-Type": "text/xml" } });
+    return ackTwiml();
   }
 
   private handleStatus(params: Record<string, string>): Response {
-    log.info(
-      {
-        messageSid: params.MessageSid,
-        status: params.MessageStatus,
-        errorCode: params.ErrorCode,
-        to: params.To,
-      },
-      "sms: delivery status",
-    );
-    return new Response("", { status: 204 });
+    return deliveryStatusAck("sms", params);
   }
 
   // --- Outbound ---
@@ -153,20 +147,6 @@ class SmsChannel implements Channel {
     }
   }
 
-  // --- Helpers ---
-
-  private isAllowed(remoteE164: string): boolean {
-    if (this.twilio.owner_number && remoteE164 === this.twilio.owner_number) return true;
-    return this.twilio.allowlist.includes(remoteE164);
-  }
-
-  private async getState(remoteE164: string): Promise<ChatState> {
-    let state = this.chats.get(remoteE164);
-    if (state) return state;
-    state = await openChatEngine(`sms-${remoteE164}`, () => ({ channel: "sms", mcpServers: getMcpServers() }));
-    this.chats.set(remoteE164, state);
-    return state;
-  }
 }
 
 export function createSmsChannel(): SmsChannel | null {