@band-ai/sdk 0.1.4 → 0.1.10

package/dist/index.cjs

@@ -133,6 +133,114 @@ var init_chatEvents = __esm({
   }
 });
 
+// src/contracts/memory.ts
+function namedValues(values) {
+  return Object.fromEntries(values.map((value) => [value, value]));
+}
+function isMemorySystem(value) {
+  return MEMORY_SYSTEMS.includes(value);
+}
+function isMemoryType(value) {
+  return MEMORY_TYPES.includes(value);
+}
+function isMemoryTypeForSystem(system, type) {
+  return MEMORY_SYSTEM_TYPES[system].includes(type);
+}
+function isMemorySegment(value) {
+  return MEMORY_SEGMENTS.includes(value);
+}
+function isMemoryStoreScope(value) {
+  return MEMORY_STORE_SCOPES.includes(value);
+}
+function isMemoryListScope(value) {
+  return MEMORY_LIST_SCOPES.includes(value);
+}
+function isMemoryStatus(value) {
+  return MEMORY_STATUSES.includes(value);
+}
+function expectedList(values) {
+  return values.join(", ");
+}
+function expectedMemoryTypesForSystem(system) {
+  return expectedList(MEMORY_SYSTEM_TYPES[system]);
+}
+function memoryTypeForSystemError(system) {
+  return `type must be one of: ${expectedMemoryTypesForSystem(system)} for system "${system}"`;
+}
+var SENSORY_MEMORY_TYPES, COGNITIVE_MEMORY_TYPES, MEMORY_SYSTEM_TYPES, MEMORY_SYSTEMS, MEMORY_TYPES, MEMORY_SEGMENTS, MEMORY_STORE_SCOPES, MEMORY_LIST_SCOPES, MEMORY_STATUSES, MEMORY_SYSTEM, MEMORY_TYPE, MEMORY_SEGMENT, MEMORY_STORE_SCOPE;
+var init_memory = __esm({
+  "src/contracts/memory.ts"() {
+    "use strict";
+    SENSORY_MEMORY_TYPES = [
+      "iconic",
+      // Visual input
+      "echoic",
+      // Auditory input
+      "haptic"
+      // Tactile input
+    ];
+    COGNITIVE_MEMORY_TYPES = [
+      "episodic",
+      // Events that occurred
+      "semantic",
+      // Facts, preferences, learned knowledge
+      "procedural"
+      // How to perform tasks
+    ];
+    MEMORY_SYSTEM_TYPES = {
+      sensory: SENSORY_MEMORY_TYPES,
+      // Brief sensory inputs
+      working: COGNITIVE_MEMORY_TYPES,
+      // Short-term session context
+      long_term: COGNITIVE_MEMORY_TYPES
+      // Persistent cross-conversation memory
+    };
+    MEMORY_SYSTEMS = Object.keys(MEMORY_SYSTEM_TYPES);
+    MEMORY_TYPES = [
+      ...SENSORY_MEMORY_TYPES,
+      ...COGNITIVE_MEMORY_TYPES
+    ];
+    MEMORY_SEGMENTS = [
+      "user",
+      // User preferences or profile info
+      "agent",
+      // Facts or events about agents/entities
+      "tool",
+      // Tool usage or task procedures
+      "guideline"
+      // Behavioral rules or policies
+    ];
+    MEMORY_STORE_SCOPES = [
+      "subject",
+      // About one person/agent; requires subject_id
+      "organization"
+      // Shared org-wide
+    ];
+    MEMORY_LIST_SCOPES = [
+      "subject",
+      // Subject-scoped memories only
+      "organization",
+      // Organization-scoped memories only
+      "all"
+      // Both scopes (no scope filter)
+    ];
+    MEMORY_STATUSES = [
+      "active",
+      // Normal, visible memories
+      "superseded",
+      // Outdated; soft-deleted via thenvoi_supersede_memory
+      "archived",
+      // Hidden but preserved via thenvoi_archive_memory
+      "all"
+      // Any status (no filter)
+    ];
+    MEMORY_SYSTEM = namedValues(MEMORY_SYSTEMS);
+    MEMORY_TYPE = namedValues(MEMORY_TYPES);
+    MEMORY_SEGMENT = namedValues(MEMORY_SEGMENTS);
+    MEMORY_STORE_SCOPE = namedValues(MEMORY_STORE_SCOPES);
+  }
+});
+
 // src/runtime/tools/schemas.ts
 function mcpToolNames(names) {
   return [...names].sort((a, b) => a.localeCompare(b)).map((name) => `${MCP_TOOL_PREFIX}${name}`);
@@ -146,6 +254,7 @@ var init_schemas = __esm({
   "src/runtime/tools/schemas.ts"() {
     "use strict";
     init_chatEvents();
+    init_memory();
     TOOL_MODELS = {
       thenvoi_send_message: {
         description: "Send a message to the chat room. Use this to respond to users or other agents. Messages require at least one @mention in the mentions array. You MUST use this tool to communicate \u2014 plain text responses won't reach users. When delegating, send the full task context in this message instead of assuming hidden state.",
@@ -332,29 +441,22 @@ var init_schemas = __esm({
           },
           scope: {
             type: "string",
-            enum: ["subject", "organization", "all"],
+            enum: [...MEMORY_LIST_SCOPES],
             description: "Filter by scope."
           },
           system: {
             type: "string",
-            enum: ["sensory", "working", "long_term"],
+            enum: [...MEMORY_SYSTEMS],
             description: "Filter by memory system."
           },
           type: {
             type: "string",
-            enum: [
-              "iconic",
-              "echoic",
-              "haptic",
-              "episodic",
-              "semantic",
-              "procedural"
-            ],
+            enum: [...MEMORY_TYPES],
             description: "Filter by memory type."
           },
           segment: {
             type: "string",
-            enum: ["user", "agent", "tool", "guideline"],
+            enum: [...MEMORY_SEGMENTS],
             description: "Filter by segment."
           },
           content_query: {
@@ -369,7 +471,7 @@ var init_schemas = __esm({
           },
           status: {
             type: "string",
-            enum: ["active", "superseded", "archived", "all"],
+            enum: [...MEMORY_STATUSES],
             description: "Filter by status."
           }
         },
@@ -384,24 +486,17 @@ var init_schemas = __esm({
           },
           system: {
             type: "string",
-            enum: ["sensory", "working", "long_term"],
+            enum: [...MEMORY_SYSTEMS],
             description: "Memory system tier."
           },
           type: {
             type: "string",
-            enum: [
-              "iconic",
-              "echoic",
-              "haptic",
-              "episodic",
-              "semantic",
-              "procedural"
-            ],
+            enum: [...MEMORY_TYPES],
             description: "Memory type (must be valid for selected system)."
           },
           segment: {
             type: "string",
-            enum: ["user", "agent", "tool", "guideline"],
+            enum: [...MEMORY_SEGMENTS],
             description: "Logical segment."
           },
           thought: {
@@ -410,7 +505,7 @@ var init_schemas = __esm({
           },
           scope: {
             type: "string",
-            enum: ["subject", "organization"],
+            enum: [...MEMORY_STORE_SCOPES],
             description: "Visibility scope."
           },
           subject_id: {
@@ -598,6 +693,13 @@ function serializeValue(value) {
     return String(value);
   }
 }
+function resolveSingleRoomTools(getToolsForRoom) {
+  const tools = getToolsForRoom("");
+  if (!tools) {
+    throw new Error('Single-room mode requires getToolsForRoom("") to return a tools instance');
+  }
+  return tools;
+}
 var init_registrations = __esm({
   "src/mcp/registrations.ts"() {
     "use strict";
@@ -607,42 +709,42 @@ var init_registrations = __esm({
 });
 
 // src/mcp/zod.ts
-function buildZodShape(z5, properties, required) {
+function buildZodShape(z6, properties, required) {
   const shape = {};
   for (const [name, schema] of Object.entries(properties)) {
-    const validator = jsonSchemaToZod(z5, schema);
+    const validator = jsonSchemaToZod(z6, schema);
     shape[name] = required.has(name) ? validator : validator.optional();
   }
   return shape;
 }
-function jsonSchemaToZod(z5, schema) {
+function jsonSchemaToZod(z6, schema) {
   const type = schema.type;
   if (type === "string") {
     if (Array.isArray(schema.enum) && schema.enum.every((v) => typeof v === "string")) {
       const values = schema.enum;
       if (values.length > 0) {
-        return z5.enum(values);
+        return z6.enum(values);
       }
     }
-    return z5.string();
+    return z6.string();
   }
   if (type === "integer" || type === "number") {
-    return z5.number();
+    return z6.number();
   }
   if (type === "boolean") {
-    return z5.boolean();
+    return z6.boolean();
   }
   if (type === "array") {
     const itemSchema = schema.items;
     if (itemSchema && typeof itemSchema === "object") {
-      return z5.array(jsonSchemaToZod(z5, itemSchema));
+      return z6.array(jsonSchemaToZod(z6, itemSchema));
     }
-    return z5.array(z5.unknown());
+    return z6.array(z6.unknown());
   }
   if (type === "object") {
-    return z5.record(z5.string(), z5.unknown());
+    return z6.record(z6.string(), z6.unknown());
   }
-  return z5.unknown();
+  return z6.unknown();
 }
 var init_zod = __esm({
   "src/mcp/zod.ts"() {
@@ -656,16 +758,16 @@ __export(sdk_exports, {
   createThenvoiSdkMcpServer: () => createThenvoiSdkMcpServer
 });
 function createThenvoiSdkMcpServer(options) {
-  const registrations = buildRoomScopedRegistrations(
-    options.getToolsForRoom,
-    {
-      enableMemoryTools: options.enableMemoryTools,
-      enableContactTools: true,
-      additionalTools: options.additionalTools
-    }
-  );
+  const registrationOptions = {
+    enableMemoryTools: options.enableMemoryTools,
+    enableContactTools: true,
+    additionalTools: options.additionalTools
+  };
+  const registrations = options.multiRoom === false ? buildSingleContextRegistrations(resolveSingleRoomTools(options.getToolsForRoom), registrationOptions) : buildRoomScopedRegistrations(options.getToolsForRoom, registrationOptions);
   const toolDefinitions = registrations.map(toSdkToolDefinition);
   const toolNames = new Set(registrations.map((r) => r.name));
+  const contextCache = /* @__PURE__ */ new Map();
+  const MAX_CONTEXT_CACHE_ENTRIES = 100;
   const serverConfig = (0, import_claude_agent_sdk.createSdkMcpServer)({
     name: "thenvoi",
     tools: toolDefinitions
@@ -673,12 +775,208 @@ function createThenvoiSdkMcpServer(options) {
   return {
     serverConfig,
     allowedTools: mcpToolNames(toolNames),
-    toolDefinitions
+    toolDefinitions,
+    getSystemPromptContext: async (roomId, contextOptions) => {
+      const context = await getOrBuildSystemPromptContext(
+        roomId,
+        contextOptions,
+        options.getToolsForRoom,
+        contextCache,
+        MAX_CONTEXT_CACHE_ENTRIES
+      );
+      return context.markdown;
+    },
+    getSystemPromptContextData: (roomId, contextOptions) => {
+      return getOrBuildSystemPromptContext(
+        roomId,
+        contextOptions,
+        options.getToolsForRoom,
+        contextCache,
+        MAX_CONTEXT_CACHE_ENTRIES
+      );
+    }
+  };
+}
+async function getOrBuildSystemPromptContext(roomId, contextOptions, getToolsForRoom, contextCache, maxEntries) {
+  const ttlMs = contextOptions?.ttlMs ?? 3e4;
+  const now = Date.now();
+  const cached = contextCache.get(roomId);
+  if (cached && cached.expiresAt > now) {
+    cached.lastAccessedAt = now;
+    return cached.value;
+  }
+  if (cached) {
+    contextCache.delete(roomId);
+  }
+  const tools = getToolsForRoom(roomId);
+  if (!tools) {
+    return buildUnavailableSystemPromptContext(roomId);
+  }
+  const context = await buildSystemPromptContext(roomId, tools);
+  contextCache.set(roomId, {
+    value: context,
+    expiresAt: now + ttlMs,
+    lastAccessedAt: now
+  });
+  evictLeastRecentlyUsedContext(contextCache, maxEntries);
+  return context;
+}
+async function buildSystemPromptContext(roomId, tools) {
+  const participants = await tools.getParticipants();
+  const warnings = [];
+  const agentResolution = await resolveAgentIdentity(tools);
+  if (agentResolution.warning) {
+    warnings.push(agentResolution.warning);
+  }
+  const roomResolution = await resolveRoomTitle(tools, roomId);
+  if (roomResolution.warning) {
+    warnings.push(roomResolution.warning);
+  }
+  const agentIdentity = agentResolution.value;
+  const roomTitle = roomResolution.value;
+  const normalizedParticipants = participants.map((participant) => ({
+    id: String(participant.id),
+    name: String(participant.name ?? "Unknown"),
+    type: String(participant.type ?? "Unknown"),
+    handle: normalizeHandle2(participant.handle),
+    isSelf: participant.id === agentIdentity?.id
+  }));
+  const selfHandle = normalizeHandle2(agentIdentity?.handle);
+  const selfName = agentIdentity?.name ?? "Agent";
+  const mentionHandles = normalizedParticipants.filter((participant) => !participant.isSelf).map((participant) => participant.handle).filter((handle) => Boolean(handle));
+  const mentionFormat = mentionHandles.length > 0 ? mentionHandles.join(", ") : "No participant handles available";
+  const roomLabel = roomTitle ? `"${roomTitle}"` : "this room";
+  const agentLabel = selfHandle ? `${selfName} (${selfHandle})` : selfName;
+  const participantLines = normalizedParticipants.length > 0 ? normalizedParticipants.map((participant) => {
+    const suffix = participant.isSelf ? " (you)" : "";
+    const handle = participant.handle ? ` (${participant.handle})` : "";
+    return `- **${participant.name}**${handle} -- ${participant.type}${suffix}`;
+  }).join("\n") : "- No participants found";
+  const markdown = [
+    "## Room Context",
+    "",
+    `You are **${agentLabel}** in room ${roomLabel} (id: ${roomId}).`,
+    "",
+    "### Participants",
+    participantLines,
+    "",
+    "### Mention Format",
+    `To address someone, use their exact handle: ${mentionFormat}`,
+    ...warnings.length > 0 ? ["", "### Warnings", ...warnings.map((warning) => `- ${warning}`)] : []
+  ].join("\n");
+  return {
+    roomId,
+    roomTitle,
+    agent: {
+      id: agentIdentity?.id ?? "unknown-agent",
+      name: selfName,
+      handle: selfHandle,
+      description: agentIdentity?.description ?? null
+    },
+    participants: normalizedParticipants,
+    mentionFormat,
+    warnings,
+    markdown
+  };
+}
+async function resolveAgentIdentity(tools) {
+  const maybeTools = tools;
+  try {
+    if (maybeTools.getAgentIdentity) {
+      return { value: await maybeTools.getAgentIdentity(), warning: null };
+    }
+    if (maybeTools.rest?.getAgentMe) {
+      return { value: await maybeTools.rest.getAgentMe(), warning: null };
+    }
+  } catch (error) {
+    return {
+      value: null,
+      warning: `Unable to resolve agent identity: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+  return { value: null, warning: null };
+}
+async function resolveRoomTitle(tools, roomId) {
+  const maybeTools = tools;
+  const rest = maybeTools.rest;
+  if (!rest?.listChats) {
+    return { value: null, warning: null };
+  }
+  try {
+    let page = 1;
+    const pageSize = 100;
+    while (true) {
+      const response = await rest.listChats({ page, pageSize });
+      const room = response?.data?.find((entry) => entry.id === roomId);
+      if (typeof room?.title === "string" && room.title.length > 0) {
+        return { value: room.title, warning: null };
+      }
+      const totalPages = response?.metadata?.totalPages ?? page;
+      if (page >= totalPages) {
+        return { value: null, warning: null };
+      }
+      page += 1;
+    }
+  } catch (error) {
+    return {
+      value: null,
+      warning: `Unable to resolve room title: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+function buildUnavailableSystemPromptContext(roomId) {
+  const warnings = [`No tool context found for room_id ${roomId}`];
+  const markdown = [
+    "## Room Context",
+    "",
+    `You are **Agent** in this room (id: ${roomId}).`,
+    "",
+    "### Participants",
+    "- No participants found",
+    "",
+    "### Mention Format",
+    "No participant handles available",
+    "",
+    "### Warnings",
+    ...warnings.map((warning) => `- ${warning}`)
+  ].join("\n");
+  return {
+    roomId,
+    roomTitle: null,
+    agent: {
+      id: "unknown-agent",
+      name: "Agent",
+      handle: null,
+      description: null
+    },
+    participants: [],
+    mentionFormat: "No participant handles available",
+    warnings,
+    markdown
   };
 }
+function evictLeastRecentlyUsedContext(contextCache, maxEntries) {
+  if (contextCache.size <= maxEntries) {
+    return;
+  }
+  let oldestKey = null;
+  let oldestAccessedAt = Number.POSITIVE_INFINITY;
+  for (const [key, entry] of contextCache.entries()) {
+    if (entry.lastAccessedAt < oldestAccessedAt) {
+      oldestAccessedAt = entry.lastAccessedAt;
+      oldestKey = key;
+    }
+  }
+  if (oldestKey) {
+    contextCache.delete(oldestKey);
+  }
+}
+function normalizeHandle2(handle) {
+  return typeof handle === "string" && handle.trim().length > 0 ? handle.trim() : null;
+}
 function toSdkToolDefinition(registration) {
   const shape = buildZodShape(
-    import_zod6.z,
+    import_zod7.z,
     registration.inputSchema.properties,
     new Set(registration.inputSchema.required)
   );
@@ -689,12 +987,12 @@ function toSdkToolDefinition(registration) {
     async (args) => registration.execute(args)
   );
 }
-var import_claude_agent_sdk, import_zod6;
+var import_claude_agent_sdk, import_zod7;
 var init_sdk = __esm({
   "src/mcp/sdk.ts"() {
     "use strict";
     import_claude_agent_sdk = require("@anthropic-ai/claude-agent-sdk");
-    import_zod6 = require("zod");
+    import_zod7 = require("zod");
     init_schemas();
     init_registrations();
     init_zod();
@@ -729,6 +1027,8 @@ __export(src_exports, {
   TOOL_MODELS: () => TOOL_MODELS,
   ThenvoiLink: () => ThenvoiLink,
   VercelAISDKAdapter: () => VercelAISDKAdapter,
+  WebSocketDisconnectError: () => WebSocketDisconnectError,
+  deriveDefaultRestUrl: () => deriveDefaultRestUrl,
   isDirectExecution: () => isDirectExecution,
   loadAgentConfig: () => loadAgentConfig,
   loadAgentConfigFromEnv: () => loadAgentConfigFromEnv
@@ -1758,56 +2058,242 @@ var payloadSchemas = {
 
 // src/platform/streaming/PhoenixChannelsTransport.ts
 var import_phoenix = require("phoenix");
-var import_ws = require("ws");
 init_errors();
+
+// src/platform/streaming/disconnectReason.ts
+var import_zod2 = require("zod");
+var UPGRADE_CODES = [
+  "invalid_on_conflict",
+  "connection_conflict",
+  "too_many_requests",
+  "tracking_failed"
+];
+var UPGRADE_REASONS = {
+  invalid_on_conflict: {
+    status: 400,
+    message: "Invalid websocket conflict policy.",
+    retryable: false
+  },
+  connection_conflict: {
+    status: 409,
+    message: "Websocket connection conflict.",
+    retryable: false
+  },
+  too_many_requests: {
+    status: 429,
+    message: "Too many websocket connection attempts.",
+    retryable: true
+  },
+  tracking_failed: {
+    status: 503,
+    message: "Websocket connection tracking failed.",
+    retryable: true
+  }
+};
+var upgradeErrorSchema = import_zod2.z.object({
+  status: import_zod2.z.number(),
+  body: import_zod2.z.preprocess(
+    (body) => {
+      if (typeof body !== "string") {
+        return body;
+      }
+      try {
+        return JSON.parse(body);
+      } catch {
+        return null;
+      }
+    },
+    import_zod2.z.object({
+      error: import_zod2.z.object({
+        code: import_zod2.z.enum(UPGRADE_CODES),
+        message: import_zod2.z.string().optional(),
+        retry_after: import_zod2.z.number().nullable().optional(),
+        request_id: import_zod2.z.string().nullable().optional()
+      })
+    })
+  ),
+  headers: import_zod2.z.record(import_zod2.z.unknown()).optional()
+});
+var WebSocketDisconnectError = class extends Error {
+  reason;
+  constructor(reason) {
+    super(reason.message);
+    this.name = "WebSocketDisconnectError";
+    this.reason = reason;
+  }
+};
+function parseSupersedeDisconnectReason(payload) {
+  if (typeof payload.reason !== "string" || typeof payload.message !== "string") {
+    return null;
+  }
+  return {
+    source: "agent_control",
+    code: payload.reason,
+    message: payload.message,
+    retryable: false,
+    retryAfter: typeof payload.retry_after === "number" ? payload.retry_after : null,
+    targetSocketId: typeof payload.target_socket_id === "string" ? payload.target_socket_id : null,
+    correlationId: typeof payload.correlation_id === "string" ? payload.correlation_id : null
+  };
+}
+function parseUpgradeDisconnectReason(event) {
+  const parsed = upgradeErrorSchema.safeParse(event);
+  if (!parsed.success) {
+    return null;
+  }
+  const { status, body, headers } = parsed.data;
+  const {
+    code,
+    message,
+    retry_after: retryAfter,
+    request_id: requestId
+  } = body.error;
+  const reason = UPGRADE_REASONS[code];
+  if (status !== reason.status) {
+    return null;
+  }
+  return {
+    source: "upgrade",
+    status: reason.status,
+    code,
+    message: message ?? reason.message,
+    retryable: reason.retryable,
+    retryAfter: retryAfter ?? retryAfterFromHeaders(headers),
+    requestId: requestId ?? null
+  };
+}
+function genericCloseReason(event) {
+  return {
+    source: "websocket_close",
+    code: "websocket.closed",
+    message: "Phoenix socket closed without a platform disconnect reason.",
+    retryable: true,
+    closeCode: typeof event?.code === "number" ? event.code : null,
+    closeReason: typeof event?.reason === "string" && event.reason.length > 0 ? event.reason : null
+  };
+}
+function retryAfterFromHeaders(headers) {
+  const value = headers?.["retry-after"] ?? headers?.["Retry-After"];
+  if (typeof value === "number") {
+    return value;
+  }
+  if (typeof value === "string" && value.trim() !== "") {
+    const seconds = Number(value);
+    return Number.isFinite(seconds) ? seconds : null;
+  }
+  return null;
+}
+
+// src/platform/streaming/nodeWebSocketFactory.ts
+var import_ws = require("ws");
+function createNodeWebSocketFactory(headers) {
+  const Constructor = import_ws.WebSocket;
+  class ThenvoiNodeWebSocket {
+    constructor(address, protocols) {
+      const socket = new Constructor(address, protocols, headers ? { headers } : void 0);
+      socket.once("unexpected-response", (request, response) => {
+        void emitUpgradeError(socket, request, response);
+      });
+      return socket;
+    }
+  }
+  return ThenvoiNodeWebSocket;
+}
+async function emitUpgradeError(websocket, request, response) {
+  const body = await readResponseBody(response);
+  const error = new Error(
+    `Unexpected server response: ${response.statusCode ?? "unknown"}`
+  );
+  error.status = response.statusCode;
+  error.body = body;
+  error.headers = response.headers;
+  request.destroy();
+  websocket.emit("error", error);
+  websocket.emit("close", 1006, Buffer.alloc(0));
+}
+async function readResponseBody(response) {
+  const chunks = [];
+  for await (const chunk of response) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+
+// src/platform/streaming/PhoenixChannelsTransport.ts
 var PhoenixChannelsTransport = class {
   socket;
+  agentId;
   channels = /* @__PURE__ */ new Map();
   channelRefs = /* @__PURE__ */ new Map();
   pendingJoins = /* @__PURE__ */ new Map();
   logger;
+  onTerminalDisconnect;
   onHandlerError;
   connected = false;
   connectPromise = null;
   connectResolve = null;
+  connectReject = null;
+  lastDisconnectReason = null;
+  terminalDisconnectError = null;
+  runForeverWaiters = /* @__PURE__ */ new Set();
+  stoppingReconnect = false;
+  suppressNextCloseReason = false;
   constructor(options) {
     this.logger = options.logger ?? new NoopLogger();
+    this.agentId = options.agentId;
+    this.onTerminalDisconnect = options.onTerminalDisconnect;
     let wsUrl = options.wsUrl;
     if (wsUrl.endsWith("/websocket")) {
       wsUrl = wsUrl.slice(0, -"/websocket".length);
     }
+    const reconnectAfterMs = options.reconnectAfterMs ?? ((tries) => [1e3, 2e3, 5e3, 1e4, 3e4][tries - 1] ?? 3e4);
     this.socket = new import_phoenix.Socket(wsUrl, {
       params: {
-        api_key: options.apiKey,
-        agent_id: options.agentId
+        agent_id: options.agentId,
+        ...options.conflictPolicy ? { on_conflict: options.conflictPolicy } : {}
       },
       heartbeatIntervalMs: options.heartbeatIntervalMs,
-      reconnectAfterMs: options.reconnectAfterMs ?? ((tries) => [1e3, 2e3, 5e3, 1e4, 3e4][tries - 1] ?? 3e4),
-      transport: options.websocketFactory ?? resolveWebSocketFactory()
+      reconnectAfterMs: (tries) => {
+        if (this.terminalDisconnectError) {
+          return Number.POSITIVE_INFINITY;
+        }
+        return reconnectAfterMs(tries);
+      },
+      transport: options.websocketFactory ?? resolveWebSocketFactory(options.apiKey)
     });
     this.socket.onOpen(() => {
-      this.connected = true;
-      this.connectResolve?.();
-      this.connectResolve = null;
-      this.logger.info("Phoenix socket opened", {
-        channels: getSocketChannelCount(this.socket)
-      });
+      void this.handleOpen();
     });
     this.socket.onClose((event) => {
-      this.connected = false;
-      if (getSocketChannelCount(this.socket) === 0) {
-        this.socket.disconnect();
-      }
-      this.logger.info("Phoenix socket closed", {
-        code: event?.code ?? null,
-        reason: event?.reason ?? null
-      });
+      this.recordSocketClose(event);
     });
     this.socket.onError((event) => {
+      const errorEvent = unwrapErrorEvent(event);
+      const upgradeReason = parseUpgradeDisconnectReason(errorEvent);
+      if (upgradeReason) {
+        if (upgradeReason.retryable) {
+          this.lastDisconnectReason = upgradeReason;
+          this.connectReject?.(new WebSocketDisconnectError(upgradeReason));
+          this.stopReconnectIfNoChannels({ suppressCloseReason: true });
+        } else {
+          this.recordTerminalDisconnect(upgradeReason);
+        }
+        this.logger.warn("Phoenix socket upgrade failed", {
+          reason: upgradeReason
+        });
+        return;
+      }
+      this.connectReject?.(
+        new TransportError("Phoenix socket connection failed", errorEvent)
+      );
+      this.stopReconnectIfNoChannels({ suppressCloseReason: true });
       this.logger.warn("Phoenix socket error", { event });
     });
   }
   async connect() {
+    if (this.terminalDisconnectError) {
+      throw this.terminalDisconnectError;
+    }
     if (this.connected) {
       return;
     }
@@ -1831,15 +2317,30 @@ var PhoenixChannelsTransport = class {
     await this.connectPromise;
   }
   async disconnect() {
-    for (const topic of this.channels.keys()) {
-      await this.leave(topic);
-    }
+    const results = await Promise.allSettled(
+      [...this.channels.keys()].map((topic) => this.leave(topic))
+    );
     this.socket.disconnect();
     this.connected = false;
+    const failures = [];
+    for (const result of results) {
+      if (result.status === "rejected") {
+        failures.push(result.reason);
+      }
+    }
+    if (failures.length > 0) {
+      throw new AggregateError(
+        failures,
+        "Failed to leave one or more Phoenix topics during disconnect"
+      );
+    }
   }
   isConnected() {
     return this.connected;
   }
+  getDisconnectReason() {
+    return this.lastDisconnectReason;
+  }
   async join(topic, handlers) {
     if (this.channels.has(topic)) {
       return;
@@ -1875,7 +2376,10 @@ var PhoenixChannelsTransport = class {
         channel.join().receive("ok", () => resolve()).receive(
           "error",
           (error) => reject(new TransportError(`Failed to join topic ${topic}`, error))
-        ).receive("timeout", () => reject(new TransportError(`Timeout joining topic ${topic}`)));
+        ).receive(
+          "timeout",
+          () => reject(new TransportError(`Timeout joining topic ${topic}`))
+        );
       });
     } catch (error) {
       for (const [event, ref] of refs) {
@@ -1903,19 +2407,127 @@ var PhoenixChannelsTransport = class {
       channel.leave().receive("ok", () => resolve()).receive(
         "error",
         (error) => reject(new TransportError(`Failed to leave topic ${topic}`, error))
-      ).receive("timeout", () => reject(new TransportError(`Timeout leaving topic ${topic}`)));
+      ).receive(
+        "timeout",
+        () => reject(new TransportError(`Timeout leaving topic ${topic}`))
+      );
     });
     this.channels.delete(topic);
     this.logger.debug("Left topic", { topic });
   }
   async runForever(signal) {
+    if (this.terminalDisconnectError) {
+      throw this.terminalDisconnectError;
+    }
     if (signal.aborted) {
       return;
     }
-    await new Promise((resolve) => {
-      signal.addEventListener("abort", () => resolve(), { once: true });
+    await new Promise((resolve, reject) => {
+      let settled = false;
+      const abortController = new AbortController();
+      const waiter = {
+        reject: (error) => {
+          if (settled) {
+            return;
+          }
+          settled = true;
+          this.runForeverWaiters.delete(waiter);
+          abortController.abort();
+          reject(error);
+        }
+      };
+      this.runForeverWaiters.add(waiter);
+      signal.addEventListener(
+        "abort",
+        () => {
+          if (settled) {
+            return;
+          }
+          settled = true;
+          this.runForeverWaiters.delete(waiter);
+          resolve();
+        },
+        { once: true, signal: abortController.signal }
+      );
+    });
+  }
+  async handleOpen() {
+    try {
+      await this.subscribeAgentControl();
+    } catch (error) {
+      this.connected = false;
+      this.socket.disconnect();
+      this.connectReject?.(
+        error instanceof Error ? error : new TransportError(String(error))
+      );
+      this.logger.warn("Failed to join mandatory agent_control channel", {
+        error
+      });
+      return;
+    }
+    this.connected = true;
+    this.connectResolve?.();
+    this.connectResolve = null;
+    this.connectReject = null;
+    this.logger.info("Phoenix socket opened", {
+      channels: getSocketChannelCount(this.socket)
+    });
+  }
+  stopReconnectIfNoChannels(options = {}) {
+    if (this.stoppingReconnect || getSocketChannelCount(this.socket) !== 0) {
+      return;
+    }
+    this.suppressNextCloseReason = options.suppressCloseReason ?? false;
+    this.stoppingReconnect = true;
+    this.socket.disconnect();
+    this.stoppingReconnect = false;
+  }
+  async subscribeAgentControl() {
+    if (!this.agentId) {
+      return;
+    }
+    await this.join(`agent_control:${this.agentId}`, {
+      supersede: (payload) => {
+        const reason = parseSupersedeDisconnectReason(payload);
+        if (!reason) {
+          this.logger.warn("Invalid agent_control supersede payload", {
+            payload
+          });
+          return;
+        }
+        this.recordTerminalDisconnect(reason);
+      }
     });
   }
+  recordSocketClose(event) {
+    this.connected = false;
+    const suppressCloseReason = this.suppressNextCloseReason;
+    this.suppressNextCloseReason = false;
+    this.stopReconnectIfNoChannels();
+    if (!suppressCloseReason && !this.terminalDisconnectError && !this.lastDisconnectReason) {
+      this.lastDisconnectReason = genericCloseReason(event);
+    }
+    this.logger.info("Phoenix socket closed", {
+      code: event?.code ?? null,
+      reason: event?.reason ?? null,
+      platformReason: this.lastDisconnectReason
+    });
+  }
+  recordTerminalDisconnect(reason) {
+    if (this.terminalDisconnectError) {
+      return;
+    }
+    const error = new WebSocketDisconnectError(reason);
+    this.lastDisconnectReason = reason;
+    this.terminalDisconnectError = error;
+    this.onTerminalDisconnect?.(reason);
+    this.connectReject?.(error);
+    for (const waiter of this.runForeverWaiters) {
+      waiter.reject(error);
+    }
+    this.runForeverWaiters.clear();
+    this.socket.disconnect();
+  }
   async waitForConnection(timeoutMs = 1e4) {
     if (this.connected) {
       return;
@@ -1923,20 +2535,43 @@ var PhoenixChannelsTransport = class {
     await new Promise((resolve, reject) => {
       const timeout = setTimeout(() => {
         this.connectResolve = null;
-        reject(new TransportError("Timed out waiting for Phoenix socket connection"));
+        this.connectReject = null;
+        reject(
+          new TransportError("Timed out waiting for Phoenix socket connection")
+        );
       }, timeoutMs);
       this.connectResolve = () => {
         clearTimeout(timeout);
+        this.connectReject = null;
         resolve();
       };
+      this.connectReject = (error) => {
+        clearTimeout(timeout);
+        this.connectResolve = null;
+        this.connectReject = null;
+        reject(
+          error instanceof Error ? error : new TransportError(String(error))
+        );
+      };
     });
   }
 };
-function resolveWebSocketFactory() {
+function resolveWebSocketFactory(apiKey) {
   if (typeof process !== "undefined" && process.versions?.node) {
-    return import_ws.WebSocket;
+    return createNodeWebSocketFactory({ "x-api-key": apiKey });
+  }
+  throw new TransportError(
+    "Phoenix WebSocket API-key auth requires a WebSocket transport that can set handshake headers."
+  );
+}
+function unwrapErrorEvent(event) {
+  if (!isErrorEvent(event)) {
+    return event;
   }
-  return WebSocket;
+  return event.error;
+}
+function isErrorEvent(event) {
+  return typeof event === "object" && event !== null && "error" in event;
 }
 function removeSocketChannel(socket, channel) {
   const candidate = socket;
@@ -1959,6 +2594,12 @@ function deriveDefaultRestUrl(wsUrl) {
   const protocol = parsed.protocol === "ws:" ? "http:" : "https:";
   return `${protocol}//${parsed.host}`;
 }
+function roomTopics(roomId) {
+  return {
+    chat: `chat_room:${roomId}`,
+    participants: `room_participants:${roomId}`
+  };
+}
 function toPlatformMessage(roomId, message) {
   return {
     id: message.id,
@@ -1985,6 +2626,8 @@ var ThenvoiLink = class {
   eventQueue = [];
   waiters = [];
   connected = false;
+  lastDisconnectReason = null;
+  terminalDisconnectError = null;
   constructor(options) {
     this.agentId = options.agentId;
     this.apiKey = options.apiKey;
@@ -2006,17 +2649,35 @@ var ThenvoiLink = class {
       wsUrl: this.wsUrl,
       apiKey: this.apiKey,
       agentId: this.agentId,
-      logger: this.logger
+      logger: this.logger,
+      conflictPolicy: options.conflictPolicy,
+      onTerminalDisconnect: (reason) => {
+        this.recordDisconnectReason(reason);
+      }
     });
   }
   isConnected() {
     return this.connected;
   }
+  getDisconnectReason() {
+    return this.lastDisconnectReason;
+  }
   async connect() {
     if (this.connected) {
       return;
     }
-    await this.transport.connect();
+    try {
+      await this.transport.connect();
+    } catch (error) {
+      if (error instanceof WebSocketDisconnectError) {
+        if (error.reason.retryable) {
+          this.lastDisconnectReason = error.reason;
+        } else {
+          this.recordDisconnectError(error);
+        }
+      }
+      throw error;
+    }
     this.connected = true;
   }
   async disconnect() {
@@ -2030,8 +2691,23 @@ var ThenvoiLink = class {
     this.connected = false;
   }
   async runForever(signal) {
+    if (this.terminalDisconnectError) {
+      throw this.terminalDisconnectError;
+    }
     await this.transport.runForever(signal);
   }
+  recordDisconnectReason(reason) {
+    this.recordDisconnectError(new WebSocketDisconnectError(reason));
+  }
+  recordDisconnectError(error) {
+    this.connected = false;
+    this.lastDisconnectReason = error.reason;
+    this.terminalDisconnectError = error;
+    while (this.waiters.length > 0) {
+      const waiter = this.waiters.shift();
+      waiter?.reject(error);
+    }
+  }
   queueEvent(event) {
     const waiter = this.waiters.shift();
     if (waiter) {
@@ -2056,32 +2732,42 @@ var ThenvoiLink = class {
     if (this.subscribedRooms.has(roomId)) {
       return;
     }
-    await this.transport.join(`chat_room:${roomId}`, {
-      message_created: (payload) => {
-        this.emit("message_created", payload, roomId);
-      }
-    });
-    await this.transport.join(`room_participants:${roomId}`, {
-      participant_added: (payload) => {
-        this.emit("participant_added", payload, roomId);
-      },
-      participant_removed: (payload) => {
-        this.emit("participant_removed", payload, roomId);
-      },
-      room_deleted: (payload) => {
-        this.emit("room_deleted", payload, roomId);
-      }
-    });
+    await this.joinRoomTopics(roomId);
     this.subscribedRooms.add(roomId);
   }
   async unsubscribeRoom(roomId) {
     if (!this.subscribedRooms.has(roomId)) {
       return;
     }
-    await this.transport.leave(`chat_room:${roomId}`);
-    await this.transport.leave(`room_participants:${roomId}`);
+    const topics = roomTopics(roomId);
+    await this.transport.leave(topics.chat);
+    await this.transport.leave(topics.participants);
     this.subscribedRooms.delete(roomId);
   }
+  async joinRoomTopics(roomId) {
+    const topics = roomTopics(roomId);
+    await this.transport.join(topics.chat, {
+      message_created: (payload) => {
+        this.emit("message_created", payload, roomId);
+      }
+    });
+    try {
+      await this.transport.join(topics.participants, {
+        participant_added: (payload) => {
+          this.emit("participant_added", payload, roomId);
+        },
+        participant_removed: (payload) => {
+          this.emit("participant_removed", payload, roomId);
+        },
+        room_deleted: (payload) => {
+          this.emit("room_deleted", payload, roomId);
+        }
+      });
+    } catch (error) {
+      await this.transport.leave(topics.chat);
+      throw error;
+    }
+  }
   async subscribeAgentContacts() {
     assertCapability(this.capabilities, "contacts", "Contacts streaming");
     await this.transport.join(`agent_contacts:${this.agentId}`, {
@@ -2103,6 +2789,9 @@ var ThenvoiLink = class {
     await this.transport.leave(`agent_contacts:${this.agentId}`);
   }
   async nextEvent(signal) {
+    if (this.terminalDisconnectError) {
+      throw this.terminalDisconnectError;
+    }
     if (signal?.aborted) {
       return null;
     }
@@ -2110,19 +2799,19 @@ var ThenvoiLink = class {
     if (queued) {
       return queued;
     }
-    return new Promise((resolve) => {
+    return new Promise((resolve, reject) => {
       let settled = false;
       const onAbort = () => {
         const index = this.waiters.indexOf(waiter);
         if (index >= 0) {
           this.waiters.splice(index, 1);
         }
-        finalize(null);
+        finalizeResolve(null);
       };
       const cleanup = () => {
         signal?.removeEventListener("abort", onAbort);
       };
-      const finalize = (event) => {
+      const finalizeResolve = (event) => {
         if (settled) {
           return;
         }
@@ -2130,8 +2819,17 @@ var ThenvoiLink = class {
         cleanup();
         resolve(event);
       };
+      const finalizeReject = (error) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        cleanup();
+        reject(error);
+      };
       const waiter = {
-        resolve: finalize,
+        resolve: finalizeResolve,
+        reject: finalizeReject,
         cleanup
       };
       this.waiters.push(waiter);
@@ -2143,7 +2841,10 @@ var ThenvoiLink = class {
       next: async () => {
         const value = await this.nextEvent();
         if (value === null) {
-          return { done: true, value: void 0 };
+          return {
+            done: true,
+            value: void 0
+          };
         }
         return { done: false, value };
       }
@@ -2225,7 +2926,9 @@ var ThenvoiLink = class {
   }
   async listChats(request, requestOptions) {
     if (!this.rest.listChats) {
-      throw new UnsupportedFeatureError("Chat listing is not available in current REST adapter");
+      throw new UnsupportedFeatureError(
+        "Chat listing is not available in current REST adapter"
+      );
     }
     return this.rest.listChats(request, requestOptions);
   }
@@ -2558,6 +3261,7 @@ init_errors();
 init_chatEvents();
 init_protocols();
 init_schemas();
+init_memory();
 var REQUIRED_ADAPTER_TOOL_METHODS = [
   "sendMessage",
   "sendEvent",
@@ -2592,40 +3296,6 @@ var CONTACT_REQUEST_ACTIONS = /* @__PURE__ */ new Set([
   "reject",
   "cancel"
 ]);
-var MEMORY_SYSTEMS = /* @__PURE__ */ new Set([
-  "sensory",
-  "working",
-  "long_term"
-]);
-var MEMORY_TYPES = /* @__PURE__ */ new Set([
-  "iconic",
-  "echoic",
-  "haptic",
-  "episodic",
-  "semantic",
-  "procedural"
-]);
-var MEMORY_SEGMENTS = /* @__PURE__ */ new Set([
-  "user",
-  "agent",
-  "tool",
-  "guideline"
-]);
-var LIST_MEMORY_SCOPES = /* @__PURE__ */ new Set([
-  "subject",
-  "organization",
-  "all"
-]);
-var LIST_MEMORY_STATUSES = /* @__PURE__ */ new Set([
-  "active",
-  "superseded",
-  "archived",
-  "all"
-]);
-var MEMORY_SCOPES = /* @__PURE__ */ new Set([
-  "subject",
-  "organization"
-]);
 var AgentTools = class {
   roomId;
   capabilities;
@@ -3203,6 +3873,9 @@ var AgentTools = class {
     const status = this.normalizeOptionalMemoryStatus(arguments_.status);
     const subjectId = this.normalizeOptionalString(arguments_.subject_id);
     const contentQuery = this.normalizeOptionalString(arguments_.content_query);
+    if (system && type && !isMemoryTypeForSystem(system, type)) {
+      throw new ValidationError(memoryTypeForSystemError(system));
+    }
     return {
       ...subjectId ? { subject_id: subjectId } : {},
       ...scope ? { scope } : {},
@@ -3224,13 +3897,21 @@ var AgentTools = class {
     const subjectId = this.normalizeOptionalString(arguments_.subject_id);
     const metadata = this.normalizeOptionalMetadata(arguments_.metadata);
     if (!system) {
-      throw new ValidationError("system must be one of: sensory, working, long_term");
+      throw new ValidationError(`system must be one of: ${expectedList(MEMORY_SYSTEMS)}`);
     }
     if (!type) {
-      throw new ValidationError("type must be one of: iconic, echoic, haptic, episodic, semantic, procedural");
+      throw new ValidationError(`type must be one of: ${expectedList(MEMORY_TYPES)}`);
+    }
+    if (!isMemoryTypeForSystem(system, type)) {
+      throw new ValidationError(memoryTypeForSystemError(system));
     }
     if (!segment) {
-      throw new ValidationError("segment must be one of: user, agent, tool, guideline");
+      throw new ValidationError(`segment must be one of: ${expectedList(MEMORY_SEGMENTS)}`);
+    }
+    if (scope === "subject" && !subjectId) {
+      throw new ValidationError(
+        'scope="subject" requires a subject_id (the UUID of the person or agent the memory is about). If you do not have a concrete subject UUID, retry with scope="organization" and omit subject_id. Do not invent a UUID.'
+      );
     }
     return {
       content,
@@ -3310,8 +3991,8 @@ var AgentTools = class {
     if (!normalized) {
       return void 0;
     }
-    if (!isListMemoryScope(normalized)) {
-      throw new ValidationError("scope must be one of: subject, organization, all");
+    if (!isMemoryListScope(normalized)) {
+      throw new ValidationError(`scope must be one of: ${expectedList(MEMORY_LIST_SCOPES)}`);
     }
     return normalized;
   }
@@ -3321,7 +4002,7 @@ var AgentTools = class {
       return void 0;
     }
     if (!isMemorySystem(normalized)) {
-      throw new ValidationError("system must be one of: sensory, working, long_term");
+      throw new ValidationError(`system must be one of: ${expectedList(MEMORY_SYSTEMS)}`);
     }
     return normalized;
   }
@@ -3331,7 +4012,7 @@ var AgentTools = class {
       return void 0;
     }
     if (!isMemoryType(normalized)) {
-      throw new ValidationError("type must be one of: iconic, echoic, haptic, episodic, semantic, procedural");
+      throw new ValidationError(`type must be one of: ${expectedList(MEMORY_TYPES)}`);
     }
     return normalized;
   }
@@ -3341,7 +4022,7 @@ var AgentTools = class {
       return void 0;
     }
     if (!isMemorySegment(normalized)) {
-      throw new ValidationError("segment must be one of: user, agent, tool, guideline");
+      throw new ValidationError(`segment must be one of: ${expectedList(MEMORY_SEGMENTS)}`);
     }
     return normalized;
   }
@@ -3351,7 +4032,7 @@ var AgentTools = class {
       return void 0;
     }
     if (!isMemoryStatus(normalized)) {
-      throw new ValidationError("status must be one of: active, superseded, archived, all");
+      throw new ValidationError(`status must be one of: ${expectedList(MEMORY_STATUSES)}`);
     }
     return normalized;
   }
@@ -3360,8 +4041,8 @@ var AgentTools = class {
     if (!normalized) {
       return void 0;
     }
-    if (!isStoreMemoryScope(normalized)) {
-      throw new ValidationError("scope must be one of: subject, organization");
+    if (!isMemoryStoreScope(normalized)) {
+      throw new ValidationError(`scope must be one of: ${expectedList(MEMORY_STORE_SCOPES)}`);
     }
     return normalized;
   }
@@ -3369,24 +4050,6 @@ var AgentTools = class {
 function isContactRequestAction(value) {
   return CONTACT_REQUEST_ACTIONS.has(value);
 }
-function isMemorySystem(value) {
-  return MEMORY_SYSTEMS.has(value);
-}
-function isMemoryType(value) {
-  return MEMORY_TYPES.has(value);
-}
-function isMemorySegment(value) {
-  return MEMORY_SEGMENTS.has(value);
-}
-function isStoreMemoryScope(value) {
-  return MEMORY_SCOPES.has(value);
-}
-function isListMemoryScope(value) {
-  return LIST_MEMORY_SCOPES.has(value);
-}
-function isMemoryStatus(value) {
-  return LIST_MEMORY_STATUSES.has(value);
-}
 function coercePositiveInt(value, fallback) {
   const num = Number(value ?? fallback);
   return Number.isFinite(num) && num >= 1 ? Math.floor(num) : fallback;
@@ -3426,17 +4089,19 @@ function validateToolArgs(toolName, args) {
     }
   }
   if (toolName === "thenvoi_store_memory") {
-    const validSystems = ["sensory", "working", "long_term"];
-    const validTypes = ["iconic", "echoic", "haptic", "episodic", "semantic", "procedural"];
-    const validSegments = ["user", "agent", "tool", "guideline"];
-    if (typeof args.system === "string" && !validSystems.includes(args.system)) {
-      errors.push(`system: Invalid value '${args.system}'. Expected one of: ${validSystems.join(", ")}`);
+    if (typeof args.system === "string" && !isMemorySystem(args.system)) {
+      errors.push(`system: Invalid value '${args.system}'. Expected one of: ${expectedList(MEMORY_SYSTEMS)}`);
+    }
+    if (typeof args.type === "string" && !isMemoryType(args.type)) {
+      errors.push(`type: Invalid value '${args.type}'. Expected one of: ${expectedList(MEMORY_TYPES)}`);
     }
-    if (typeof args.type === "string" && !validTypes.includes(args.type)) {
-      errors.push(`type: Invalid value '${args.type}'. Expected one of: ${validTypes.join(", ")}`);
+    if (typeof args.system === "string" && isMemorySystem(args.system) && typeof args.type === "string" && isMemoryType(args.type) && !isMemoryTypeForSystem(args.system, args.type)) {
+      errors.push(
+        `type: Invalid value '${args.type}' for system '${args.system}'. Expected one of: ${expectedMemoryTypesForSystem(args.system)}`
+      );
     }
-    if (typeof args.segment === "string" && !validSegments.includes(args.segment)) {
-      errors.push(`segment: Invalid value '${args.segment}'. Expected one of: ${validSegments.join(", ")}`);
+    if (typeof args.segment === "string" && !isMemorySegment(args.segment)) {
+      errors.push(`segment: Invalid value '${args.segment}'. Expected one of: ${expectedList(MEMORY_SEGMENTS)}`);
     }
   }
   if (errors.length > 0) {
@@ -3503,6 +4168,29 @@ var MessageRetryTracker = class {
   }
 };
 
+// src/runtime/types.ts
+var HistoryProvider = class {
+  raw;
+  constructor(raw) {
+    this.raw = raw;
+  }
+  convert(converter) {
+    return converter.convert(this.raw);
+  }
+  get length() {
+    return this.raw.length;
+  }
+};
+var SYNTHETIC_SENDER_TYPE = "System";
+var SYNTHETIC_CONTACT_EVENTS_SENDER_ID = "contact-events";
+var SYNTHETIC_CONTACT_EVENTS_SENDER_NAME = "Contact Events";
+function ensureHandlePrefix(handle) {
+  if (!handle) {
+    return null;
+  }
+  return handle.startsWith("@") ? handle : `@${handle}`;
+}
+
 // src/runtime/formatters.ts
 function isMetadataMap(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -3516,7 +4204,7 @@ function replaceUuidMentions(content, participants) {
     const participantId = participant.id;
     const handle = participant.handle;
     if (typeof participantId === "string" && typeof handle === "string") {
-      next = next.replaceAll(`@[[${participantId}]]`, `@${handle}`);
+      next = next.replaceAll(`@[[${participantId}]]`, ensureHandlePrefix(handle) ?? "");
     }
   }
   return next;
@@ -3548,7 +4236,9 @@ function buildParticipantsMessage(participants) {
     const participantType = String(participant.type ?? "Unknown");
     const participantName = String(participant.name ?? "Unknown");
     const participantHandle = String(participant.handle ?? "Unknown");
-    lines.push(`- @${participantHandle} \u2014 ${participantName} (${participantType})`);
+    lines.push(
+      `- ${ensureHandlePrefix(participantHandle) ?? ""} \u2014 ${participantName} (${participantType})`
+    );
   }
   lines.push("");
   lines.push(
@@ -4028,7 +4718,7 @@ var AgentRuntime = class {
     await this.link.disconnect();
   }
   async stop(timeoutMs) {
-    if (!this.running || this.stopping) {
+    if (this.stopping || !this.running && !this.fatalError) {
       return true;
     }
     this.stopping = true;
@@ -4048,7 +4738,8 @@ var AgentRuntime = class {
       }
     }
     for (const roomId of [...this.subscribedRooms]) {
-      await this.leaveTrackedRoom(roomId);
+      const remaining = deadline === void 0 ? void 0 : Math.max(0, deadline - Date.now());
+      await this.leaveTrackedRoom(roomId, remaining);
     }
     for (const roomId of [...this.contexts.keys()]) {
       await this.onSessionCleanup(roomId);
@@ -4084,7 +4775,13 @@ var AgentRuntime = class {
   }
   async consumeLoop(signal) {
     while (!signal.aborted) {
-      const event = await this.link.nextEvent(signal);
+      let event;
+      try {
+        event = await this.link.nextEvent(signal);
+      } catch (error) {
+        await this.failRuntime(error, syntheticRuntimeFailureEvent(this.agentId));
+        return;
+      }
       if (!event) {
         return;
       }
@@ -4247,13 +4944,13 @@ var AgentRuntime = class {
       }
     });
   }
-  async leaveTrackedRoom(roomId) {
+  async leaveTrackedRoom(roomId, timeoutMs) {
     await trackRoomLeave({
       link: this.link,
       roomId,
       trackedRooms: this.subscribedRooms,
       onLeft: async (leftRoomId) => {
-        await this.executions.get(leftRoomId)?.stop();
+        await this.executions.get(leftRoomId)?.stop(timeoutMs);
         this.contexts.delete(leftRoomId);
         this.executions.delete(leftRoomId);
         await this.onSessionCleanup(leftRoomId);
@@ -4290,27 +4987,27 @@ var AgentRuntime = class {
     }
   }
 };
+function syntheticRuntimeFailureEvent(agentId) {
+  return {
+    type: "message_created",
+    roomId: null,
+    payload: {
+      id: "runtime-failed",
+      content: "",
+      sender_id: agentId,
+      sender_type: "Agent",
+      sender_name: null,
+      message_type: "text",
+      metadata: {},
+      inserted_at: (/* @__PURE__ */ new Date(0)).toISOString(),
+      updated_at: (/* @__PURE__ */ new Date(0)).toISOString()
+    }
+  };
+}
 function assertNever(value) {
   throw new Error(`Unhandled platform event: ${JSON.stringify(value)}`);
 }
 
-// src/runtime/types.ts
-var HistoryProvider = class {
-  raw;
-  constructor(raw) {
-    this.raw = raw;
-  }
-  convert(converter) {
-    return converter.convert(this.raw);
-  }
-  get length() {
-    return this.raw.length;
-  }
-};
-var SYNTHETIC_SENDER_TYPE = "System";
-var SYNTHETIC_CONTACT_EVENTS_SENDER_ID = "contact-events";
-var SYNTHETIC_CONTACT_EVENTS_SENDER_NAME = "Contact Events";
-
 // src/runtime/PlatformRuntime.ts
 init_errors();
 
@@ -5156,7 +5853,8 @@ var PlatformRuntime = class {
         agentId: this._agentId,
         apiKey: this._apiKey,
         wsUrl: this._wsUrl,
-        restUrl: this._restUrl
+        restUrl: this._restUrl,
+        logger: this.logger
       });
     }
     if (this.configuredIdentity) {
@@ -5659,16 +6357,15 @@ var GenericAdapter = class extends SimpleAdapter {
 // src/adapters/codex/CodexAdapter.ts
 init_protocols();
 
-// src/runtime/prompts.ts
-var BASE_INSTRUCTIONS = `
+// src/runtime/prompts/base.ts
+var ENVIRONMENT_SECTION = `
 ## Environment
 
 Multi-participant chat. Messages show sender: [Name]: content.
 Messages prefixed with [System]: are platform updates (participant changes, contact updates, etc.) \u2014 not messages from users.
 Use \`thenvoi_send_message(content, mentions)\` to respond. Plain text output is not delivered.
-Mentions use handles: @<username> for users, @<username>/<agent-name> for agents.
-
-## CRITICAL: Delegate When You Cannot Help Directly
+Mentions use handles: @<username> for users, @<username>/<agent-name> for agents.`;
+var MULTI_AGENT_RULES_SECTION = `## CRITICAL: Delegate When You Cannot Help Directly
 
 You have NO internet access and NO real-time data. When asked about weather, news, stock prices,
 or any current information you cannot answer directly:
@@ -5694,14 +6391,12 @@ Only remove agents if the user explicitly requests it.
 When someone asks you to get information from another agent:
 1. Ask the other agent for the information
 2. When you receive the response, IMMEDIATELY relay it back to the ORIGINAL REQUESTER
-3. Do NOT just thank the helper agent - the requester is waiting for their answer!
-
-## IMPORTANT: Always Share Your Thinking
+3. Do NOT just thank the helper agent - the requester is waiting for their answer!`;
+var THINKING_SECTION = `## IMPORTANT: Always Share Your Thinking
 
 You MUST call \`thenvoi_send_event(content, message_type="thought")\` BEFORE every action.
-This is required so users can see your reasoning process.
-
-## Examples
+This is required so users can see your reasoning process.`;
+var EXAMPLES_SECTION = `## Examples
 
 ### Simple question - answer directly
 [John Doe]: What's 2+2?
@@ -5734,8 +6429,75 @@ This is required so users can see your reasoning process.
 
 [Weather Agent]: London is 8\xB0C and rainy.
 -> thenvoi_send_event("Got London weather. Relaying to John Doe.", message_type="thought")
--> thenvoi_send_message("London is 8\xB0C and rainy.", mentions=["@john"])
-`;
+-> thenvoi_send_message("London is 8\xB0C and rainy.", mentions=["@john"])`;
+var BASE_INSTRUCTIONS = [
+  ENVIRONMENT_SECTION,
+  MULTI_AGENT_RULES_SECTION,
+  THINKING_SECTION,
+  EXAMPLES_SECTION
+].join("\n\n") + "\n";
+
+// src/runtime/prompts/memory.ts
+init_memory();
+init_schemas();
+var MEMORY_INTRO = `## Memory Tools
+
+You have access to memory tools for storing and retrieving information
+across conversations. Use \`thenvoi_store_memory\` to persist important
+information and \`thenvoi_list_memories\` / \`thenvoi_get_memory\` to recall it.
+Use \`thenvoi_supersede_memory\` to mark outdated memories and
+\`thenvoi_archive_memory\` to hide memories that should be preserved.`;
+function longTermPattern(label, type, segment, scope) {
+  return {
+    label,
+    system: MEMORY_SYSTEM.long_term,
+    type,
+    segment,
+    scope
+  };
+}
+var COMMON_MEMORY_PATTERNS = [
+  longTermPattern("Facts learned about a specific agent/entity", MEMORY_TYPE.semantic, MEMORY_SEGMENT.agent, MEMORY_STORE_SCOPE.subject),
+  longTermPattern("Events involving a specific person/agent", MEMORY_TYPE.episodic, MEMORY_SEGMENT.agent, MEMORY_STORE_SCOPE.subject),
+  longTermPattern("A user's preferences or profile info", MEMORY_TYPE.semantic, MEMORY_SEGMENT.user, MEMORY_STORE_SCOPE.subject),
+  longTermPattern("Org-wide knowledge or how to perform a task", MEMORY_TYPE.procedural, MEMORY_SEGMENT.tool, MEMORY_STORE_SCOPE.organization)
+];
+function renderMemoryPattern(pattern) {
+  return `- ${pattern.label}: \`system="${pattern.system}"\`, \`type="${pattern.type}"\`, \`segment="${pattern.segment}"\`, \`scope="${pattern.scope}"\``;
+}
+var MEMORY_COMMON_PATTERNS = [
+  "Common patterns:",
+  ...COMMON_MEMORY_PATTERNS.map(renderMemoryPattern)
+].join("\n");
+var MEMORY_SCOPE_GUIDANCE = `Prefer \`scope="${MEMORY_STORE_SCOPE.subject}"\` whenever the memory is about a specific person or agent, so it
+stays attached to that subject rather than leaking org-wide. Storing with \`scope="${MEMORY_STORE_SCOPE.subject}"\` requires a
+real \`subject_id\` UUID, so resolve it first via \`thenvoi_lookup_peers\` or the participant list.
+Reserve \`scope="${MEMORY_STORE_SCOPE.organization}"\` for knowledge that is genuinely shared across the whole organization and
+is not about any one subject.`;
+function quoteChoices(values) {
+  return values.map((value) => `\`"${value}"\``).join(" | ");
+}
+function memoryTypeLines() {
+  return Object.entries(MEMORY_SYSTEM_TYPES).map(([system, types]) => `  - ${system}: ${quoteChoices(types)}`).join("\n");
+}
+function buildMemorySection() {
+  const storeMemoryProps = TOOL_MODELS.thenvoi_store_memory.properties;
+  const systems = storeMemoryProps.system.enum;
+  const segments = storeMemoryProps.segment.enum;
+  const scopes = storeMemoryProps.scope.enum;
+  const fieldRules = `When calling \`thenvoi_store_memory\`, the \`system\`, \`type\`, \`segment\`, and \`scope\` fields
+must use these exact values (case-sensitive):
+
+- **system**: ${quoteChoices(systems)}
+- **type** (must match the chosen system):
+${memoryTypeLines()}
+- **segment**: ${quoteChoices(segments)}
+- **scope**: ${quoteChoices(scopes)}`;
+  return [MEMORY_INTRO, fieldRules, MEMORY_COMMON_PATTERNS, MEMORY_SCOPE_GUIDANCE].join("\n\n");
+}
+var MEMORY_SECTION = buildMemorySection();
+
+// src/runtime/prompts/templates.ts
 var TEMPLATES = {
   default: `You are {agent_name}, {agent_description}.
 
@@ -5754,11 +6516,17 @@ ${customSection}`.trim();
   }
   const template = options?.template ?? "default";
   const templateString = TEMPLATES[template] ?? TEMPLATES.default;
-  return templateString.replaceAll("{agent_name}", agentName).replaceAll("{agent_description}", agentDescription).replaceAll("{custom_section}", customSection);
+  const parts = [
+    templateString.replaceAll("{agent_name}", agentName).replaceAll("{agent_description}", agentDescription).replaceAll("{custom_section}", customSection)
+  ];
+  if (options?.capabilities?.memory) {
+    parts.push(MEMORY_SECTION);
+  }
+  return parts.join("\n\n");
 }
 
 // src/runtime/tools/customTools.ts
-var import_zod2 = require("zod");
+var import_zod3 = require("zod");
 var import_zod_to_json_schema = require("zod-to-json-schema");
 var CustomToolDefinitionError = class extends Error {
   constructor(message) {
@@ -6453,7 +7221,8 @@ var CodexAdapter = class extends SimpleAdapter {
       agentName: this.agentName,
       agentDescription: this.agentDescription,
       customSection,
-      includeBaseInstructions: this.baseConfig.includeBaseInstructions ?? true
+      includeBaseInstructions: this.baseConfig.includeBaseInstructions ?? true,
+      capabilities: { memory: this.includeMemoryTools }
     }).trim();
     this.systemPrompt = prompt.length > 0 ? prompt : null;
   }
@@ -8576,7 +9345,8 @@ var GoogleADKAdapter = class extends SimpleAdapter {
     this.systemPrompt = this.systemPromptOverride ?? renderSystemPrompt({
       agentName,
       agentDescription,
-      customSection: this.customSection
+      customSection: this.customSection,
+      capabilities: { memory: this.enableMemoryTools }
     });
   }
   async onMessage(message, tools, history, participantsMessage, contactsMessage, context) {
@@ -8816,7 +9586,8 @@ var LangGraphAdapter = class extends SimpleAdapter {
     this.renderedSystemPrompt = this.systemPromptOverride ?? renderSystemPrompt({
       agentName,
       agentDescription,
-      customSection: this.customSection
+      customSection: this.customSection,
+      capabilities: { memory: this.includeMemoryTools }
     });
   }
   async onMessage(message, tools, history, participantsMessage, contactsMessage, context) {
@@ -8835,14 +9606,17 @@ var LangGraphAdapter = class extends SimpleAdapter {
       ];
     }
     const graph = await this.resolveGraph(sdk, langGraphTools);
-    const messages = this.buildMessages(
-      history,
-      message,
-      participantsMessage,
-      contactsMessage,
-      context.isSessionBootstrap,
-      context.roomId
-    );
+    const usesCheckpointer = Boolean(this.checkpointer);
+    const isFirstBootstrap = context.isSessionBootstrap && !this.bootstrappedRooms.has(context.roomId);
+    const replayHistory = !usesCheckpointer || isFirstBootstrap;
+    const includeSystemPrompt = this.usesCustomGraph && (!usesCheckpointer || isFirstBootstrap);
+    if (context.isSessionBootstrap) {
+      this.bootstrappedRooms.add(context.roomId);
+    }
+    const messages = this.buildMessages(history, message, participantsMessage, contactsMessage, {
+      replayHistory,
+      includeSystemPrompt
+    });
     const input = { messages };
     const graphConfig = {
       configurable: {
@@ -8869,6 +9643,10 @@ var LangGraphAdapter = class extends SimpleAdapter {
   async onCleanup(roomId) {
     this.bootstrappedRooms.delete(roomId);
   }
+  /** A caller-supplied graph rather than the built-in createReactAgent. */
+  get usesCustomGraph() {
+    return Boolean(this.graph || this.graphFactory);
+  }
   resolveGraph(sdk, langGraphTools) {
     if (this.graphFactory) {
       return Promise.resolve(this.graphFactory(langGraphTools));
@@ -8889,14 +9667,13 @@ var LangGraphAdapter = class extends SimpleAdapter {
       prompt: this.renderedSystemPrompt
     }));
   }
-  buildMessages(history, message, participantsMessage, contactsMessage, isSessionBootstrap, roomId) {
+  buildMessages(history, message, participantsMessage, contactsMessage, options) {
     const messages = [];
-    if (isSessionBootstrap && !this.bootstrappedRooms.has(roomId)) {
+    if (options.includeSystemPrompt) {
       messages.push(["system", this.renderedSystemPrompt]);
-      this.bootstrappedRooms.add(roomId);
     }
-    if (isSessionBootstrap && history.length > 0) {
-      const historical = history.raw.slice(-this.maxHistoryMessages);
+    if (options.replayHistory && history.length > 0) {
+      const historical = history.raw.filter((item) => item.id !== message.id).slice(-this.maxHistoryMessages);
       for (const item of historical) {
         const role = String(item.sender_type ?? "") === "Agent" ? "assistant" : "user";
         const content = String(item.content ?? "");
@@ -8915,7 +9692,7 @@ var LangGraphAdapter = class extends SimpleAdapter {
     return messages;
   }
   async forwardStreamEvents(graph, input, config, tools) {
-    const stream = graph.streamEvents?.(input, config, { version: "v2" });
+    const stream = graph.streamEvents?.(input, { ...config, version: "v2" });
     if (!stream) {
       return null;
     }
@@ -8942,6 +9719,10 @@ var LangGraphAdapter = class extends SimpleAdapter {
         );
       }
       if (eventType === "on_chain_end") {
+        const chainName = String(data.name ?? "");
+        if (!this.usesCustomGraph && chainName !== "LangGraph" && chainName !== "agent") {
+          continue;
+        }
         const output = asOptionalRecord(data.data) ?? {};
         const text = extractAssistantText(output.output);
         if (text) {
@@ -9003,18 +9784,25 @@ function stringifyToolResult2(value, logger, toolName) {
   });
 }
 function extractAssistantText(result) {
-  if (typeof result === "string" && result.trim().length > 0) {
-    return result.trim();
+  if (typeof result === "string") {
+    const trimmed = result.trim();
+    return trimmed.length > 0 && !isInternalLangGraphMarker(trimmed) ? trimmed : null;
   }
   const record = asOptionalRecord(result) ?? {};
+  if (isLangChainAssistantMessage(record)) {
+    const text = asLangChainMessageContent(record);
+    if (text && !isInternalLangGraphMarker(text)) {
+      return text;
+    }
+  }
   const directContent = asMessageContent(record.content);
-  if (directContent) {
+  if (directContent && !isInternalLangGraphMarker(directContent)) {
     return directContent;
   }
   const messages = Array.isArray(record.messages) ? record.messages : [];
   for (let index = messages.length - 1; index >= 0; index -= 1) {
     const text = asMessageText(messages[index]);
-    if (text) {
+    if (text && !isInternalLangGraphMarker(text)) {
       return text;
     }
   }
@@ -9031,12 +9819,40 @@ function asMessageText(value) {
   if (!record) {
     return null;
   }
+  if (isLangChainAssistantMessage(record)) {
+    return asLangChainMessageContent(record);
+  }
   const role = String(record.role ?? "");
   if (role !== "assistant") {
     return null;
   }
   return asMessageContent(record.content);
 }
+function isLangChainAssistantMessage(record) {
+  const id = record.id;
+  if (Array.isArray(id)) {
+    const typeName = String(id[id.length - 1] ?? "");
+    if (typeName === "AIMessage" || typeName === "AIMessageChunk") {
+      return true;
+    }
+  }
+  const getType = record.getType;
+  if (typeof getType === "function") {
+    try {
+      return getType.call(record) === "ai";
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+function asLangChainMessageContent(record) {
+  const kwargs = asOptionalRecord(record.kwargs);
+  return asMessageContent(kwargs?.content ?? record.content);
+}
+function isInternalLangGraphMarker(text) {
+  return text === "__end__" || text === "__start__";
+}
 function asMessageContent(value) {
   if (typeof value === "string" && value.trim().length > 0) {
     return value.trim();
@@ -11956,12 +12772,12 @@ var ThenvoiMcpStdioServer = class {
     }
     const { McpServer } = await import("@modelcontextprotocol/sdk/server/mcp.js");
     const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
-    const { z: z5 } = await import("zod");
+    const { z: z6 } = await import("zod");
     const mcpServer = new McpServer({
       name: this.options.name ?? "thenvoi",
       version: "1.0.0"
     });
-    registerTools(mcpServer, z5, this.registrations);
+    registerTools(mcpServer, z6, this.registrations);
     const transport = new StdioServerTransport(this.options.stdin, this.options.stdout);
     await mcpServer.connect(transport);
     this.mcpServer = mcpServer;
@@ -11973,14 +12789,14 @@ var ThenvoiMcpStdioServer = class {
     this.mcpServer = null;
   }
 };
-function registerTools(mcpServer, z5, registrations) {
+function registerTools(mcpServer, z6, registrations) {
   for (const reg of registrations) {
-    const zodShape = buildZodShape(z5, reg.inputSchema.properties, new Set(reg.inputSchema.required));
+    const zodShape = buildZodShape(z6, reg.inputSchema.properties, new Set(reg.inputSchema.required));
     mcpServer.registerTool(
       reg.name,
       {
         description: reg.description,
-        inputSchema: z5.object(zodShape)
+        inputSchema: z6.object(zodShape)
       },
       // eslint-disable-next-line @typescript-eslint/no-explicit-any -- MCP SDK handler signature is complex; our McpToolResult is compatible
       async (args) => reg.execute(args)
@@ -12039,7 +12855,7 @@ var ThenvoiMcpServer = class {
     const express = expressModule.default ?? expressModule;
     const http = await import("http");
     const { randomUUID: randomUUID6 } = await import("crypto");
-    const { z: z5 } = await import("zod");
+    const { z: z6 } = await import("zod");
     const serverName = this.options.name ?? "thenvoi";
     const app = express();
     app.use(express.json());
@@ -12060,7 +12876,7 @@ var ThenvoiMcpServer = class {
             StreamableHTTPServerTransport,
             serverName,
             sessionIdGenerator: randomUUID6,
-            z: z5
+            z: z6
           });
         }
         session.lastSeenAt = Date.now();
@@ -12186,14 +13002,14 @@ function sendMcpError(res, status, message) {
     id: null
   });
 }
-function registerTools2(mcpServer, z5, registrations) {
+function registerTools2(mcpServer, z6, registrations) {
   for (const reg of registrations) {
-    const zodShape = buildZodShape(z5, reg.inputSchema.properties, new Set(reg.inputSchema.required));
+    const zodShape = buildZodShape(z6, reg.inputSchema.properties, new Set(reg.inputSchema.required));
     mcpServer.registerTool(
       reg.name,
       {
         description: reg.description,
-        inputSchema: z5.object(zodShape)
+        inputSchema: z6.object(zodShape)
       },
       // eslint-disable-next-line @typescript-eslint/no-explicit-any -- MCP SDK handler signature is complex; our McpToolResult is compatible
       async (args) => reg.execute(args)
@@ -12268,7 +13084,7 @@ var ThenvoiMcpSseServer = class {
     const expressModule = await import("express");
     const express = expressModule.default ?? expressModule;
     const http = await import("http");
-    const { z: z5 } = await import("zod");
+    const { z: z6 } = await import("zod");
     const app = express();
     app.use(express.json());
     app.get("/healthz", (_req, res) => {
@@ -12280,7 +13096,7 @@ var ThenvoiMcpSseServer = class {
         name: this.options.name ?? "thenvoi",
         version: "1.0.0"
       });
-      registerTools3(mcpServer, z5, this.registrations);
+      registerTools3(mcpServer, z6, this.registrations);
       await mcpServer.connect(transport);
       const sessionId = transport.sessionId;
       this.sessions.set(sessionId, {
@@ -12372,10 +13188,10 @@ var ThenvoiMcpSseServer = class {
     }
   }
 };
-function registerTools3(mcpServer, z5, registrations) {
+function registerTools3(mcpServer, z6, registrations) {
   for (const registration of registrations) {
     const zodShape = buildZodShape(
-      z5,
+      z6,
       registration.inputSchema.properties,
       new Set(registration.inputSchema.required)
     );
@@ -12383,7 +13199,7 @@ function registerTools3(mcpServer, z5, registrations) {
       registration.name,
       {
         description: registration.description,
-        inputSchema: z5.object(zodShape)
+        inputSchema: z6.object(zodShape)
       },
       // eslint-disable-next-line @typescript-eslint/no-explicit-any -- MCP SDK handler signature is complex; our McpToolResult is compatible
       async (args) => registration.execute(args)
@@ -12413,20 +13229,17 @@ function checkPort2(http, port) {
 
 // src/mcp/backends.ts
 async function createThenvoiMcpBackend(options) {
-  const registrations = buildRoomScopedRegistrations(
-    options.getToolsForRoom,
-    {
-      enableMemoryTools: options.enableMemoryTools,
-      enableContactTools: true,
-      additionalTools: options.additionalTools
-    }
-  );
-  const allowedTools = mcpToolNames(new Set(registrations.map((registration) => registration.name)));
+  const registrationOptions = {
+    enableMemoryTools: options.enableMemoryTools,
+    enableContactTools: true,
+    additionalTools: options.additionalTools
+  };
   if (options.kind === "sdk") {
     const { createThenvoiSdkMcpServer: createThenvoiSdkMcpServer2 } = await Promise.resolve().then(() => (init_sdk(), sdk_exports));
     const server2 = createThenvoiSdkMcpServer2({
-      enableMemoryTools: options.enableMemoryTools,
       getToolsForRoom: options.getToolsForRoom,
+      multiRoom: options.multiRoom,
+      enableMemoryTools: options.enableMemoryTools,
       additionalTools: options.additionalTools
     });
     return {
@@ -12436,9 +13249,12 @@ async function createThenvoiMcpBackend(options) {
       stop: async () => void 0
     };
   }
+  const resolvedTools = options.multiRoom === false ? resolveSingleRoomTools(options.getToolsForRoom) : options.getToolsForRoom;
+  const registrations = options.multiRoom === false ? buildSingleContextRegistrations(resolvedTools, registrationOptions) : buildRoomScopedRegistrations(resolvedTools, registrationOptions);
+  const allowedTools = mcpToolNames(new Set(registrations.map((registration) => registration.name)));
   if (options.kind === "stdio") {
     const server2 = new ThenvoiMcpStdioServer({
-      tools: options.getToolsForRoom,
+      tools: resolvedTools,
       enableMemoryTools: options.enableMemoryTools,
       enableContactTools: true,
       additionalTools: options.additionalTools
@@ -12455,7 +13271,7 @@ async function createThenvoiMcpBackend(options) {
   }
   if (options.kind === "sse") {
     const server2 = new ThenvoiMcpSseServer({
-      tools: options.getToolsForRoom,
+      tools: resolvedTools,
       enableMemoryTools: options.enableMemoryTools,
       enableContactTools: true,
       additionalTools: options.additionalTools
@@ -12471,7 +13287,7 @@ async function createThenvoiMcpBackend(options) {
     };
   }
   const server = new ThenvoiMcpServer({
-    tools: options.getToolsForRoom,
+    tools: resolvedTools,
     enableMemoryTools: options.enableMemoryTools,
     enableContactTools: true,
     additionalTools: options.additionalTools
@@ -12710,7 +13526,7 @@ var SdkOpencodeClientBase = class {
     }
     const response = await fetch(url, { method: "DELETE" });
     if (!response.ok && response.status !== 404) {
-      throw new HttpStatusError(response.status, await readResponseBody(response));
+      throw new HttpStatusError(response.status, await readResponseBody2(response));
     }
   }
 };
@@ -12799,7 +13615,7 @@ async function findAvailablePort3() {
     });
   });
 }
-async function readResponseBody(response) {
+async function readResponseBody2(response) {
   const contentType = response.headers.get("content-type") ?? "";
   if (contentType.includes("application/json")) {
     try {
@@ -12911,7 +13727,8 @@ var OpencodeAdapter = class extends SimpleAdapter {
       agentName,
       agentDescription,
       customSection: this.config.customSection,
-      includeBaseInstructions: this.config.includeBaseInstructions
+      includeBaseInstructions: this.config.includeBaseInstructions,
+      capabilities: { memory: this.config.enableMemoryTools }
     }).trim();
     this.systemPrompt = `${systemPrompt}
 
@@ -13691,7 +14508,7 @@ function extractClaudeSessionId(raw) {
 // src/adapters/claude-sdk/ClaudeSDKAdapter.ts
 init_registrations();
 init_zod();
-var import_zod9 = require("zod");
+var import_zod10 = require("zod");
 var DEFAULT_MODEL2 = "claude-sonnet-4-6";
 var thenvoiMcpBridgeFactory = new LazyAsyncValue({
   load: async () => {
@@ -13718,7 +14535,7 @@ var thenvoiMcpBridgeFactory = new LazyAsyncValue({
       );
       const toolDefinitions = registrations.map((registration) => {
         const shape = buildZodShape(
-          import_zod9.z,
+          import_zod10.z,
           registration.inputSchema.properties,
           new Set(registration.inputSchema.required)
         );
@@ -13778,7 +14595,8 @@ var ClaudeSDKAdapter = class extends SimpleAdapter {
       agentName,
       agentDescription,
       customSection: this.customSection,
-      includeBaseInstructions: this.includeBaseInstructions
+      includeBaseInstructions: this.includeBaseInstructions,
+      capabilities: { memory: this.enableMemoryTools }
     });
     if (this.enableMcpTools) {
       const createThenvoiMcpBridge = await thenvoiMcpBridgeFactory.get();
@@ -13953,6 +14771,8 @@ init_schemas();
   TOOL_MODELS,
   ThenvoiLink,
   VercelAISDKAdapter,
+  WebSocketDisconnectError,
+  deriveDefaultRestUrl,
   isDirectExecution,
   loadAgentConfig,
   loadAgentConfigFromEnv