@letta-ai/letta-agent-sdk 0.3.3 → 0.5.0

package/dist/index.js

@@ -1,22 +1,4 @@
 // Generated bundle. Canonical modules are published under src/ and maintained in the letta-agent-sdk repository.
-import { createRequire } from "node:module";
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/repositories.ts
 var DEFAULT_CLOUD_API_BASE_URL = "https://api.letta.com";
@@ -262,6 +244,18 @@ class RepositoriesClient {
 }
 
 // node_modules/@letta-ai/letta-code/dist/app-server-client.js
+function isAppServerInfoResponseMessage(message) {
+  if (!message || typeof message !== "object" || Array.isArray(message)) {
+    return false;
+  }
+  const candidate = message;
+  const capabilities = candidate.capabilities;
+  if (!capabilities || typeof capabilities !== "object" || Array.isArray(capabilities)) {
+    return false;
+  }
+  const capabilityRecord = capabilities;
+  return candidate.type === "app_server_info_response" && typeof candidate.request_id === "string" && candidate.request_id.length > 0 && candidate.success === true && (candidate.backend === "local" || candidate.backend === "api") && typeof candidate.letta_code_version === "string" && typeof candidate.protocol_version === "number" && Number.isInteger(candidate.protocol_version) && typeof capabilityRecord.agent_management === "boolean" && typeof capabilityRecord.conversation_management === "boolean" && typeof capabilityRecord.memory_management === "boolean" && typeof capabilityRecord.runtime_start === "boolean" && typeof capabilityRecord.split_channels === "boolean";
+}
 var DEFAULT_REQUEST_TIMEOUT_MS = 30000;
 var WEBSOCKET_OPEN_STATE = 1;
 function getGlobalWebSocket() {
@@ -281,9 +275,9 @@ function normalizeBaseUrl(url) {
   }
   return parsed;
 }
-function resolveAppServerChannelUrl(url, channel) {
+function resolveAppServerUrl(url) {
   const parsed = normalizeBaseUrl(url);
-  parsed.searchParams.set("channel", channel);
+  parsed.searchParams.delete("channel");
   return parsed.toString();
 }
 function attachSocketListener(socket, type, listener) {
@@ -396,6 +390,7 @@ function streamDeltaErrorMessage(message) {
 }
 
 class AppServerClient {
+  socket;
   control;
   stream;
   requestTimeoutMs;
@@ -414,26 +409,18 @@ class AppServerClient {
     }
     this.requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
     const socketOptions = appServerSocketOptions(options.authToken);
-    this.control = new WebSocket(resolveAppServerChannelUrl(options.url, "control"), socketOptions);
-    this.stream = new WebSocket(resolveAppServerChannelUrl(options.url, "stream"), socketOptions);
-    attachSocketListener(this.control, "message", (event) => {
+    this.socket = new WebSocket(resolveAppServerUrl(options.url), socketOptions);
+    this.control = this.socket;
+    this.stream = this.socket;
+    attachSocketListener(this.socket, "message", (event) => {
       this.handleMessage(event, "control");
     });
-    attachSocketListener(this.stream, "message", (event) => {
-      this.handleMessage(event, "stream");
-    });
-    attachSocketListener(this.control, "close", (event) => {
+    attachSocketListener(this.socket, "close", (event) => {
       this.handleDisconnect("control", event);
     });
-    attachSocketListener(this.stream, "close", (event) => {
-      this.handleDisconnect("stream", event);
-    });
   }
   async connect() {
-    await Promise.all([
-      waitForSocketOpen(this.control),
-      waitForSocketOpen(this.stream)
-    ]);
+    await waitForSocketOpen(this.socket);
     return this;
   }
   close() {
@@ -441,8 +428,7 @@ class AppServerClient {
       return;
     this.explicitlyClosed = true;
     this.rejectAllPending("App-server client closed");
-    this.control.close();
-    this.stream.close();
+    this.socket.close();
   }
   onMessage(handler) {
     this.messageHandlers.add(handler);
@@ -461,10 +447,38 @@ class AppServerClient {
     return `${prefix}-${this.nextRequestNumber}`;
   }
   send(command) {
+    this.writeCommand(command);
+  }
+  writeCommand(command) {
     for (const handler of this.sendHandlers) {
       handler(command);
     }
-    this.control.send(JSON.stringify(command));
+    this.socket.send(JSON.stringify(command));
+  }
+  sendRaw(command) {
+    this.writeCommand(command);
+  }
+  requestRaw(command, options) {
+    const timeoutMs = options.timeoutMs ?? this.requestTimeoutMs;
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pending.delete(command.request_id);
+        reject(new Error(`Timed out waiting for ${command.request_id}`));
+      }, timeoutMs);
+      this.pending.set(command.request_id, {
+        resolve: (message) => resolve(message),
+        reject,
+        predicate: options.predicate,
+        timeout
+      });
+      try {
+        this.sendRaw(command);
+      } catch (error) {
+        clearTimeout(timeout);
+        this.pending.delete(command.request_id);
+        reject(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
   }
   request(commandOrType, bodyOrOptions = {}, maybeOptions = {}) {
     const isTypeRequest = typeof commandOrType === "string";
@@ -495,6 +509,15 @@ class AppServerClient {
       }
     });
   }
+  info(options = {}) {
+    return this.request({
+      type: "app_server_info",
+      request_id: this.nextRequestId("app-server-info")
+    }, {
+      ...options,
+      predicate: isAppServerInfoResponseMessage
+    });
+  }
   runtimeStart(command, options = {}) {
     return this.request({
       type: "runtime_start",
@@ -714,44 +737,6 @@ function applyUniqueRequestIds(client) {
 }
 
 // src/app-server-management.ts
-var DEFAULT_IDLE_LINGER_MS = 250;
-var registeredTransportsByUrl = new Map;
-function appServerUrlKey(value) {
-  try {
-    const url = new URL(value);
-    if (url.protocol === "http:")
-      url.protocol = "ws:";
-    if (url.protocol === "https:")
-      url.protocol = "wss:";
-    url.hash = "";
-    url.searchParams.delete("channel");
-    return url.toString();
-  } catch {
-    return value;
-  }
-}
-function registerManagementTransport(url, transport) {
-  const key = appServerUrlKey(url);
-  const registration = { transport };
-  const transports = registeredTransportsByUrl.get(key) ?? new Set;
-  transports.add(registration);
-  registeredTransportsByUrl.set(key, transports);
-  return () => {
-    transports.delete(registration);
-    if (transports.size === 0) {
-      registeredTransportsByUrl.delete(key);
-    }
-  };
-}
-async function releaseAppServerManagementConnections(url) {
-  const key = appServerUrlKey(url);
-  while (true) {
-    const transports = [...registeredTransportsByUrl.get(key) ?? []];
-    if (transports.length === 0)
-      return;
-    await Promise.all(transports.map(({ transport }) => transport.releaseIdleConnection()));
-  }
-}
 function ensureResponse(response, value, fallback) {
   if (!response.success || value == null) {
     throw new Error(response.error ?? fallback);
@@ -788,15 +773,9 @@ function stringRecord(value) {
 class AppServerManagementTransport {
   options;
   connectionPromise = null;
-  releasePromise = null;
   closingConnections = new Set;
-  inFlightRequests = 0;
-  idleWaiters = new Set;
-  idleTimer = null;
-  idleLingerMs;
   constructor(options) {
     this.options = options;
-    this.idleLingerMs = options.idleLingerMs ?? DEFAULT_IDLE_LINGER_MS;
   }
   async listAgents(query) {
     const response = await this.request("agent_list", { query }, "agent_list_response");
@@ -863,73 +842,20 @@ class AppServerManagementTransport {
     }
     return { messages: response.messages };
   }
-  releaseIdleConnection() {
-    this.clearIdleTimer();
-    if (this.releasePromise)
-      return this.releasePromise;
-    const release = this.releaseConnectionWhenIdle();
-    this.releasePromise = release;
-    release.then(() => {
-      if (this.releasePromise === release) {
-        this.releasePromise = null;
-      }
-    }, () => {
-      if (this.releasePromise === release) {
-        this.releasePromise = null;
-      }
-    });
-    return release;
-  }
   async request(type, body, responseType) {
-    if (this.releasePromise) {
-      await this.releasePromise;
-    }
     if (this.closingConnections.size > 0) {
       await Promise.all([...this.closingConnections]);
     }
-    this.clearIdleTimer();
-    this.inFlightRequests += 1;
-    try {
-      const { client } = await this.acquireConnection();
-      const command = {
-        type,
-        request_id: client.nextRequestId(type),
-        ...body
-      };
-      const response = await client.request(command, {
-        predicate: (message) => message.type === responseType
-      });
-      return response;
-    } finally {
-      this.inFlightRequests -= 1;
-      if (this.inFlightRequests === 0) {
-        const waiters = [...this.idleWaiters];
-        this.idleWaiters.clear();
-        for (const resolve of waiters)
-          resolve();
-        if (!this.releasePromise) {
-          this.scheduleIdleRelease();
-        }
-      }
-    }
-  }
-  async releaseConnectionWhenIdle() {
-    if (this.inFlightRequests > 0) {
-      await new Promise((resolve) => {
-        this.idleWaiters.add(resolve);
-      });
-    }
-    this.clearIdleTimer();
-    const promise = this.connectionPromise;
-    try {
-      if (promise) {
-        this.connectionPromise = null;
-        await this.trackClosingConnection(await promise);
-      }
-      if (this.closingConnections.size > 0) {
-        await Promise.all([...this.closingConnections]);
-      }
-    } catch {}
+    const { client } = await this.acquireConnection();
+    const command = {
+      type,
+      request_id: client.nextRequestId(type),
+      ...body
+    };
+    const response = await client.request(command, {
+      predicate: (message) => message.type === responseType
+    });
+    return response;
   }
   acquireConnection() {
     if (this.connectionPromise)
@@ -954,7 +880,6 @@ class AppServerManagementTransport {
     if (!url) {
       throw new Error("App-server management requires a url or connect hook.");
     }
-    const unregister = registerManagementTransport(url, this);
     let client = null;
     try {
       client = applyUniqueRequestIds(createAppServerClient({
@@ -969,29 +894,23 @@ class AppServerManagementTransport {
     } catch (error) {
       try {
         if (client) {
-          const controlClosed = waitForSocketClose(client.control);
           client.close();
           ownedConnection?.close();
-          await controlClosed;
         } else {
           ownedConnection?.close();
         }
-      } catch {} finally {
-        unregister();
-      }
+      } catch {}
       throw error;
     }
     return {
       client,
       ownedConnection,
-      detachDisconnect: () => {},
-      unregister
+      detachDisconnect: () => {}
     };
   }
   discardConnection(promise, connection) {
     if (this.connectionPromise === promise) {
       this.connectionPromise = null;
-      this.clearIdleTimer();
     }
     this.trackClosingConnection(connection);
   }
@@ -1001,67 +920,11 @@ class AppServerManagementTransport {
     closing.then(() => this.closingConnections.delete(closing), () => this.closingConnections.delete(closing));
     return closing;
   }
-  scheduleIdleRelease() {
-    if (!this.connectionPromise)
-      return;
-    this.clearIdleTimer();
-    const timer = setTimeout(() => {
-      this.idleTimer = null;
-      this.releaseIdleConnection();
-    }, this.idleLingerMs);
-    this.idleTimer = timer;
-    timer.unref?.();
-  }
-  clearIdleTimer() {
-    if (this.idleTimer === null)
-      return;
-    clearTimeout(this.idleTimer);
-    this.idleTimer = null;
-  }
 }
 async function closeConnection(connection) {
   connection.detachDisconnect();
-  const controlClosed = waitForSocketClose(connection.client.control);
-  try {
-    connection.client.close();
-    connection.ownedConnection?.close();
-    await controlClosed;
-  } finally {
-    connection.unregister();
-  }
-}
-function waitForSocketClose(socket) {
-  if (socket.readyState === 3)
-    return Promise.resolve();
-  return new Promise((resolve) => {
-    let settled = false;
-    let detach = () => {};
-    const finish = () => {
-      if (settled)
-        return;
-      settled = true;
-      clearTimeout(timeout);
-      detach();
-      resolve();
-    };
-    if (socket.addEventListener) {
-      socket.addEventListener("close", finish);
-      detach = () => socket.removeEventListener?.("close", finish);
-    } else if (socket.once) {
-      socket.once("close", finish);
-      detach = () => socket.off?.("close", finish);
-    } else if (socket.on) {
-      socket.on("close", finish);
-      detach = () => socket.off?.("close", finish);
-    } else {
-      resolve();
-      return;
-    }
-    const timeout = setTimeout(finish, 1000);
-    timeout.unref?.();
-    if (socket.readyState === 3)
-      finish();
-  });
+  connection.client.close();
+  connection.ownedConnection?.close();
 }
 
 // node_modules/@letta-ai/letta-code/dist/agent-presets.js
@@ -5968,6 +5831,12 @@ function streamDeltaMessageType2(delta) {
 function streamDeltaRunId2(delta) {
   return typeof delta.run_id === "string" ? delta.run_id : undefined;
 }
+function streamDeltaOtid(delta) {
+  return typeof delta.otid === "string" || delta.otid === null ? delta.otid : undefined;
+}
+function streamDeltaSeqId(delta) {
+  return typeof delta.seq_id === "number" ? delta.seq_id : undefined;
+}
 function streamDeltaStopReason2(delta) {
   return typeof delta.stop_reason === "string" ? delta.stop_reason : undefined;
 }
@@ -6377,6 +6246,8 @@ class RemoteTurnCoordinator {
   transformStreamDelta(delta) {
     const messageType = typeof delta.message_type === "string" ? delta.message_type : undefined;
     const runId = typeof delta.run_id === "string" ? delta.run_id : undefined;
+    const otid = streamDeltaOtid(delta);
+    const seqId = streamDeltaSeqId(delta);
     const uuid = typeof delta.id === "string" ? delta.id : `${this.label}-${++this.messageCounter}`;
     if (messageType === "assistant_message") {
       const content = extractTextFromContent(delta.content);
@@ -6384,13 +6255,27 @@ class RemoteTurnCoordinator {
         return null;
       if (this.activeTurn)
         this.activeTurn.assistantText += content;
-      return { type: "assistant", content, uuid, runId };
+      return {
+        type: "assistant",
+        content,
+        uuid,
+        ...otid !== undefined ? { otid } : {},
+        ...seqId !== undefined ? { seqId } : {},
+        runId
+      };
     }
     if (messageType === "reasoning_message") {
       const content = typeof delta.reasoning === "string" ? delta.reasoning : extractTextFromContent(delta.content);
       if (!content)
         return null;
-      return { type: "reasoning", content, uuid, runId };
+      return {
+        type: "reasoning",
+        content,
+        uuid,
+        ...otid !== undefined ? { otid } : {},
+        ...seqId !== undefined ? { seqId } : {},
+        runId
+      };
     }
     if (messageType === "tool_call_message" || messageType === "approval_request_message") {
       const toolCall = firstToolCall(delta);
@@ -7093,26 +6978,6 @@ function assertRemoteCreateAgentOptionsSupported(options) {
     throw new Error("App-server createAgent() does not yet support dreaming.behavior overrides.");
   }
 }
-function assertRemoteSessionOptionsSupported(action, options) {
-  if (options.systemPrompt !== undefined) {
-    throw new Error(`App-server ${action}() does not yet support systemPrompt overrides for existing agents.`);
-  }
-  if (options.disallowedTools !== undefined) {
-    throw new Error(`App-server ${action}() does not yet support disallowedTools.`);
-  }
-  if (options.systemInfoReminder !== undefined) {
-    throw new Error(`App-server ${action}() does not yet support systemInfoReminder overrides.`);
-  }
-  if (options.dreaming?.behavior !== undefined) {
-    throw new Error(`App-server ${action}() does not yet support dreaming.behavior overrides.`);
-  }
-  if (options.memfsStartup !== undefined) {
-    throw new Error(`App-server ${action}() does not support memfsStartup.`);
-  }
-  if (options.includePartialMessages !== undefined) {
-    throw new Error(`App-server ${action}() streams app-server deltas directly and does not support includePartialMessages.`);
-  }
-}
 function normalizeMemoryBlock(block) {
   const normalized = { ...block };
   if (normalized.value === undefined && typeof normalized.content === "string") {
@@ -7543,9 +7408,7 @@ class AppServerSession extends RemoteClientSessionCore {
     return options.memfs !== false;
   }
   async initializeRuntimeController() {
-    await this.remoteOptions.beforeConnect?.();
     const url = await this.resolveAppServerUrl();
-    await releaseAppServerManagementConnections(url);
     const client = applyUniqueRequestIds(createAppServerClient({
       url,
       ...this.remoteOptions.authToken !== undefined ? { authToken: this.remoteOptions.authToken } : {},
@@ -7855,6 +7718,222 @@ class CloudManagementTransport {
   }
 }
 
+// src/cloud-status-transport.ts
+var CONNECTING = 0;
+var OPEN = 1;
+var CLOSING = 2;
+var CLOSED = 3;
+var MAX_IDEMPOTENCY_KEYS = 1000;
+function addSocketListener(socket, type, listener) {
+  if (socket.addEventListener) {
+    socket.addEventListener(type, listener);
+    return () => socket.removeEventListener?.(type, listener);
+  }
+  if (socket.on) {
+    socket.on(type, listener);
+    return () => socket.off?.(type, listener);
+  }
+  throw new Error("WebSocket implementation does not support event listeners.");
+}
+function messageEventData(event) {
+  if (typeof event === "string")
+    return event;
+  if (!event || typeof event !== "object")
+    return null;
+  const data = event.data;
+  if (typeof data === "string")
+    return data;
+  if (data instanceof ArrayBuffer) {
+    return new TextDecoder().decode(data);
+  }
+  if (data instanceof Uint8Array) {
+    return new TextDecoder().decode(data);
+  }
+  return null;
+}
+function channelUrl(url, channel) {
+  const parsed = new URL(url);
+  parsed.searchParams.set("channel", channel);
+  return parsed.toString();
+}
+
+class CloudStatusTransport {
+  options;
+  controlSocket;
+  streamSocket;
+  state = CONNECTING;
+  openedChannels = new Set;
+  listeners = new Map;
+  removers = [];
+  seenIdempotencyKeys = new Set;
+  seenIdempotencyOrder = [];
+  lastEventSeq = null;
+  pingTimer = null;
+  closeEmitted = false;
+  constructor(options) {
+    this.options = options;
+    const socketOptions = options.headers ? { headers: options.headers } : undefined;
+    this.controlSocket = new options.WebSocket(channelUrl(options.url, "control"), socketOptions);
+    this.streamSocket = new options.WebSocket(channelUrl(options.url, "stream"), socketOptions);
+    this.bindSocket("control", this.controlSocket);
+    this.bindSocket("stream", this.streamSocket);
+    this.startPing();
+  }
+  get readyState() {
+    return this.state;
+  }
+  send(data) {
+    if (this.state !== OPEN || this.controlSocket.readyState !== OPEN) {
+      throw new Error("Cloud status control socket is not open");
+    }
+    this.controlSocket.send(data);
+  }
+  close() {
+    if (this.state === CLOSED || this.state === CLOSING)
+      return;
+    this.state = CLOSING;
+    this.stopPing();
+    this.closeUnderlyingSockets();
+    this.finishClose({});
+  }
+  addEventListener(type, listener) {
+    let listeners = this.listeners.get(type);
+    if (!listeners) {
+      listeners = new Set;
+      this.listeners.set(type, listeners);
+    }
+    listeners.add(listener);
+  }
+  removeEventListener(type, listener) {
+    this.listeners.get(type)?.delete(listener);
+  }
+  bindSocket(channel, socket) {
+    this.removers.push(addSocketListener(socket, "open", () => {
+      this.openedChannels.add(channel);
+      if (this.openedChannels.size === 2 && this.state === CONNECTING) {
+        this.state = OPEN;
+        this.emit("open", {});
+      }
+    }), addSocketListener(socket, "message", (event) => {
+      if (this.shouldForwardMessage(channel, socket, event)) {
+        this.emit("message", event);
+      }
+    }), addSocketListener(socket, "error", (event) => {
+      this.emit("error", event);
+    }), addSocketListener(socket, "close", (event) => {
+      if (this.state !== CLOSED) {
+        this.state = CLOSING;
+        this.stopPing();
+        this.closeUnderlyingSockets(socket);
+        this.finishClose(event);
+      }
+    }));
+  }
+  shouldForwardMessage(channel, socket, event) {
+    const data = messageEventData(event);
+    if (!data)
+      return true;
+    let message;
+    try {
+      message = JSON.parse(data);
+    } catch {
+      return true;
+    }
+    this.ackIfSequenced(socket, message);
+    if (channel === "control" && message.type === "stream_delta") {
+      return false;
+    }
+    if (this.isDuplicate(message))
+      return false;
+    this.trackEventSequence(message);
+    return true;
+  }
+  ackIfSequenced(socket, message) {
+    if (typeof message.seq !== "number")
+      return;
+    this.sendCommand(socket, { type: "ack", seq: message.seq });
+  }
+  isDuplicate(message) {
+    const key = typeof message.idempotency_key === "string" ? message.idempotency_key : null;
+    if (!key)
+      return false;
+    if (this.seenIdempotencyKeys.has(key))
+      return true;
+    this.seenIdempotencyKeys.add(key);
+    this.seenIdempotencyOrder.push(key);
+    while (this.seenIdempotencyOrder.length > MAX_IDEMPOTENCY_KEYS) {
+      const oldest = this.seenIdempotencyOrder.shift();
+      if (oldest)
+        this.seenIdempotencyKeys.delete(oldest);
+    }
+    return false;
+  }
+  trackEventSequence(message) {
+    if (typeof message.event_seq !== "number")
+      return;
+    if (this.lastEventSeq !== null && message.event_seq > this.lastEventSeq + 1) {
+      this.sendCommand(this.controlSocket, {
+        type: "sync",
+        runtime: this.options.runtime,
+        recover_approvals: true,
+        force_device_status: true
+      });
+    }
+    if (this.lastEventSeq === null || message.event_seq > this.lastEventSeq) {
+      this.lastEventSeq = message.event_seq;
+    }
+  }
+  sendCommand(socket, command) {
+    if (socket.readyState !== OPEN)
+      return;
+    try {
+      socket.send(JSON.stringify(command));
+    } catch {}
+  }
+  startPing() {
+    this.pingTimer = setInterval(() => {
+      this.sendCommand(this.controlSocket, { type: "ping" });
+      this.sendCommand(this.streamSocket, { type: "ping" });
+    }, this.options.pingIntervalMs);
+    this.pingTimer.unref?.();
+  }
+  stopPing() {
+    if (!this.pingTimer)
+      return;
+    clearInterval(this.pingTimer);
+    this.pingTimer = null;
+  }
+  closeUnderlyingSockets(except) {
+    for (const socket of [this.controlSocket, this.streamSocket]) {
+      if (socket !== except && (socket.readyState === CONNECTING || socket.readyState === OPEN)) {
+        socket.close();
+      }
+    }
+  }
+  finishClose(event) {
+    if (this.closeEmitted)
+      return;
+    this.closeEmitted = true;
+    this.state = CLOSED;
+    this.stopPing();
+    for (const remove of this.removers.splice(0))
+      remove();
+    this.emit("close", event);
+  }
+  emit(type, event) {
+    for (const listener of this.listeners.get(type) ?? []) {
+      listener(event);
+    }
+  }
+}
+function createCloudStatusTransportConstructor(options) {
+  return class CloudStatusTransportSocket extends CloudStatusTransport {
+    constructor(_url, _socketOptions) {
+      super(options);
+    }
+  };
+}
+
 // src/remote.ts
 function getDefaultApiKey2() {
   if (typeof process === "undefined") {
@@ -8163,191 +8242,6 @@ function buildCloudStatusWebSocketUrl(params) {
   }
   return base.toString();
 }
-function addSocketListener(socket, type, listener) {
-  if (socket.addEventListener) {
-    socket.addEventListener(type, listener);
-    return () => socket.removeEventListener?.(type, listener);
-  }
-  if (socket.on) {
-    socket.on(type, listener);
-    return () => socket.off?.(type, listener);
-  }
-  throw new Error("WebSocket implementation does not support event listeners.");
-}
-function messageEventData(event) {
-  if (typeof event === "string")
-    return event;
-  if (event && typeof event === "object") {
-    const data = event.data;
-    if (typeof data === "string")
-      return data;
-    if (data instanceof ArrayBuffer) {
-      return new TextDecoder().decode(data);
-    }
-    if (data instanceof Uint8Array) {
-      return new TextDecoder().decode(data);
-    }
-  }
-  return null;
-}
-function createCloudStatusWebSocketConstructor(params) {
-  const WebSocketCtor = getWebSocketConstructor(params.cloudOptions.WebSocket);
-  const authMode = params.cloudOptions.webSocketAuth ?? "header";
-  const cloudHeaders3 = authMode === "header" ? cloudWebSocketHeaders(params.cloudOptions) : undefined;
-  const pingIntervalMs = params.cloudOptions.pingIntervalMs ?? DEFAULT_PING_INTERVAL_MS;
-  const state = {
-    runtime: params.runtime,
-    seenIdempotencyKeys: new Set,
-    seenIdempotencyOrder: [],
-    lastEventSeq: null,
-    controlSocket: null
-  };
-
-  class CloudStatusSocketAdapter {
-    socket;
-    channel;
-    listenerRemovers = new Map;
-    pingTimer = null;
-    removeCloseListener = null;
-    constructor(url, options) {
-      this.channel = new URL(url).searchParams.get("channel");
-      const mergedHeaders = authMode === "header" ? {
-        ...options?.headers ?? {},
-        ...cloudHeaders3 ?? {}
-      } : undefined;
-      const socketOptions = mergedHeaders && Object.keys(mergedHeaders).length > 0 ? { headers: mergedHeaders } : undefined;
-      this.socket = new WebSocketCtor(url, socketOptions);
-      if (this.channel === "control") {
-        state.controlSocket = this;
-      }
-      this.removeCloseListener = addSocketListener(this.socket, "close", () => {
-        this.stopPing();
-        if (state.controlSocket === this)
-          state.controlSocket = null;
-      });
-      this.startPing(pingIntervalMs);
-    }
-    get readyState() {
-      return this.socket.readyState;
-    }
-    send(data) {
-      this.socket.send(data);
-    }
-    close() {
-      this.stopPing();
-      this.removeCloseListener?.();
-      this.removeCloseListener = null;
-      if (state.controlSocket === this)
-        state.controlSocket = null;
-      this.socket.close();
-    }
-    addEventListener(type, listener) {
-      const wrapped = type === "message" ? (event) => {
-        if (this.handleIncomingMessage(event)) {
-          listener(event);
-        }
-      } : listener;
-      const remove = addSocketListener(this.socket, type, wrapped);
-      let typeRemovers = this.listenerRemovers.get(type);
-      if (!typeRemovers) {
-        typeRemovers = new Map;
-        this.listenerRemovers.set(type, typeRemovers);
-      }
-      typeRemovers.set(listener, remove);
-    }
-    removeEventListener(type, listener) {
-      const typeRemovers = this.listenerRemovers.get(type);
-      const remove = typeRemovers?.get(listener);
-      if (!remove)
-        return;
-      remove();
-      typeRemovers?.delete(listener);
-      if (typeRemovers?.size === 0) {
-        this.listenerRemovers.delete(type);
-      }
-    }
-    handleIncomingMessage(event) {
-      const data = messageEventData(event);
-      if (!data)
-        return true;
-      let message;
-      try {
-        message = JSON.parse(data);
-      } catch {
-        return true;
-      }
-      this.ackIfSequenced(message);
-      if (this.channel === "control" && message.type === "stream_delta") {
-        return false;
-      }
-      if (this.isDuplicate(message))
-        return false;
-      this.trackEventSeq(message);
-      return true;
-    }
-    ackIfSequenced(message) {
-      if (typeof message.seq !== "number")
-        return;
-      this.sendCloudCommand({ type: "ack", seq: message.seq });
-    }
-    isDuplicate(message) {
-      const idempotencyKey = typeof message.idempotency_key === "string" ? message.idempotency_key : undefined;
-      if (!idempotencyKey)
-        return false;
-      if (state.seenIdempotencyKeys.has(idempotencyKey))
-        return true;
-      state.seenIdempotencyKeys.add(idempotencyKey);
-      state.seenIdempotencyOrder.push(idempotencyKey);
-      while (state.seenIdempotencyOrder.length > 1000) {
-        const oldest = state.seenIdempotencyOrder.shift();
-        if (oldest)
-          state.seenIdempotencyKeys.delete(oldest);
-      }
-      return false;
-    }
-    trackEventSeq(message) {
-      if (typeof message.event_seq !== "number")
-        return;
-      if (state.lastEventSeq !== null && message.event_seq > state.lastEventSeq + 1) {
-        this.sendSync(true);
-      }
-      if (state.lastEventSeq === null || message.event_seq > state.lastEventSeq) {
-        state.lastEventSeq = message.event_seq;
-      }
-    }
-    sendSync(recoverApprovals) {
-      const target = state.controlSocket?.readyState === 1 ? state.controlSocket : this;
-      target.sendCloudCommand({
-        type: "sync",
-        runtime: state.runtime,
-        recover_approvals: recoverApprovals,
-        force_device_status: true
-      });
-    }
-    sendCloudCommand(command) {
-      if (this.readyState !== 1)
-        return;
-      try {
-        this.socket.send(JSON.stringify(command));
-      } catch {}
-    }
-    startPing(intervalMs) {
-      if (this.pingTimer)
-        return;
-      this.pingTimer = setInterval(() => {
-        this.sendCloudCommand({ type: "ping" });
-      }, intervalMs);
-      this.pingTimer.unref?.();
-    }
-    stopPing() {
-      if (!this.pingTimer)
-        return;
-      clearInterval(this.pingTimer);
-      this.pingTimer = null;
-    }
-  }
-  return CloudStatusSocketAdapter;
-}
 function isCloudConversation(value) {
   return Boolean(value && typeof value === "object" && typeof value.id === "string");
 }
@@ -8391,24 +8285,6 @@ function assertCloudSessionOptionsSupported(action, options) {
   if (options.environment !== undefined && options.sandbox !== undefined) {
     throw new Error(`Letta Cloud ${action}() cannot specify both environment and sandbox options.`);
   }
-  if (options.systemPrompt !== undefined) {
-    throw new Error(`Letta Cloud ${action}() cannot rewrite an existing agent's systemPrompt from the SDK adapter yet.`);
-  }
-  if (options.disallowedTools !== undefined) {
-    throw new Error(`Letta Cloud ${action}() has not wired disallowedTools to the remote device protocol yet.`);
-  }
-  if (options.systemInfoReminder !== undefined) {
-    throw new Error(`Letta Cloud ${action}() has not wired systemInfoReminder to the remote device protocol yet.`);
-  }
-  if (options.dreaming?.behavior !== undefined) {
-    throw new Error(`Letta Cloud ${action}() does not yet support dreaming.behavior overrides.`);
-  }
-  if (options.memfsStartup !== undefined) {
-    throw new Error(`Letta Cloud ${action}() does not support memfsStartup.`);
-  }
-  if (options.includePartialMessages !== undefined) {
-    throw new Error(`Letta Cloud ${action}() streams Remote Client deltas directly; includePartialMessages is not a separate toggle.`);
-  }
 }
 
 class CloudEnvironmentSession extends RemoteClientSessionCore {
@@ -8448,8 +8324,11 @@ class CloudEnvironmentSession extends RemoteClientSessionCore {
     });
     const client = applyUniqueRequestIds(createAppServerClient({
       url,
-      WebSocket: createCloudStatusWebSocketConstructor({
-        cloudOptions: this.cloudOptions,
+      WebSocket: createCloudStatusTransportConstructor({
+        url,
+        WebSocket: getWebSocketConstructor(this.cloudOptions.WebSocket),
+        ...(this.cloudOptions.webSocketAuth ?? "header") === "header" ? { headers: cloudWebSocketHeaders(this.cloudOptions) } : {},
+        pingIntervalMs: this.cloudOptions.pingIntervalMs ?? DEFAULT_PING_INTERVAL_MS,
         runtime: resolved.runtime
       }),
       requestTimeoutMs: this.cloudOptions.requestTimeoutMs ?? DEFAULT_TURN_TIMEOUT_MS
@@ -9037,7 +8916,23 @@ function validateApprovalRecoveryOptions(options) {
   }
 }
 function validateRemovedSessionOptions(options) {
-  if (options.memfsStartup !== undefined) {
+  const removedOptions = options;
+  if (removedOptions.systemPrompt !== undefined) {
+    throw new Error("systemPrompt is not supported when opening an existing agent session.");
+  }
+  if (removedOptions.disallowedTools !== undefined) {
+    throw new Error("disallowedTools is not supported when opening an existing agent session.");
+  }
+  if (removedOptions.systemInfoReminder !== undefined) {
+    throw new Error("systemInfoReminder is not supported when opening an existing agent session.");
+  }
+  if (removedOptions.includePartialMessages !== undefined) {
+    throw new Error("includePartialMessages is not supported by app-server sessions.");
+  }
+  if (options.dreaming && "behavior" in options.dreaming && options.dreaming.behavior !== undefined) {
+    throw new Error("dreaming.behavior is not supported when opening an existing agent session.");
+  }
+  if (removedOptions.memfsStartup !== undefined) {
     throw new Error("memfsStartup is not supported by the SDK.");
   }
 }
@@ -9087,9 +8982,6 @@ function validateReasoningEffort(value) {
   }
 }
 function validateCreateSessionOptions(options) {
-  if (options.systemPrompt !== undefined) {
-    validateSystemPromptPreset(options.systemPrompt);
-  }
   validateSkillSources(options.skillSources);
   validateReasoningEffort(options.reasoningEffort);
   validateDreamingOptions(options.dreaming);
@@ -9145,6 +9037,7 @@ function stripCloudExecutionOptions(options) {
   const sessionOptions = { ...options };
   delete sessionOptions.environment;
   delete sessionOptions.sandbox;
+  delete sessionOptions.filesystemConfinement;
   return sessionOptions;
 }
 function hasRepositoryResources(options) {
@@ -9188,17 +9081,13 @@ class LettaAgentClientBase {
     }
     if (this.backend === "local") {
       const localOptions = options;
-      if (localOptions.transport !== undefined && localOptions.transport !== "app-server" && localOptions.transport !== "stdio") {
-        throw new Error("Invalid local transport. Valid values: app-server, stdio.");
+      if ("transport" in localOptions) {
+        throw new Error("Local transport selection has been removed. The local backend always uses the app-server protocol.");
       }
       const requestTimeoutMs = localOptions.appServer?.requestTimeoutMs;
       if (requestTimeoutMs !== undefined && (!Number.isInteger(requestTimeoutMs) || requestTimeoutMs <= 0)) {
         throw new Error("Invalid appServer.requestTimeoutMs. Expected a positive integer.");
       }
-      const idleLingerMs = localOptions.appServer?.idleLingerMs;
-      if (idleLingerMs !== undefined && (!Number.isInteger(idleLingerMs) || idleLingerMs < 0)) {
-        throw new Error("Invalid appServer.idleLingerMs. Expected a non-negative integer.");
-      }
       const startupTimeoutMs = localOptions.appServer?.startupTimeoutMs;
       if (startupTimeoutMs !== undefined && (!Number.isInteger(startupTimeoutMs) || startupTimeoutMs <= 0)) {
         throw new Error("Invalid appServer.startupTimeoutMs. Expected a positive integer.");
@@ -9211,9 +9100,6 @@ class LettaAgentClientBase {
       if (options.requestTimeoutMs !== undefined && (!Number.isInteger(options.requestTimeoutMs) || options.requestTimeoutMs <= 0)) {
         throw new Error("Invalid requestTimeoutMs. Expected a positive integer.");
       }
-      if (options.idleLingerMs !== undefined && (!Number.isInteger(options.idleLingerMs) || options.idleLingerMs < 0)) {
-        throw new Error("Invalid idleLingerMs. Expected a non-negative integer.");
-      }
     }
     if (this.backend === "cloud") {
       validateCloudClientOptions(options);
@@ -9241,40 +9127,35 @@ class LettaAgentClientBase {
     }
     return this.createLocalAgent(options);
   }
-  createSession(agentIdOrOptions, options = {}) {
-    const agentId = typeof agentIdOrOptions === "string" ? agentIdOrOptions : undefined;
-    const resolvedOptions = typeof agentIdOrOptions === "string" ? options : agentIdOrOptions ?? {};
-    this.assertSessionBackend("createSession", resolvedOptions);
-    const sessionOptions = stripCloudExecutionOptions(resolvedOptions);
+  createSession(agentId, options = {}) {
+    if (typeof agentId !== "string" || agentId.length === 0) {
+      throw new Error("createSession() requires a non-empty agent id.");
+    }
+    const sessionOptions = stripCloudExecutionOptions(options);
     validateCreateSessionOptions(sessionOptions);
+    this.assertSessionBackend("createSession", options);
     if (this.backend === "remote") {
-      if (!agentId) {
-        throw new Error("App-server createSession() requires an agent id. Call createAgent() first or pass an agent id.");
-      }
       return new AppServerSession(this.appServerSessionOptions(), {
         kind: "session",
         agentId,
         newConversation: true,
-        options: resolvedOptions
+        options
       });
     }
     if (this.backend === "cloud") {
-      if (!agentId) {
-        throw new Error("Letta Cloud createSession() requires an agent id. Call createAgent() first or pass an agent id.");
-      }
       return new CloudEnvironmentSession(this.cloudOptions(), {
         kind: "session",
         agentId,
         newConversation: true,
-        options: resolvedOptions
+        options
       });
     }
-    return this.createLocalSession(agentId, resolvedOptions, sessionOptions);
+    return this.createLocalSession(agentId, options);
   }
   resumeSession(id, options = {}) {
-    this.assertSessionBackend("resumeSession", options);
     const sessionOptions = stripCloudExecutionOptions(options);
     validateCreateSessionOptions(sessionOptions);
+    this.assertSessionBackend("resumeSession", options);
     if (this.backend === "remote") {
       if (looksLikeConversationId(id)) {
         return new AppServerSession(this.appServerSessionOptions(), {
@@ -9305,10 +9186,10 @@ class LettaAgentClientBase {
         options
       });
     }
-    return this.resumeLocalSession(id, options, sessionOptions);
+    return this.resumeLocalSession(id, options);
   }
   async prompt(message, agentId, options = {}) {
-    const session = agentId ? this.createSession(agentId, options) : this.createSession(options);
+    const session = this.createSession(agentId, options);
     try {
       return await session.runTurn(message);
     } finally {
@@ -9316,6 +9197,9 @@ class LettaAgentClientBase {
     }
   }
   assertSessionBackend(action, options) {
+    if (options.filesystemConfinement !== undefined && options.filesystemConfinement !== "memory") {
+      throw new Error(`Invalid filesystemConfinement '${String(options.filesystemConfinement)}'. Valid value: memory.`);
+    }
     const effectiveEnvironment = options.environment ?? this.environment;
     if (this.backend === "local") {
       if (effectiveEnvironment !== undefined) {
@@ -9327,12 +9211,18 @@ class LettaAgentClientBase {
       if (hasRepositoryResources(options)) {
         throw new Error(`${action}() repository resources are only valid with backend: "cloud".`);
       }
-      if (!this.useLegacyLocalStdio()) {
-        assertRemoteSessionOptionsSupported(action, options);
+      if (options.filesystemConfinement !== undefined) {
+        const localOptions = this.options;
+        if (localOptions.appServer?.url !== undefined) {
+          throw new Error(`${action}() filesystemConfinement requires an SDK-owned local app-server process.`);
+        }
       }
       return;
     }
     if (this.backend === "remote") {
+      if (options.filesystemConfinement !== undefined) {
+        throw new Error(`${action}() filesystemConfinement requires an SDK-owned local app-server process.`);
+      }
       if (options.environment !== undefined) {
         throw new Error(`${action}() environment overrides are only valid with backend: "cloud"; remote url selects the app-server runtime.`);
       }
@@ -9342,10 +9232,12 @@ class LettaAgentClientBase {
       if (hasRepositoryResources(options)) {
         throw new Error(`${action}() repository resources are only valid with backend: "cloud".`);
       }
-      assertRemoteSessionOptionsSupported(action, options);
       return;
     }
     if (this.backend === "cloud") {
+      if (options.filesystemConfinement !== undefined) {
+        throw new Error(`${action}() filesystemConfinement is only supported with backend: "local".`);
+      }
       const cloudOptions = this.cloudOptions();
       if (cloudOptions.environment !== undefined && options.sandbox !== undefined) {
         throw new Error(`Letta Cloud ${action}() cannot specify sandbox options when the client has a default environment.`);
@@ -9358,16 +9250,13 @@ class LettaAgentClientBase {
     }
     throw new Error(`LettaAgentClient backend '${this.backend}' is not implemented yet. ${action} currently supports backend 'local' only.`);
   }
-  useLegacyLocalStdio() {
-    return this.options.transport === "stdio";
-  }
   createLocalAgent(_options) {
     throw this.localBackendUnavailableError();
   }
-  createLocalSession(_agentId, _options, _sessionOptions) {
+  createLocalSession(_agentId, _options) {
     throw this.localBackendUnavailableError();
   }
-  resumeLocalSession(_id, _options, _sessionOptions) {
+  resumeLocalSession(_id, _options) {
     throw this.localBackendUnavailableError();
   }
   localBackendUnavailableError() {
@@ -9383,10 +9272,7 @@ class LettaAgentClientBase {
     return this.options;
   }
   appServerSessionOptions() {
-    return {
-      ...this.remoteOptions(),
-      beforeConnect: () => this.releaseIdleManagementConnection()
-    };
+    return this.remoteOptions();
   }
   getRepositoriesClient() {
     if (this.backend !== "cloud") {
@@ -9395,9 +9281,6 @@ class LettaAgentClientBase {
     this.repositoriesClient ??= new RepositoriesClient(this.cloudOptions());
     return this.repositoriesClient;
   }
-  async releaseIdleManagementConnection() {
-    await this.managementTransport?.releaseIdleConnection?.();
-  }
   getManagementTransport() {
     if (this.managementTransport)
       return this.managementTransport;
@@ -9420,32 +9303,373 @@ class LettaAgentClientBase {
 
 // src/local-app-server.ts
 import { spawn } from "node:child_process";
+import { homedir as homedir4 } from "node:os";
+import { join as join7 } from "node:path";
+
+// node_modules/@letta-ai/letta-code/dist/memory-confinement.js
+import { homedir as homedir3 } from "node:os";
+import { basename as basename2, dirname as dirname2, join as join3, resolve as resolve2 } from "node:path";
+import { existsSync, realpathSync } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { basename, dirname, isAbsolute, join as join2, resolve } from "node:path";
+import { posix, win32 } from "node:path";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+import { existsSync as existsSync2 } from "node:fs";
+import { delimiter, isAbsolute as isAbsolute2, join as join4 } from "node:path";
+var SANDBOX_ENV_VAR = "LETTA_SANDBOX";
+function buildFsSandboxPolicy(options) {
+  return {
+    baseWritableRoots: normalizeRoots(options.baseWritableRoots ?? []),
+    deniedRoots: normalizeRoots(options.deniedRoots ?? []),
+    readonlyRoots: normalizeRoots(options.readonlyRoots ?? []),
+    writableRoots: normalizeRoots(options.writableRoots ?? []),
+    restrictWrites: options.restrictWrites ?? false
+  };
+}
+function normalizeSandboxPath(path) {
+  const trimmed = path.trim();
+  const absolute = posix.isAbsolute(trimmed) || win32.isAbsolute(trimmed) ? trimmed : posix.resolve("/", trimmed);
+  const forward = absolute.replace(/\\/g, "/");
+  return forward.replace(/\/+$/, "") || "/";
+}
+function normalizeRoots(roots) {
+  const seen = new Set;
+  for (const root of roots) {
+    if (!root || !root.trim())
+      continue;
+    seen.add(normalizeSandboxPath(root));
+  }
+  return [...seen];
+}
+var LOCAL_BACKEND_DIR_ENV = "LETTA_LOCAL_BACKEND_DIR";
+function getLocalBackendStorageDir(homeDir = homedir(), env = process.env) {
+  return env[LOCAL_BACKEND_DIR_ENV] ?? join(homeDir, ".letta", "lc-local-backend");
+}
+function getLocalBackendCrossAgentTreeRoot(storageDir = getLocalBackendStorageDir()) {
+  return join(storageDir, "memfs");
+}
+function getDefaultAgentsTreeRoot(homeDir = homedir2()) {
+  return canonicalizeRoot(join2(homeDir, ".letta", "agents"));
+}
+function getCrossBackendAgentsTreeRoots(options = {}) {
+  const homeDir = options.homeDir ?? homedir2();
+  const localBackendStorageDir = options.localBackendStorageDir ?? getLocalBackendStorageDir(homeDir, options.env ?? process.env);
+  return [
+    getDefaultAgentsTreeRoot(homeDir),
+    canonicalizeRoot(getLocalBackendCrossAgentTreeRoot(localBackendStorageDir))
+  ];
+}
+function getLettaHomeRoot(homeDir = homedir2()) {
+  return canonicalizeRoot(join2(homeDir, ".letta"));
+}
+function canonicalizeRoot(input) {
+  const abs = isAbsolute(input) ? input : resolve(input);
+  let dir = abs;
+  const tail = [];
+  while (!existsSync(dir)) {
+    tail.unshift(basename(dir));
+    const parent = dirname(dir);
+    if (parent === dir) {
+      return normalizeSandboxPath(abs);
+    }
+    dir = parent;
+  }
+  try {
+    const real = realpathSync(dir);
+    return normalizeSandboxPath(tail.length ? join2(real, ...tail) : real);
+  } catch {
+    return normalizeSandboxPath(abs);
+  }
+}
+function isWithinRoot(path, root) {
+  return path === root || path.startsWith(`${root}/`);
+}
+function isAncestorOfRoot(path, root) {
+  const prefix = path === "/" ? "/" : `${path}/`;
+  return root.startsWith(prefix);
+}
+function isTreeOrAncestorOfTree(path, canonicalTrees) {
+  return canonicalTrees.some((tree) => path === tree || isAncestorOfRoot(path, tree));
+}
+function resolveAgentsTreeRootsInput(roots) {
+  return roots?.length ? roots.map(canonicalizeRoot) : getCrossBackendAgentsTreeRoots();
+}
+function deriveSelfAgentRootsForTrees(memoryRoots, agentsTreeRoots = getCrossBackendAgentsTreeRoots()) {
+  const canonicalTrees = agentsTreeRoots.map(canonicalizeRoot);
+  const out = new Set;
+  for (const root of memoryRoots) {
+    const canon = canonicalizeRoot(root);
+    const containingTree = canonicalTrees.find((tree) => canon !== tree && isWithinRoot(canon, tree));
+    if (containingTree) {
+      const leaf = basename(canon);
+      const parentLeaf = basename(dirname(canon));
+      out.add(leaf === "memory" || leaf === "memory-worktrees" ? dirname(canon) : parentLeaf === "memory-worktrees" || parentLeaf === "memory" && leaf === ".git" ? dirname(dirname(canon)) : canon);
+      continue;
+    }
+    if (!isTreeOrAncestorOfTree(canon, canonicalTrees)) {
+      out.add(canon);
+    }
+  }
+  return [...out];
+}
+function deriveWritableMemoryRootsForTrees(memoryRoots, agentsTreeRoots) {
+  const canonicalTrees = agentsTreeRoots.map(canonicalizeRoot);
+  const out = new Set;
+  for (const root of memoryRoots) {
+    const canon = canonicalizeRoot(root);
+    if (!isTreeOrAncestorOfTree(canon, canonicalTrees)) {
+      out.add(canon);
+    }
+  }
+  return [...out];
+}
+function buildMemorySubagentSandboxPolicy(input) {
+  const agentsTreeRoots = resolveAgentsTreeRootsInput(input.agentsTreeRoots);
+  const baseWritableRoots = [
+    getLettaHomeRoot(),
+    ...input.harnessWritableRoots ?? []
+  ].map(canonicalizeRoot);
+  return buildFsSandboxPolicy({
+    baseWritableRoots,
+    deniedRoots: agentsTreeRoots,
+    readonlyRoots: [
+      ...deriveSelfAgentRootsForTrees(input.memoryRoots, agentsTreeRoots),
+      ...(input.readonlyRoots ?? []).map(canonicalizeRoot)
+    ],
+    writableRoots: deriveWritableMemoryRootsForTrees(input.memoryRoots, agentsTreeRoots),
+    restrictWrites: true
+  });
+}
+var BWRAP_BIN = "bwrap";
+function buildBwrapArgs(policy) {
+  const args = [];
+  args.push(policy.restrictWrites ? "--ro-bind" : "--bind", "/", "/");
+  args.push("--dev", "/dev");
+  args.push("--proc", "/proc");
+  for (const root of policy.baseWritableRoots) {
+    args.push("--bind-try", root, root);
+  }
+  for (const root of policy.deniedRoots) {
+    args.push("--tmpfs", root);
+  }
+  for (const root of policy.readonlyRoots) {
+    args.push("--ro-bind-try", root, root);
+  }
+  for (const root of policy.writableRoots) {
+    args.push("--bind-try", root, root);
+  }
+  args.push("--die-with-parent");
+  return args;
+}
+var SANDBOX_EXEC_PATH = "/usr/bin/sandbox-exec";
+function buildSeatbeltProfile(policy) {
+  const defines = [];
+  const lines = ["(version 1)", "(allow default)"];
+  if (policy.restrictWrites) {
+    lines.push('(deny file-write* (subpath "/"))');
+    lines.push('(allow file-write* (subpath "/dev"))');
+  }
+  policy.baseWritableRoots.forEach((root, i) => {
+    const name = `BASEWRITABLE_${i}`;
+    defines.push({ name, value: root });
+    lines.push(`(allow file-write* (subpath (param "${name}")))`);
+  });
+  policy.deniedRoots.forEach((root, i) => {
+    const name = `DENIED_${i}`;
+    defines.push({ name, value: root });
+    lines.push(`(deny file-read* file-write* (subpath (param "${name}")))`);
+    lines.push(`(allow file-read-metadata (literal (param "${name}")))`);
+  });
+  policy.writableRoots.forEach((root, i) => {
+    const name = `WRITABLE_${i}`;
+    defines.push({ name, value: root });
+    lines.push(`(allow file-read* file-write* (subpath (param "${name}")))`);
+  });
+  policy.readonlyRoots.forEach((root, i) => {
+    const name = `READONLY_${i}`;
+    defines.push({ name, value: root });
+    lines.push(`(allow file-read* (subpath (param "${name}")))`);
+  });
+  return { profile: `${lines.join(`
+`)}
+`, defines };
+}
+function buildSeatbeltArgs(policy) {
+  const { profile, defines } = buildSeatbeltProfile(policy);
+  const args = ["-p", profile];
+  for (const { name, value } of defines) {
+    args.push(`-D${name}=${value}`);
+  }
+  return args;
+}
+function wrapLauncher(launcher, policy, options) {
+  if (!options.backend)
+    return null;
+  if (launcher.length === 0)
+    return null;
+  switch (options.backend) {
+    case "seatbelt":
+      return [
+        SANDBOX_EXEC_PATH,
+        ...buildSeatbeltArgs(policy),
+        "--",
+        ...launcher
+      ];
+    case "bwrap":
+      return [
+        options.bwrapPath ?? BWRAP_BIN,
+        ...buildBwrapArgs(policy),
+        "--",
+        ...launcher
+      ];
+  }
+}
+function normalizeRoot(path) {
+  const trimmed = path.trim();
+  const expanded = trimmed.startsWith("~/") ? join3(homedir3(), trimmed.slice(2)) : trimmed.startsWith("$HOME/") ? join3(homedir3(), trimmed.slice(6)) : trimmed;
+  return resolve2(expanded);
+}
+function resolveWritableMemoryRoots(env) {
+  const roots = new Set;
+  for (const value of [env.MEMORY_DIR, env.LETTA_MEMORY_DIR]) {
+    if (!value?.trim())
+      continue;
+    const root = normalizeRoot(value);
+    roots.add(root);
+    if (basename2(root) === "memory") {
+      roots.add(join3(dirname2(root), "memory-worktrees"));
+    }
+  }
+  return [...roots];
+}
+function customHarnessWritableRoots(env) {
+  return [env.LETTA_LOCAL_BACKEND_DIR, env.LETTA_TRANSCRIPT_ROOT].filter((value) => Boolean(value?.trim())).map(normalizeRoot);
+}
+function createMemoryConfinementLauncherWithAvailability(input, availability) {
+  if (input.launcher.length === 0) {
+    throw new Error("Memory confinement requires a non-empty launcher.");
+  }
+  const memoryRoots = resolveWritableMemoryRoots(input.env);
+  if (memoryRoots.length === 0) {
+    throw new Error("Memory confinement requires MEMORY_DIR or LETTA_MEMORY_DIR.");
+  }
+  if (!availability.backend) {
+    throw new Error(`Memory confinement is unavailable: ${availability.reason}.`);
+  }
+  const localBackendStorageDir = input.env.LETTA_LOCAL_BACKEND_DIR?.trim() || undefined;
+  const policy = buildMemorySubagentSandboxPolicy({
+    memoryRoots,
+    agentsTreeRoots: getCrossBackendAgentsTreeRoots({
+      env: input.env,
+      localBackendStorageDir
+    }),
+    harnessWritableRoots: customHarnessWritableRoots(input.env)
+  });
+  const launcher = wrapLauncher(input.launcher, policy, {
+    backend: availability.backend,
+    bwrapPath: availability.bwrapPath
+  });
+  if (!launcher) {
+    throw new Error("Memory confinement could not wrap the launcher.");
+  }
+  return {
+    launcher,
+    env: { ...input.env, [SANDBOX_ENV_VAR]: availability.backend },
+    backend: availability.backend
+  };
+}
+var cached = null;
+var warnedUnavailableContexts = new Set;
+function detectSandboxBackend(options = {}) {
+  const platform = options.platform ?? process.platform;
+  if (!options.force && cached && !options.platform) {
+    return cached;
+  }
+  const result = probe(platform);
+  if (!options.platform) {
+    cached = result;
+  }
+  return result;
+}
+function probe(platform) {
+  if (platform === "darwin") {
+    if (existsSync2(SANDBOX_EXEC_PATH)) {
+      return { backend: "seatbelt", reason: "sandbox-exec available" };
+    }
+    return {
+      backend: null,
+      reason: `${SANDBOX_EXEC_PATH} not found`
+    };
+  }
+  if (platform === "linux") {
+    return probeBwrap();
+  }
+  return {
+    backend: null,
+    reason: `no filesystem sandbox backend for platform "${platform}"`
+  };
+}
+function probeBwrap() {
+  const bwrapPath = resolveExecutableOnPath("bwrap");
+  if (!bwrapPath) {
+    return { backend: null, reason: "bwrap not found on PATH" };
+  }
+  const version = spawnSync(bwrapPath, ["--version"], { timeout: 5000 });
+  if (version.error || version.status !== 0) {
+    return { backend: null, reason: "bwrap not found on PATH" };
+  }
+  const userns = spawnSync(bwrapPath, ["--ro-bind", "/", "/", "--unshare-user", "/bin/true"], { timeout: 5000 });
+  if (userns.error || userns.status !== 0) {
+    return {
+      backend: null,
+      reason: "bwrap present but user namespaces are unavailable"
+    };
+  }
+  return { backend: "bwrap", bwrapPath, reason: "bwrap available" };
+}
+function resolveExecutableOnPath(executable, envPath = process.env.PATH) {
+  if (isAbsolute2(executable) && existsSync2(executable))
+    return executable;
+  for (const dir of (envPath ?? "").split(delimiter)) {
+    if (!dir)
+      continue;
+    const candidate = join4(dir, executable);
+    if (existsSync2(candidate))
+      return candidate;
+  }
+  return null;
+}
+function createMemoryConfinementLauncher(input) {
+  return createMemoryConfinementLauncherWithAvailability(input, detectSandboxBackend());
+}
 
 // src/cli-resolver.ts
-import { existsSync } from "node:fs";
-import { createRequire as createRequire2 } from "node:module";
-import { dirname, join } from "node:path";
+import { existsSync as existsSync3 } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname as dirname3, join as join5 } from "node:path";
 import { fileURLToPath } from "node:url";
-var require2 = createRequire2(import.meta.url);
+var require2 = createRequire(import.meta.url);
 var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = dirname(__filename2);
+var __dirname2 = dirname3(__filename2);
 function findLettaCli() {
   const envPath = process.env.LETTA_CLI_PATH;
-  if (envPath && existsSync(envPath)) {
+  if (envPath && existsSync3(envPath)) {
     return envPath;
   }
   try {
     return require2.resolve("@letta-ai/letta-code");
   } catch {}
   const localPaths = [
-    join(__dirname2, "..", "node_modules", "@letta-ai", "letta-code", "letta.js"),
-    join(__dirname2, "../../@letta-ai/letta-code/letta.js"),
-    join(__dirname2, "../../../letta-code-prod/letta.js"),
-    join(__dirname2, "../../../letta-code/letta.js"),
-    join(__dirname2, "..", "..", "letta-code", "letta.js")
+    join5(__dirname2, "..", "node_modules", "@letta-ai", "letta-code", "letta.js"),
+    join5(__dirname2, "../../@letta-ai/letta-code/letta.js"),
+    join5(__dirname2, "../../../letta-code-prod/letta.js"),
+    join5(__dirname2, "../../../letta-code/letta.js"),
+    join5(__dirname2, "..", "..", "letta-code", "letta.js")
   ];
   for (const path of localPaths) {
-    if (existsSync(path)) {
+    if (existsSync3(path)) {
       return path;
     }
   }
@@ -9456,6 +9680,38 @@ function findLettaCli() {
 var DEFAULT_LISTEN_URL = "ws://127.0.0.1:0";
 var DEFAULT_STARTUP_TIMEOUT_MS = 30000;
 var LISTENING_RE = /^Listening on\s+(ws:\/\/\S+)\s*$/m;
+function targetHomeDirectory(env) {
+  if (process.platform === "win32") {
+    const profile = env.USERPROFILE?.trim();
+    if (profile)
+      return profile;
+    const drive = env.HOMEDRIVE?.trim();
+    const path = env.HOMEPATH?.trim();
+    if (drive && path)
+      return `${drive}${path}`;
+    return homedir4();
+  }
+  return env.HOME?.trim() || homedir4();
+}
+function withDefaultMemoryDirectory(env, options) {
+  const explicitMemoryDir = options.env?.MEMORY_DIR?.trim();
+  const explicitLettaMemoryDir = options.env?.LETTA_MEMORY_DIR?.trim();
+  const scopedEnv = { ...env };
+  if (explicitMemoryDir || explicitLettaMemoryDir) {
+    if (!explicitMemoryDir)
+      delete scopedEnv.MEMORY_DIR;
+    if (!explicitLettaMemoryDir)
+      delete scopedEnv.LETTA_MEMORY_DIR;
+    return scopedEnv;
+  }
+  delete scopedEnv.MEMORY_DIR;
+  delete scopedEnv.LETTA_MEMORY_DIR;
+  if (!options.agentId)
+    return scopedEnv;
+  const homeDir = targetHomeDirectory(env);
+  const memoryDir = options.backend === "api" ? join7(homeDir, ".letta", "agents", options.agentId, "memory") : join7(env.LETTA_LOCAL_BACKEND_DIR?.trim() || join7(homeDir, ".letta", "lc-local-backend"), "memfs", options.agentId, "memory");
+  return { ...scopedEnv, MEMORY_DIR: memoryDir };
+}
 function appendLine(buffer, chunk) {
   return buffer + String(chunk);
 }
@@ -9472,6 +9728,29 @@ function buildLocalAppServerArgs(cliPath, options = {}) {
     options.listen ?? DEFAULT_LISTEN_URL
   ];
 }
+function buildLocalAppServerProcess(cliPath, options = {}, confineMemory = createMemoryConfinementLauncher) {
+  const env = { ...process.env, ...options.env ?? {} };
+  const launcher = [
+    process.execPath,
+    ...buildLocalAppServerArgs(cliPath, options)
+  ];
+  if (options.filesystemConfinement !== "memory") {
+    return {
+      command: launcher[0],
+      args: launcher.slice(1),
+      env
+    };
+  }
+  const confined = confineMemory({
+    launcher,
+    env: withDefaultMemoryDirectory(env, options)
+  });
+  return {
+    command: confined.launcher[0],
+    args: confined.launcher.slice(1),
+    env: confined.env
+  };
+}
 function terminateProcess(child) {
   if (child.exitCode !== null || child.signalCode !== null)
     return;
@@ -9484,12 +9763,12 @@ function terminateProcess(child) {
 }
 function startLocalAppServer(options = {}) {
   const cliPath = options.cliPath ?? findLettaCli();
-  const args = buildLocalAppServerArgs(cliPath, options);
+  const processSpec = buildLocalAppServerProcess(cliPath, options);
   const startupTimeoutMs = options.startupTimeoutMs ?? DEFAULT_STARTUP_TIMEOUT_MS;
-  return new Promise((resolve, reject) => {
-    const child = spawn(process.execPath, args, {
+  return new Promise((resolve3, reject) => {
+    const child = spawn(processSpec.command, processSpec.args, {
       stdio: ["ignore", "pipe", "pipe"],
-      env: { ...process.env, ...options.env ?? {} }
+      env: processSpec.env
     });
     let settled = false;
     let output = "";
@@ -9513,7 +9792,7 @@ function startLocalAppServer(options = {}) {
         return;
       settled = true;
       cleanup();
-      resolve({
+      resolve3({
         url,
         close: () => terminateProcess(child)
       });
@@ -9547,7 +9826,7 @@ ${output.trim()}` : ""}`));
 }
 
 // src/local-app-server-session.ts
-function createLocalAppServerSession(options, mode, beforeConnect) {
+function createLocalAppServerSession(options, mode) {
   const appServer = options ?? {};
   const sessionOptions = {
     ...appServer.url !== undefined ? { url: appServer.url } : {
@@ -9555,1540 +9834,142 @@ function createLocalAppServerSession(options, mode, beforeConnect) {
         listen: appServer.listen,
         backend: appServer.harnessBackend ?? "local",
         startupTimeoutMs: appServer.startupTimeoutMs,
-        env: sessionEnv
+        env: sessionEnv,
+        filesystemConfinement: mode.kind === "session" ? mode.options.filesystemConfinement : undefined,
+        agentId: mode.kind === "session" && "agentId" in mode ? mode.agentId : undefined
       })
     },
     ...appServer.WebSocket !== undefined ? { WebSocket: appServer.WebSocket } : {},
     ...appServer.requestTimeoutMs !== undefined ? { requestTimeoutMs: appServer.requestTimeoutMs } : {},
-    ...appServer.pinGlobalAgent !== undefined ? { pinGlobalAgent: appServer.pinGlobalAgent } : {},
-    ...beforeConnect ? { beforeConnect } : {}
+    ...appServer.pinGlobalAgent !== undefined ? { pinGlobalAgent: appServer.pinGlobalAgent } : {}
   };
   return new AppServerSession(sessionOptions, mode);
 }
 
-// src/transport.ts
-import { spawn as spawn2 } from "node:child_process";
-import { createInterface } from "node:readline";
-function sdkLog(tag, ...args) {
-  if (process.env.DEBUG_SDK)
-    console.error(`[SDK-Transport] [${tag}]`, ...args);
+// src/client.ts
+class LettaAgentClient extends LettaAgentClientBase {
+  createLocalManagementTransport() {
+    const localOptions = this.options.appServer;
+    return new AppServerManagementTransport({
+      ...localOptions?.url !== undefined ? { url: localOptions.url } : {
+        connect: () => startLocalAppServer({
+          listen: localOptions?.listen,
+          backend: localOptions?.harnessBackend ?? "local",
+          startupTimeoutMs: localOptions?.startupTimeoutMs
+        })
+      },
+      ...localOptions?.WebSocket !== undefined ? { WebSocket: localOptions.WebSocket } : {},
+      ...localOptions?.requestTimeoutMs !== undefined ? { requestTimeoutMs: localOptions.requestTimeoutMs } : {}
+    });
+  }
+  async createLocalAgent(options) {
+    const localOptions = this.options;
+    const session = createLocalAppServerSession(localOptions.appServer, {
+      kind: "create-agent",
+      options
+    });
+    const initMsg = await session.initialize();
+    session.close();
+    return initMsg.agentId;
+  }
+  createLocalSession(agentId, options) {
+    const localOptions = this.options;
+    return createLocalAppServerSession(localOptions.appServer, {
+      kind: "session",
+      agentId,
+      newConversation: true,
+      options
+    });
+  }
+  resumeLocalSession(id, options) {
+    const localOptions = this.options;
+    if (looksLikeConversationId2(id)) {
+      return createLocalAppServerSession(localOptions.appServer, {
+        kind: "session",
+        conversationId: id,
+        options
+      });
+    }
+    return createLocalAppServerSession(localOptions.appServer, {
+      kind: "session",
+      agentId: id,
+      defaultConversation: true,
+      options
+    });
+  }
 }
-var SDK_AGENT_ORIGIN_TAG = "origin:letta-code";
-function shouldApplyNewAgentDefaults(options) {
-  return options.createOnly === true;
+function looksLikeConversationId2(id) {
+  return id.startsWith("conv-") || id.startsWith("local-conv-");
 }
-function includeSdkAgentOriginTag(tags) {
-  const normalizedTags = [];
-  let hasOriginTag = false;
-  for (const tag of tags ?? []) {
-    if (tag === SDK_AGENT_ORIGIN_TAG) {
-      if (hasOriginTag)
-        continue;
-      hasOriginTag = true;
+// src/websocket.ts
+function createReactNativeWebSocketConstructor(WebSocket) {
+  class ReactNativeWebSocketAdapter {
+    constructor(url, options) {
+      return new WebSocket(url, undefined, options);
     }
-    normalizedTags.push(tag);
-  }
-  if (!hasOriginTag) {
-    normalizedTags.push(SDK_AGENT_ORIGIN_TAG);
   }
-  return normalizedTags;
+  return ReactNativeWebSocketAdapter;
 }
-function buildCliArgs(options) {
-  const args = [
-    "--output-format",
-    "stream-json",
-    "--input-format",
-    "stream-json"
-  ];
-  const applyNewAgentDefaults = shouldApplyNewAgentDefaults(options);
-  if (options.conversationId) {
-    args.push("--conversation", options.conversationId);
-  } else if (options.agentId) {
-    args.push("--agent", options.agentId);
-    if (options.newConversation) {
-      args.push("--new");
-    } else if (options.defaultConversation) {
-      args.push("--conversation", "default");
-    }
-  } else if (options.createOnly) {
-    args.push("--new-agent");
-  } else if (options.newConversation) {
-    args.push("--new");
-  }
-  if (options.model) {
-    args.push("-m", options.model);
-  }
-  if (options.includePartialMessages) {
-    args.push("--include-partial-messages");
-  }
-  if (options.embedding) {
-    args.push("--embedding", options.embedding);
-  }
-  if (options.systemPrompt !== undefined) {
-    if (typeof options.systemPrompt === "string") {
-      const validPresets = [
-        "default",
-        "letta-claude",
-        "letta-codex",
-        "letta-gemini",
-        "claude",
-        "codex",
-        "gemini"
-      ];
-      if (validPresets.includes(options.systemPrompt)) {
-        args.push("--system", options.systemPrompt);
-      } else {
-        args.push("--system-custom", options.systemPrompt);
-      }
-    } else {
-      args.push("--system", options.systemPrompt.preset);
-      if (options.systemPrompt.append) {
-        args.push("--system-append", options.systemPrompt.append);
-      }
-    }
+// src/stream-events.ts
+function extractTextFromContent2(content) {
+  if (typeof content === "string") {
+    return content;
   }
-  if (options.memory !== undefined && !options.agentId) {
-    if (options.memory.length === 0) {
-      args.push("--init-blocks", "");
-    } else {
-      const presetNames = [];
-      const memoryBlocksJson = [];
-      for (const item of options.memory) {
-        if (typeof item === "string") {
-          presetNames.push(item);
-        } else if ("blockId" in item) {
-          memoryBlocksJson.push(item);
-        } else {
-          memoryBlocksJson.push(item);
-        }
+  if (Array.isArray(content)) {
+    const pieces = [];
+    for (const part of content) {
+      if (typeof part === "string") {
+        pieces.push(part);
+        continue;
       }
-      if (memoryBlocksJson.length > 0) {
-        args.push("--memory-blocks", JSON.stringify(memoryBlocksJson));
-        if (presetNames.length > 0) {
-          console.warn("[letta-agent-sdk] Using custom memory blocks. " + `Preset blocks are ignored when custom blocks are provided: ${presetNames.join(", ")}`);
-        }
-      } else if (presetNames.length > 0) {
-        args.push("--init-blocks", presetNames.join(","));
+      if (!part || typeof part !== "object") {
+        continue;
+      }
+      const rec = part;
+      if (typeof rec.text === "string") {
+        pieces.push(rec.text);
       }
     }
+    const joined = pieces.join("");
+    return joined.length > 0 ? joined : null;
   }
-  if (!options.agentId) {
-    if (options.persona !== undefined) {
-      args.push("--block-value", `persona=${options.persona}`);
-    }
-    if (options.human !== undefined) {
-      args.push("--block-value", `human=${options.human}`);
+  if (content && typeof content === "object") {
+    const rec = content;
+    if (typeof rec.text === "string") {
+      return rec.text;
     }
   }
-  const mode = normalizePermissionMode(options.permissionMode);
-  if (mode !== undefined) {
-    args.push("--permission-mode", mode);
-  }
-  if (options.allowedTools) {
-    args.push("--allowedTools", options.allowedTools.join(","));
-  }
-  if (options.disallowedTools) {
-    args.push("--disallowedTools", options.disallowedTools.join(","));
-  }
-  const tags = applyNewAgentDefaults ? includeSdkAgentOriginTag(options.tags) : options.tags;
-  if (tags && tags.length > 0) {
-    args.push("--tags", tags.join(","));
+  return null;
+}
+function extractStreamTextDelta(event) {
+  if (!event || typeof event !== "object") {
+    return null;
   }
-  if (applyNewAgentDefaults) {
-    args.push("--memfs");
-    if (options.baseTools !== undefined) {
-      args.push("--base-tools", options.baseTools.length > 0 ? options.baseTools.join(",") : "none");
+  const rec = event;
+  const maybeDelta = rec.delta;
+  if (maybeDelta && typeof maybeDelta === "object") {
+    const delta = maybeDelta;
+    if (typeof delta.reasoning === "string" && delta.reasoning.length > 0) {
+      return { kind: "reasoning", text: delta.reasoning };
     }
-  }
-  if (options.skillSources !== undefined) {
-    const sources = [...new Set(options.skillSources)];
-    if (sources.length === 0) {
-      args.push("--no-skills");
-    } else {
-      args.push("--skill-sources", sources.join(","));
+    if (typeof delta.text === "string" && delta.text.length > 0) {
+      return { kind: "assistant", text: delta.text };
     }
   }
-  if (options.systemInfoReminder === false) {
-    args.push("--no-system-info-reminder");
-  }
-  if (options.dreaming?.trigger !== undefined) {
-    args.push("--reflection-trigger", options.dreaming.trigger);
-  }
-  if (options.dreaming?.behavior !== undefined) {
-    args.push("--reflection-behavior", options.dreaming.behavior);
+  const messageType = rec.message_type;
+  if (messageType === "reasoning_message") {
+    const reasoningText = typeof rec.reasoning === "string" ? rec.reasoning : extractTextFromContent2(rec.content);
+    if (reasoningText && reasoningText.length > 0) {
+      return { kind: "reasoning", text: reasoningText };
+    }
   }
-  if (options.dreaming?.stepCount !== undefined) {
-    args.push("--reflection-step-count", String(options.dreaming.stepCount));
+  if (messageType === "assistant_message") {
+    const assistantText = extractTextFromContent2(rec.content);
+    if (assistantText && assistantText.length > 0) {
+      return { kind: "assistant", text: assistantText };
+    }
   }
-  return args;
-}
-
-class SubprocessTransport {
-  options;
-  process = null;
-  stdout = null;
-  messageQueue = [];
-  messageResolvers = [];
-  closed = false;
-  agentId;
-  wireMessageCount = 0;
-  lastMessageAt = 0;
-  stderrLines = [];
-  constructor(options = {}) {
-    this.options = options;
-  }
-  async connect() {
-    const args = this.buildArgs();
-    const cliPath = await this.findCli();
-    sdkLog("connect", `CLI: ${cliPath}`);
-    sdkLog("connect", `args: ${args.join(" ")}`);
-    sdkLog("connect", `cwd: ${this.options.cwd || process.cwd()}`);
-    sdkLog("connect", `permissionMode: ${this.options.permissionMode || "default"}`);
-    this.process = spawn2("node", [cliPath, ...args], {
-      cwd: this.options.cwd || process.cwd(),
-      stdio: ["pipe", "pipe", "pipe"],
-      env: { ...process.env }
-    });
-    const pid = this.process.pid;
-    sdkLog("connect", `CLI process spawned, pid=${pid}`);
-    if (!this.process.stdout || !this.process.stdin) {
-      throw new Error("Failed to create subprocess pipes");
-    }
-    this.stdout = createInterface({
-      input: this.process.stdout,
-      crlfDelay: Infinity
-    });
-    this.stdout.on("line", (line) => {
-      if (!line.trim())
-        return;
-      try {
-        const msg = JSON.parse(line);
-        this.handleMessage(msg);
-      } catch {
-        sdkLog("stdout", `[non-JSON] ${line.slice(0, 500)}`);
-      }
-    });
-    if (this.process.stderr) {
-      this.process.stderr.on("data", (data) => {
-        const msg = data.toString().trim();
-        if (msg) {
-          console.error("[letta-agent-sdk] CLI stderr:", msg);
-          this.stderrLines.push(msg);
-        }
-      });
-    }
-    this.process.on("close", (code, signal) => {
-      if (code !== 0 && code !== null) {
-        console.error(`[letta-agent-sdk] CLI process exited with code ${code}`);
-      }
-      sdkLog("close", `CLI process exited: pid=${pid} code=${code} signal=${signal} wireMessages=${this.wireMessageCount} msSinceLastMsg=${this.lastMessageAt ? Date.now() - this.lastMessageAt : 0} pendingResolvers=${this.messageResolvers.length} queueLen=${this.messageQueue.length}`);
-      this.closed = true;
-      for (const resolve of this.messageResolvers) {
-        resolve(null);
-      }
-      this.messageResolvers = [];
-    });
-    this.process.on("error", (err) => {
-      console.error("[letta-agent-sdk] CLI process error:", err);
-      this.closed = true;
-    });
-  }
-  async write(data) {
-    if (!this.process?.stdin || this.closed) {
-      const err = new Error(`Transport not connected (closed=${this.closed}, pid=${this.process?.pid}, stdin=${!!this.process?.stdin})`);
-      sdkLog("write", err.message);
-      throw err;
-    }
-    const payload = data;
-    sdkLog("write", `type=${payload.type} subtype=${payload.request?.subtype || payload.response?.subtype || "N/A"}`);
-    this.process.stdin.write(JSON.stringify(data) + `
-`);
-  }
-  async read() {
-    if (this.messageQueue.length > 0) {
-      return this.messageQueue.shift();
-    }
-    if (this.closed) {
-      sdkLog("read", `returning null (closed), total wireMessages=${this.wireMessageCount}`);
-      return null;
-    }
-    sdkLog("read", `waiting for next message (resolvers=${this.messageResolvers.length + 1}, queue=${this.messageQueue.length})`);
-    return new Promise((resolve) => {
-      this.messageResolvers.push(resolve);
-    });
-  }
-  async* messages() {
-    while (true) {
-      const msg = await this.read();
-      if (msg === null) {
-        sdkLog("messages", `iterator ending (closed=${this.closed}, wireMessages=${this.wireMessageCount})`);
-        break;
-      }
-      yield msg;
-    }
-  }
-  close() {
-    sdkLog("close", `explicit close called (wireMessages=${this.wireMessageCount}, pendingResolvers=${this.messageResolvers.length}, pid=${this.process?.pid})`);
-    if (this.process) {
-      this.process.stdin?.end();
-      this.process.kill();
-      this.process = null;
-    }
-    this.closed = true;
-    for (const resolve of this.messageResolvers) {
-      resolve(null);
-    }
-    this.messageResolvers = [];
-  }
-  get isClosed() {
-    return this.closed;
-  }
-  getStderr() {
-    return this.stderrLines.join(`
-`);
-  }
-  handleMessage(msg) {
-    this.wireMessageCount++;
-    this.lastMessageAt = Date.now();
-    const wirePayload = msg;
-    const msgType = wirePayload.message_type || wirePayload.subtype || "";
-    sdkLog("wire", `#${this.wireMessageCount} type=${msg.type} ${msgType ? `msg_type=${msgType}` : ""} resolvers=${this.messageResolvers.length} queue=${this.messageQueue.length}`);
-    if (msg.type === "result") {
-      const result = wirePayload;
-      sdkLog("wire", `RESULT: subtype=${result.subtype} stop_reason=${result.stop_reason || "N/A"} duration=${result.duration_ms}ms resultLen=${result.result?.length || 0}`);
-    }
-    if (msg.type === "system" && "subtype" in msg && msg.subtype === "init") {
-      this.agentId = msg.agent_id;
-      sdkLog("wire", `INIT: agent_id=${this.agentId}`);
-    }
-    if (msg.type === "control_request") {
-      const req = wirePayload;
-      sdkLog("wire", `CONTROL_REQUEST: id=${req.request_id} subtype=${req.request?.subtype} tool=${req.request?.tool_name || "N/A"}`);
-    }
-    if (this.messageResolvers.length > 0) {
-      const resolve = this.messageResolvers.shift();
-      resolve(msg);
-    } else {
-      this.messageQueue.push(msg);
-    }
-  }
-  buildArgs() {
-    return buildCliArgs(this.options);
-  }
-  async findCli() {
-    const { existsSync: existsSync2 } = await import("node:fs");
-    const { dirname: dirname2, join: join2 } = await import("node:path");
-    const { fileURLToPath: fileURLToPath2 } = await import("node:url");
-    if (process.env.LETTA_CLI_PATH && existsSync2(process.env.LETTA_CLI_PATH)) {
-      return process.env.LETTA_CLI_PATH;
-    }
-    try {
-      const { createRequire: createRequire3 } = await import("node:module");
-      const require3 = createRequire3(import.meta.url);
-      const resolved = require3.resolve("@letta-ai/letta-code");
-      if (existsSync2(resolved)) {
-        return resolved;
-      }
-    } catch {}
-    const __filename3 = fileURLToPath2(import.meta.url);
-    const __dirname3 = dirname2(__filename3);
-    const localPaths = [
-      join2(__dirname3, "../../@letta-ai/letta-code/letta.js"),
-      join2(__dirname3, "../../../letta-code-prod/letta.js"),
-      join2(__dirname3, "../../../letta-code/letta.js")
-    ];
-    for (const p of localPaths) {
-      if (existsSync2(p)) {
-        return p;
-      }
-    }
-    throw new Error("Letta Code CLI not found. Set LETTA_CLI_PATH or install @letta-ai/letta-code.");
-  }
-}
-
-// src/session.ts
-function sessionLog(tag, ...args) {
-  if (process.env.DEBUG_SDK)
-    console.error(`[SDK-Session] [${tag}]`, ...args);
-}
-var MAX_BUFFERED_STREAM_MESSAGES = 100;
-var DEFAULT_MAX_APPROVAL_RECOVERY_ATTEMPTS = 1;
-var DEFAULT_APPROVAL_RECOVERY_TIMEOUT_MS = 5000;
-var KNOWN_SDK_ERROR_CODES2 = new Set([
-  "approval_conflict",
-  "approval_conflict_terminal",
-  "protocol_error",
-  "error",
-  "llm_api_error",
-  "max_steps",
-  "interrupted",
-  "stream_closed"
-]);
-function isKnownSdkErrorCode(value) {
-  return KNOWN_SDK_ERROR_CODES2.has(value);
-}
-function toSdkErrorCode2(value) {
-  if (!value || value.length === 0)
-    return;
-  return isKnownSdkErrorCode(value) ? value : undefined;
-}
-function isUnknownControlSubtypeError(errorMessage, subtype) {
-  if (!errorMessage)
-    return false;
-  return errorMessage.toLowerCase().includes(`unknown control request subtype: ${subtype}`.toLowerCase());
-}
-function extractApiErrorDetail(apiError) {
-  const detail = apiError?.detail;
-  if (typeof detail !== "string")
-    return;
-  const trimmed = detail.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
-}
-function isApprovalConflictSignal2(params) {
-  if (params.stopReason === "requires_approval")
-    return true;
-  const haystack = [params.detail, params.message].filter((value) => typeof value === "string" && value.length > 0).join(`
-`).toLowerCase();
-  if (!haystack)
-    return false;
-  return haystack.includes("waiting for approval on a tool call") || haystack.includes("cannot send a new message") || haystack.includes("requires_approval");
-}
-
-class Session {
-  options;
-  transport;
-  _agentId = null;
-  _sessionId = null;
-  _conversationId = null;
-  initialized = false;
-  closed = false;
-  initializePromise = null;
-  externalTools = new Map;
-  streamQueue = [];
-  streamResolvers = [];
-  pumpPromise = null;
-  pumpClosed = false;
-  droppedStreamMessages = 0;
-  sendGeneration = 0;
-  lastCompletedRunIds = new Set;
-  controlResponseWaiters = new Map;
-  constructor(options = {}) {
-    this.options = options;
-    if (options.reasoningEffort !== undefined) {
-      throw new Error("reasoningEffort is not supported by this session. Create a Cloud, Remote, or local agent session before setting reasoning effort.");
-    }
-    this.transport = new SubprocessTransport(options);
-    if (options.tools) {
-      for (const tool of options.tools) {
-        this.externalTools.set(tool.name, tool);
-      }
-    }
-  }
-  async initialize() {
-    if (this.closed) {
-      throw new Error("Session is closed");
-    }
-    if (this.initializePromise) {
-      return this.initializePromise;
-    }
-    if (this.initialized) {
-      throw new Error("Session already initialized");
-    }
-    const attempt = this.performInitialize();
-    const memo = attempt.catch((error) => {
-      this.cleanupFailedInitialize();
-      throw error;
-    }).finally(() => {
-      if (this.initializePromise === memo) {
-        this.initializePromise = null;
-      }
-    });
-    this.initializePromise = memo;
-    return memo;
-  }
-  async performInitialize() {
-    sessionLog("init", "connecting transport...");
-    await this.transport.connect();
-    sessionLog("init", "transport connected, sending initialize request");
-    await this.transport.write({
-      type: "control_request",
-      request_id: "init_1",
-      request: { subtype: "initialize" }
-    });
-    sessionLog("init", "waiting for init message from CLI...");
-    for await (const msg of this.transport.messages()) {
-      sessionLog("init", `received wire message: type=${msg.type}`);
-      if (msg.type === "control_request") {
-        const handled = await this.handleControlRequest(msg);
-        if (!handled) {
-          const wireMsgAny = msg;
-          sessionLog("init", `DROPPED unsupported control_request: subtype=${wireMsgAny.request?.subtype || "N/A"}`);
-        }
-        continue;
-      }
-      if (msg.type === "system" && "subtype" in msg && msg.subtype === "init") {
-        const initMsg = msg;
-        this._agentId = initMsg.agent_id;
-        this._sessionId = initMsg.session_id;
-        this._conversationId = initMsg.conversation_id;
-        if (this.externalTools.size > 0) {
-          await this.registerExternalTools();
-        }
-        if (this.closed) {
-          throw new Error("Session is closed");
-        }
-        this.initialized = true;
-        this.startBackgroundPump();
-        const allTools = [
-          ...initMsg.tools,
-          ...Array.from(this.externalTools.keys())
-        ];
-        sessionLog("init", `initialized: agent=${initMsg.agent_id} conversation=${initMsg.conversation_id} model=${initMsg.model} tools=${allTools.length} (${this.externalTools.size} external)`);
-        return {
-          type: "init",
-          agentId: initMsg.agent_id,
-          sessionId: initMsg.session_id,
-          conversationId: initMsg.conversation_id,
-          model: initMsg.model,
-          tools: allTools,
-          memfsEnabled: initMsg.memfs_enabled,
-          skillSources: initMsg.skill_sources,
-          systemInfoReminderEnabled: initMsg.system_info_reminder_enabled,
-          dreaming: initMsg.reflection_trigger && initMsg.reflection_behavior && typeof initMsg.reflection_step_count === "number" ? {
-            trigger: initMsg.reflection_trigger,
-            behavior: initMsg.reflection_behavior,
-            stepCount: initMsg.reflection_step_count
-          } : undefined
-        };
-      }
-    }
-    const stderr = this.transport.getStderr();
-    const detail = stderr ? `
-CLI stderr:
-${stderr}` : "";
-    sessionLog("init", `ERROR: transport closed before init message received${detail}`);
-    throw new Error(`Failed to initialize session - no init message received${detail}`);
-  }
-  cleanupFailedInitialize() {
-    this.transport.close();
-    this.closed = true;
-    this.initialized = false;
-    this._agentId = null;
-    this._sessionId = null;
-    this._conversationId = null;
-    this.pumpClosed = true;
-    this.resolveAllStreamWaiters(null);
-  }
-  async send(message) {
-    if (!this.initialized) {
-      sessionLog("send", "auto-initializing (not yet initialized)");
-      await this.initialize();
-    }
-    const preview = typeof message === "string" ? message.slice(0, 100) : Array.isArray(message) ? `[multimodal: ${message.length} parts]` : String(message).slice(0, 100);
-    sessionLog("send", `sending message: ${preview}${typeof message === "string" && message.length > 100 ? "..." : ""}`);
-    if (this.streamQueue.length > 0) {
-      sessionLog("send", `clearing ${this.streamQueue.length} stale messages from previous turn`);
-      this.streamQueue.length = 0;
-    }
-    await this.transport.write({
-      type: "user",
-      message: { role: "user", content: message }
-    });
-    this.sendGeneration++;
-    sessionLog("send", `message written to transport (generation=${this.sendGeneration})`);
-  }
-  async runTurn(message, options = {}) {
-    const maxApprovalRecoveryAttempts = this.resolveMaxApprovalRecoveryAttempts(options);
-    const recoveryTimeoutMs = this.resolveApprovalRecoveryTimeoutMs(options);
-    let recoveryAttempts = 0;
-    let result = await this.runSingleTurn(message);
-    while (!result.success && result.approvalConflict === true && recoveryAttempts < maxApprovalRecoveryAttempts) {
-      recoveryAttempts += 1;
-      const recovery = await this.recoverPendingApprovals({
-        timeoutMs: recoveryTimeoutMs
-      });
-      if (!recovery.recovered) {
-        return this.toTerminalApprovalConflictResult(result, {
-          recoveryAttempts,
-          detail: recovery.detail
-        });
-      }
-      result = await this.runSingleTurn(message);
-    }
-    if (!result.success && result.approvalConflict === true) {
-      return this.toTerminalApprovalConflictResult(result, { recoveryAttempts });
-    }
-    if (recoveryAttempts > 0) {
-      result.recoveryAttempts = recoveryAttempts;
-    }
-    return result;
-  }
-  async recoverPendingApprovals(options = {}) {
-    if (!this.initialized) {
-      await this.initialize();
-    }
-    const timeoutMs = options.timeoutMs ?? this.options.approvalRecoveryTimeoutMs ?? DEFAULT_APPROVAL_RECOVERY_TIMEOUT_MS;
-    if (!Number.isInteger(timeoutMs) || timeoutMs <= 0) {
-      throw new Error("Invalid approval recovery timeout. Expected a positive integer.");
-    }
-    const requestId = `recover-approvals-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
-    let resp;
-    try {
-      resp = await this.requestControlResponse(requestId, {
-        subtype: "recover_pending_approvals",
-        ...this._agentId ? { agent_id: this._agentId } : {},
-        ...this._conversationId ? { conversation_id: this._conversationId } : {}
-      }, { timeoutMs });
-    } catch (error) {
-      const detail = error instanceof Error ? error.message : String(error);
-      return {
-        recovered: false,
-        unsupported: false,
-        detail
-      };
-    }
-    if (resp.subtype === "error") {
-      const detail = resp.error ?? "recover_pending_approvals failed";
-      return {
-        recovered: false,
-        pendingApproval: true,
-        unsupported: isUnknownControlSubtypeError(detail, "recover_pending_approvals"),
-        detail
-      };
-    }
-    return {
-      recovered: true,
-      pendingApproval: false,
-      unsupported: false
-    };
-  }
-  resolveMaxApprovalRecoveryAttempts(options) {
-    const value = options.maxApprovalRecoveryAttempts ?? this.options.maxApprovalRecoveryAttempts ?? DEFAULT_MAX_APPROVAL_RECOVERY_ATTEMPTS;
-    if (!Number.isInteger(value) || value < 0) {
-      throw new Error("Invalid maxApprovalRecoveryAttempts. Expected a non-negative integer.");
-    }
-    return value;
-  }
-  resolveApprovalRecoveryTimeoutMs(options) {
-    const value = options.recoveryTimeoutMs ?? this.options.approvalRecoveryTimeoutMs ?? DEFAULT_APPROVAL_RECOVERY_TIMEOUT_MS;
-    if (!Number.isInteger(value) || value <= 0) {
-      throw new Error("Invalid approval recovery timeout. Expected a positive integer.");
-    }
-    return value;
-  }
-  toTerminalApprovalConflictResult(result, options) {
-    return {
-      ...result,
-      success: false,
-      error: "approval_conflict_terminal",
-      errorCode: "approval_conflict_terminal",
-      approvalConflict: true,
-      recoverable: false,
-      recoveryAttempts: options.recoveryAttempts,
-      errorDetail: options.detail || result.errorDetail || "Approval conflict remained unresolved after bounded SDK recovery."
-    };
-  }
-  async runSingleTurn(message) {
-    await this.send(message);
-    let latestApprovalConflictDetail;
-    let latestNonConflictErrorDetail;
-    for await (const msg of this.stream()) {
-      if (msg.type === "error") {
-        const detail = msg.errorDetail || msg.message;
-        if (msg.approvalConflict) {
-          latestApprovalConflictDetail = detail;
-        } else {
-          latestNonConflictErrorDetail = detail;
-        }
-        continue;
-      }
-      if (msg.type === "result") {
-        if (!msg.success && !msg.errorDetail) {
-          if (msg.approvalConflict && latestApprovalConflictDetail) {
-            return {
-              ...msg,
-              errorDetail: latestApprovalConflictDetail
-            };
-          }
-          if (!msg.approvalConflict && latestNonConflictErrorDetail) {
-            return {
-              ...msg,
-              errorDetail: latestNonConflictErrorDetail
-            };
-          }
-        }
-        return msg;
-      }
-    }
-    return {
-      type: "result",
-      success: false,
-      error: "stream_closed",
-      errorCode: "stream_closed",
-      recoverable: false,
-      errorDetail: "Stream ended before terminal result",
-      durationMs: 0,
-      conversationId: this._conversationId
-    };
-  }
-  async* stream() {
-    const streamStart = Date.now();
-    const minGeneration = this.sendGeneration;
-    let yieldCount = 0;
-    let staleCount = 0;
-    let staleRunIdCount = 0;
-    let gotResult = false;
-    const currentStreamRunIds = new Set;
-    const staleRunIds = new Set(this.lastCompletedRunIds);
-    const approvalConflictDetailsByRunId = new Map;
-    let latestApprovalConflictDetail;
-    this.startBackgroundPump();
-    sessionLog("stream", `starting stream (agent=${this._agentId}, conversation=${this._conversationId}, generation=${minGeneration})`);
-    while (true) {
-      const bufferedMsg = await this.nextBufferedMessage();
-      if (!bufferedMsg) {
-        break;
-      }
-      if (bufferedMsg.generation < minGeneration) {
-        staleCount++;
-        sessionLog("stream", `discarding stale message: type=${bufferedMsg.message.type} generation=${bufferedMsg.generation} (current=${minGeneration})`);
-        continue;
-      }
-      if (bufferedMsg.runId && staleRunIds.has(bufferedMsg.runId)) {
-        staleRunIdCount++;
-        sessionLog("stream", `discarding stale message: type=${bufferedMsg.message.type} runId=${bufferedMsg.runId}`);
-        continue;
-      }
-      if (bufferedMsg.runId) {
-        currentStreamRunIds.add(bufferedMsg.runId);
-      }
-      const sdkMsg = bufferedMsg.message;
-      if (sdkMsg.type === "error" && sdkMsg.approvalConflict) {
-        const detail = sdkMsg.errorDetail || sdkMsg.message;
-        if (detail) {
-          latestApprovalConflictDetail = detail;
-          if (sdkMsg.runId) {
-            approvalConflictDetailsByRunId.set(sdkMsg.runId, detail);
-          }
-        }
-      }
-      let normalizedMsg = sdkMsg;
-      if (sdkMsg.type === "result" && !sdkMsg.success) {
-        let detail = sdkMsg.errorDetail;
-        if (!detail && Array.isArray(sdkMsg.runIds)) {
-          for (const runId of sdkMsg.runIds) {
-            const fromRun = approvalConflictDetailsByRunId.get(runId);
-            if (fromRun) {
-              detail = fromRun;
-              break;
-            }
-          }
-        }
-        if (!detail) {
-          detail = latestApprovalConflictDetail;
-        }
-        const approvalConflict = sdkMsg.approvalConflict === true || isApprovalConflictSignal2({
-          detail,
-          message: sdkMsg.errorCode || sdkMsg.error,
-          stopReason: sdkMsg.stopReason
-        });
-        if (approvalConflict) {
-          const normalizedErrorCode = !sdkMsg.errorCode || sdkMsg.errorCode === "error" ? "approval_conflict" : sdkMsg.errorCode;
-          const normalizedError = !sdkMsg.error || sdkMsg.error === "error" ? normalizedErrorCode : sdkMsg.error;
-          normalizedMsg = {
-            ...sdkMsg,
-            approvalConflict: true,
-            recoverable: sdkMsg.recoverable ?? true,
-            ...detail ? { errorDetail: detail } : {},
-            errorCode: normalizedErrorCode,
-            error: normalizedError
-          };
-        } else if (!sdkMsg.errorCode && sdkMsg.error) {
-          const errorCode = toSdkErrorCode2(sdkMsg.error);
-          if (errorCode) {
-            normalizedMsg = {
-              ...sdkMsg,
-              errorCode
-            };
-          }
-        }
-      }
-      yieldCount++;
-      sessionLog("stream", `yield #${yieldCount}: type=${normalizedMsg.type}${normalizedMsg.type === "result" ? ` success=${normalizedMsg.success} error=${normalizedMsg.error || "none"}` : ""}`);
-      yield normalizedMsg;
-      if (normalizedMsg.type === "result") {
-        gotResult = true;
-        this.updateCompletedRunIds(normalizedMsg.runIds, currentStreamRunIds);
-        break;
-      }
-    }
-    const elapsed = Date.now() - streamStart;
-    sessionLog("stream", `stream ended: duration=${elapsed}ms yielded=${yieldCount} staleFiltered=${staleCount} staleRunIdFiltered=${staleRunIdCount} dropped=${this.droppedStreamMessages} gotResult=${gotResult}`);
-    if (!gotResult) {
-      sessionLog("stream", "WARNING: stream ended WITHOUT a result message -- transport may have closed unexpectedly");
-    }
-  }
-  startBackgroundPump() {
-    if (this.pumpPromise) {
-      return;
-    }
-    this.pumpClosed = false;
-    this.pumpPromise = this.runBackgroundPump().catch((err) => {
-      sessionLog("pump", `ERROR: ${err instanceof Error ? err.message : String(err)}`);
-    }).finally(() => {
-      this.pumpClosed = true;
-      this.resolveAllStreamWaiters(null);
-    });
-  }
-  async runBackgroundPump() {
-    sessionLog("pump", "background pump started");
-    const indexToToolCallId = new Map;
-    for await (const wireMsg of this.transport.messages()) {
-      const wireMsgAny = wireMsg;
-      if (wireMsg.type === "control_request") {
-        const handled = await this.handleControlRequest(wireMsg);
-        if (!handled) {
-          sessionLog("pump", `DROPPED unsupported control_request: subtype=${wireMsgAny.request?.subtype || "N/A"}`);
-        }
-        continue;
-      }
-      if (wireMsg.type === "control_response") {
-        const respMsg = wireMsg;
-        const requestId = respMsg.response?.request_id;
-        if (requestId && this.controlResponseWaiters.has(requestId)) {
-          const resolve = this.controlResponseWaiters.get(requestId);
-          this.controlResponseWaiters.delete(requestId);
-          resolve(respMsg.response);
-        } else {
-          sessionLog("pump", `DROPPED unmatched control_response: request_id=${requestId ?? "N/A"}`);
-        }
-        continue;
-      }
-      const messageType = wireMsgAny.message_type;
-      if (wireMsg.type === "message" && (messageType === "tool_call_message" || messageType === "approval_request_message")) {
-        const toolCalls = wireMsgAny.tool_calls;
-        const toolCall = wireMsgAny.tool_call;
-        const tc = toolCalls?.[0] || toolCall;
-        if (tc) {
-          const fnObj = tc.function;
-          const tcId = tc.tool_call_id ?? tc.id;
-          const tcIndex = tc.index;
-          if (tcId && tcIndex !== undefined) {
-            indexToToolCallId.set(tcIndex, tcId);
-          } else if (!tcId && tcIndex !== undefined) {
-            const resolvedId = indexToToolCallId.get(tcIndex);
-            if (resolvedId) {
-              if (fnObj) {
-                tc.id = resolvedId;
-              } else {
-                tc.tool_call_id = resolvedId;
-              }
-            }
-          }
-        }
-      }
-      const sdkMsg = this.transformMessage(wireMsg);
-      if (sdkMsg) {
-        this.enqueueStreamMessage(sdkMsg);
-      } else {
-        sessionLog("pump", `DROPPED wire message: type=${wireMsg.type} message_type=${wireMsgAny.message_type || "N/A"} subtype=${wireMsgAny.subtype || "N/A"}`);
-      }
-    }
-    sessionLog("pump", "background pump ended");
-  }
-  async handleControlRequest(controlReq) {
-    const subtype = controlReq.request.subtype;
-    sessionLog("pump", `control_request: subtype=${subtype} tool=${controlReq.request.tool_name || "N/A"}`);
-    if (subtype === "can_use_tool") {
-      await this.handleCanUseTool(controlReq.request_id, controlReq.request);
-      return true;
-    }
-    if (subtype === "execute_external_tool") {
-      const rawReq = controlReq.request;
-      await this.handleExecuteExternalTool(controlReq.request_id, {
-        subtype: "execute_external_tool",
-        tool_call_id: rawReq.tool_call_id,
-        tool_name: rawReq.tool_name,
-        input: rawReq.input
-      });
-      return true;
-    }
-    return false;
-  }
-  enqueueStreamMessage(msg) {
-    const bufferedMsg = {
-      message: msg,
-      generation: this.sendGeneration,
-      runId: this.getMessageRunId(msg)
-    };
-    if (this.streamResolvers.length > 0) {
-      const resolve = this.streamResolvers.shift();
-      resolve(bufferedMsg);
-      return;
-    }
-    if (this.streamQueue.length >= MAX_BUFFERED_STREAM_MESSAGES) {
-      this.streamQueue.shift();
-      this.droppedStreamMessages++;
-      sessionLog("pump", `stream queue overflow: dropped oldest message (total_dropped=${this.droppedStreamMessages}, max=${MAX_BUFFERED_STREAM_MESSAGES})`);
-    }
-    this.streamQueue.push(bufferedMsg);
-  }
-  async nextBufferedMessage() {
-    if (this.streamQueue.length > 0) {
-      return this.streamQueue.shift();
-    }
-    if (this.pumpClosed) {
-      return null;
-    }
-    return new Promise((resolve) => {
-      this.streamResolvers.push(resolve);
-    });
-  }
-  resolveAllStreamWaiters(msg) {
-    for (const resolve of this.streamResolvers) {
-      resolve(msg);
-    }
-    this.streamResolvers = [];
-    for (const resolve of this.controlResponseWaiters.values()) {
-      resolve({ subtype: "error", error: "session closed" });
-    }
-    this.controlResponseWaiters.clear();
-  }
-  getMessageRunId(msg) {
-    switch (msg.type) {
-      case "assistant":
-      case "tool_call":
-      case "tool_result":
-      case "reasoning":
-      case "error":
-      case "retry":
-        return msg.runId;
-      default:
-        return;
-    }
-  }
-  updateCompletedRunIds(resultRunIds, streamedRunIds) {
-    const nextRunIds = new Set;
-    if (Array.isArray(resultRunIds)) {
-      for (const runId of resultRunIds) {
-        if (runId) {
-          nextRunIds.add(runId);
-        }
-      }
-    }
-    for (const runId of streamedRunIds) {
-      if (runId) {
-        nextRunIds.add(runId);
-      }
-    }
-    this.lastCompletedRunIds = nextRunIds;
-  }
-  async registerExternalTools() {
-    const toolDefs = Array.from(this.externalTools.values()).map((tool) => ({
-      name: tool.name,
-      label: tool.label,
-      description: tool.description,
-      parameters: this.schemaToJsonSchema(tool.parameters)
-    }));
-    sessionLog("registerTools", `registering ${toolDefs.length} external tools: ${toolDefs.map((t) => t.name).join(", ")}`);
-    await this.transport.write({
-      type: "control_request",
-      request_id: `register_tools_${Date.now()}`,
-      request: {
-        subtype: "register_external_tools",
-        tools: toolDefs
-      }
-    });
-  }
-  schemaToJsonSchema(schema) {
-    if (schema && typeof schema === "object") {
-      const s = schema;
-      return {
-        type: s.type,
-        properties: s.properties,
-        required: s.required,
-        additionalProperties: s.additionalProperties,
-        description: s.description
-      };
-    }
-    return { type: "object" };
-  }
-  async handleExecuteExternalTool(requestId, req) {
-    const tool = this.externalTools.get(req.tool_name);
-    if (!tool) {
-      sessionLog("executeExternalTool", `ERROR: unknown tool ${req.tool_name}`);
-      await this.transport.write({
-        type: "control_response",
-        response: {
-          subtype: "external_tool_result",
-          request_id: requestId,
-          tool_call_id: req.tool_call_id,
-          content: [{ type: "text", text: `Unknown external tool: ${req.tool_name}` }],
-          is_error: true
-        }
-      });
-      return;
-    }
-    try {
-      sessionLog("executeExternalTool", `executing ${req.tool_name} (call_id=${req.tool_call_id})`);
-      const result = await tool.execute(req.tool_call_id, req.input);
-      await this.transport.write({
-        type: "control_response",
-        response: {
-          subtype: "external_tool_result",
-          request_id: requestId,
-          tool_call_id: req.tool_call_id,
-          content: result.content,
-          is_error: false
-        }
-      });
-      sessionLog("executeExternalTool", `${req.tool_name} completed successfully`);
-    } catch (err) {
-      const errorMessage = err instanceof Error ? err.message : String(err);
-      sessionLog("executeExternalTool", `${req.tool_name} failed: ${errorMessage}`);
-      await this.transport.write({
-        type: "control_response",
-        response: {
-          subtype: "external_tool_result",
-          request_id: requestId,
-          tool_call_id: req.tool_call_id,
-          content: [{ type: "text", text: `Tool execution error: ${errorMessage}` }],
-          is_error: true
-        }
-      });
-    }
-  }
-  async handleCanUseTool(requestId, req) {
-    let response;
-    const toolName = req.tool_name;
-    const hasCallback = typeof this.options.canUseTool === "function";
-    const toolNeedsRuntimeUserInput = requiresRuntimeUserInput(toolName);
-    const autoAllowWithoutCallback = isHeadlessAutoAllowTool(toolName);
-    sessionLog("canUseTool", `tool=${toolName} mode=${this.options.permissionMode || "standard"} requestId=${requestId}`);
-    if (toolNeedsRuntimeUserInput && !hasCallback) {
-      response = {
-        behavior: "deny",
-        message: "No canUseTool callback registered",
-        interrupt: false
-      };
-    } else if (isUnrestrictedPermissionMode(this.options.permissionMode) && !toolNeedsRuntimeUserInput) {
-      sessionLog("canUseTool", `AUTO-ALLOW ${toolName} (unrestricted)`);
-      response = {
-        behavior: "allow",
-        updatedInput: null,
-        updatedPermissions: []
-      };
-    } else if (hasCallback) {
-      try {
-        const result = await this.options.canUseTool(toolName, req.input, buildCanUseToolContext(req, requestId));
-        if (result.behavior === "allow") {
-          response = {
-            behavior: "allow",
-            updatedInput: result.updatedInput ?? null,
-            updatedPermissions: []
-          };
-        } else {
-          response = {
-            behavior: "deny",
-            message: result.message ?? "Denied by canUseTool callback",
-            interrupt: false
-          };
-        }
-      } catch (err) {
-        response = {
-          behavior: "deny",
-          message: err instanceof Error ? err.message : "Callback error",
-          interrupt: false
-        };
-      }
-    } else if (autoAllowWithoutCallback) {
-      sessionLog("canUseTool", `AUTO-ALLOW ${toolName} (default behavior)`);
-      response = {
-        behavior: "allow",
-        updatedInput: null,
-        updatedPermissions: []
-      };
-    } else {
-      response = {
-        behavior: "deny",
-        message: "No canUseTool callback registered",
-        interrupt: false
-      };
-    }
-    const responseBehavior = "behavior" in response ? response.behavior : "unknown";
-    sessionLog("canUseTool", `responding: requestId=${requestId} behavior=${responseBehavior}`);
-    await this.transport.write({
-      type: "control_response",
-      response: {
-        subtype: "success",
-        request_id: requestId,
-        response
-      }
-    });
-    sessionLog("canUseTool", `response sent for ${toolName}`);
-  }
-  async abort() {
-    if (!this.initialized || this.pumpClosed)
-      return;
-    sessionLog("abort", `aborting session (agent=${this._agentId})`);
-    await this.transport.write({
-      type: "control_request",
-      request_id: `interrupt-${Date.now()}`,
-      request: { subtype: "interrupt" }
-    });
-  }
-  async requestControlResponse(requestId, request, options = {}) {
-    const responsePromise = new Promise((resolve) => {
-      this.controlResponseWaiters.set(requestId, resolve);
-    });
-    try {
-      await this.transport.write({
-        type: "control_request",
-        request_id: requestId,
-        request
-      });
-    } catch (error) {
-      this.controlResponseWaiters.delete(requestId);
-      throw error;
-    }
-    let timeoutHandle;
-    try {
-      if (typeof options.timeoutMs === "number") {
-        return await Promise.race([
-          responsePromise,
-          new Promise((_, reject) => {
-            timeoutHandle = setTimeout(() => {
-              this.controlResponseWaiters.delete(requestId);
-              reject(new Error(`Timed out waiting for control_response (${requestId})`));
-            }, options.timeoutMs);
-          })
-        ]);
-      }
-      return await responsePromise;
-    } finally {
-      if (timeoutHandle) {
-        clearTimeout(timeoutHandle);
-      }
-    }
-  }
-  async listMessages(options = {}) {
-    if (!this.initialized) {
-      throw new Error("Session must be initialized before calling listMessages()");
-    }
-    const requestId = `list-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
-    const resp = await this.requestControlResponse(requestId, {
-      subtype: "list_messages",
-      ...options.conversationId ? { conversation_id: options.conversationId } : {},
-      ...options.before ? { before: options.before } : {},
-      ...options.after ? { after: options.after } : {},
-      ...options.order ? { order: options.order } : {},
-      ...options.limit !== undefined ? { limit: options.limit } : {}
-    });
-    if (!resp) {
-      throw new Error("Session closed before listMessages response arrived");
-    }
-    if (resp.subtype === "error") {
-      throw new Error(resp.error ?? "listMessages failed");
-    }
-    const payload = resp.response;
-    return {
-      messages: payload?.messages ?? [],
-      nextBefore: payload?.next_before ?? null,
-      hasMore: payload?.has_more ?? false
-    };
-  }
-  async listModels() {
-    throw new Error("listModels() is not supported by this session. Use a Cloud, Remote, or local agent session.");
-  }
-  async sendCommand(_command, _options) {
-    throw new Error("sendCommand() is not supported by this session. Use a Cloud, Remote, or local agent session.");
-  }
-  async updateModel(_update) {
-    throw new Error("updateModel() is not supported by this session. Use a Cloud, Remote, or local agent session.");
-  }
-  async changeDeviceState(_updates) {
-    throw new Error("changeDeviceState() is not supported by the legacy stdio transport. Use a Cloud, Remote, or local app-server session.");
-  }
-  async removeQueuedMessage(_itemId) {
-    throw new Error("removeQueuedMessage() is not supported by the legacy stdio transport. Use a Cloud, Remote, or local app-server session.");
-  }
-  async getDeviceStatus(_options) {
-    throw new Error("getDeviceStatus() is not supported by the legacy stdio transport. Use a Cloud, Remote, or local app-server session.");
-  }
-  onDeviceStatus(_listener) {
-    throw new Error("onDeviceStatus() is not supported by the legacy stdio transport. Use a Cloud, Remote, or local app-server session.");
-  }
-  async bootstrapState(options = {}) {
-    if (!this.initialized) {
-      throw new Error("Session must be initialized before calling bootstrapState()");
-    }
-    const requestId = `bootstrap-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
-    const resp = await this.requestControlResponse(requestId, {
-      subtype: "bootstrap_session_state",
-      ...options.limit !== undefined ? { limit: options.limit } : {},
-      ...options.order ? { order: options.order } : {}
-    });
-    if (!resp) {
-      throw new Error("Session closed before bootstrapState response arrived");
-    }
-    if (resp.subtype === "error") {
-      throw new Error(resp.error ?? "bootstrapState failed");
-    }
-    const payload = resp.response;
-    const state = {
-      agentId: payload?.agent_id ?? this._agentId ?? "",
-      conversationId: payload?.conversation_id ?? this._conversationId ?? "",
-      model: payload?.model,
-      memfsEnabled: payload?.memfs_enabled ?? false,
-      messages: payload?.messages ?? [],
-      nextBefore: payload?.next_before ?? null,
-      hasMore: payload?.has_more ?? false,
-      hasPendingApproval: payload?.has_pending_approval ?? false
-    };
-    if (payload?.tools !== undefined)
-      state.tools = payload.tools;
-    if (payload?.timings !== undefined)
-      state.timings = payload.timings;
-    return state;
-  }
-  async updateToolset(_toolsetPreference) {
-    throw new Error("updateToolset() is not supported by this session. Use a Cloud, Remote, or local agent session.");
-  }
-  close() {
-    if (this.closed)
-      return;
-    this.closed = true;
-    sessionLog("close", `closing session (agent=${this._agentId}, conversation=${this._conversationId})`);
-    this.transport.close();
-    this.pumpClosed = true;
-    this.resolveAllStreamWaiters(null);
-  }
-  get agentId() {
-    return this._agentId;
-  }
-  get sessionId() {
-    return this._sessionId;
-  }
-  get conversationId() {
-    return this._conversationId;
-  }
-  async[Symbol.asyncDispose]() {
-    this.close();
-  }
-  transformMessage(wireMsg) {
-    if (wireMsg.type === "system" && "subtype" in wireMsg && wireMsg.subtype === "init") {
-      const msg = wireMsg;
-      return {
-        type: "init",
-        agentId: msg.agent_id,
-        sessionId: msg.session_id,
-        conversationId: msg.conversation_id,
-        model: msg.model,
-        tools: msg.tools,
-        memfsEnabled: msg.memfs_enabled,
-        skillSources: msg.skill_sources,
-        systemInfoReminderEnabled: msg.system_info_reminder_enabled,
-        dreaming: msg.reflection_trigger && msg.reflection_behavior && typeof msg.reflection_step_count === "number" ? {
-          trigger: msg.reflection_trigger,
-          behavior: msg.reflection_behavior,
-          stepCount: msg.reflection_step_count
-        } : undefined
-      };
-    }
-    if (wireMsg.type === "message" && "message_type" in wireMsg) {
-      const msg = wireMsg;
-      const runId = msg.run_id || undefined;
-      if (msg.message_type === "assistant_message" && msg.content) {
-        return {
-          type: "assistant",
-          content: msg.content,
-          uuid: msg.uuid,
-          runId
-        };
-      }
-      if (msg.message_type === "tool_call_message" || msg.message_type === "approval_request_message") {
-        const toolCallRaw = msg.tool_calls?.[0] || msg.tool_call;
-        if (toolCallRaw) {
-          const fnObj = toolCallRaw.function;
-          const toolCallId = toolCallRaw.tool_call_id ?? toolCallRaw.id;
-          if (!toolCallId) {
-            const detail = `Missing tool_call_id in ${msg.message_type} (uuid=${msg.uuid || "unknown"})`;
-            sessionLog("transform", detail);
-            return {
-              type: "error",
-              message: detail,
-              errorCode: "protocol_error",
-              stopReason: "protocol_error",
-              runId,
-              apiError: {
-                error_type: "protocol_error",
-                detail,
-                message_type: msg.message_type
-              },
-              recoverable: false,
-              errorDetail: detail
-            };
-          }
-          const toolName = toolCallRaw.name ?? fnObj?.name ?? "?";
-          const toolArgs = toolCallRaw.arguments ?? fnObj?.arguments ?? "";
-          let toolInput = {};
-          try {
-            toolInput = JSON.parse(toolArgs);
-          } catch {
-            toolInput = { raw: toolArgs };
-          }
-          return {
-            type: "tool_call",
-            toolCallId,
-            toolName,
-            toolInput,
-            rawArguments: toolArgs || undefined,
-            uuid: msg.uuid,
-            runId
-          };
-        }
-      }
-      if (msg.message_type === "tool_return_message" && msg.tool_call_id) {
-        return {
-          type: "tool_result",
-          toolCallId: msg.tool_call_id,
-          content: msg.tool_return || "",
-          isError: msg.status === "error",
-          uuid: msg.uuid,
-          runId
-        };
-      }
-      if (msg.message_type === "reasoning_message" && msg.reasoning) {
-        return {
-          type: "reasoning",
-          content: msg.reasoning,
-          uuid: msg.uuid,
-          runId
-        };
-      }
-    }
-    if (wireMsg.type === "stream_event") {
-      const msg = wireMsg;
-      const eventPayload = msg.event ?? {};
-      return {
-        type: "stream_event",
-        event: eventPayload,
-        uuid: msg.uuid
-      };
-    }
-    if (wireMsg.type === "result") {
-      const msg = wireMsg;
-      const runIds = Array.isArray(msg.run_ids) ? msg.run_ids.filter((id) => typeof id === "string") : undefined;
-      const approvalConflict = isApprovalConflictSignal2({
-        stopReason: msg.stop_reason
-      });
-      const legacyError = msg.subtype !== "success" ? approvalConflict && msg.subtype === "error" ? "approval_conflict" : msg.subtype : undefined;
-      const errorCode = toSdkErrorCode2(legacyError);
-      return {
-        type: "result",
-        success: msg.subtype === "success",
-        result: msg.result,
-        error: legacyError,
-        errorCode,
-        ...approvalConflict ? {
-          approvalConflict: true,
-          recoverable: true
-        } : {},
-        stopReason: msg.stop_reason,
-        durationMs: msg.duration_ms,
-        totalCostUsd: msg.total_cost_usd,
-        conversationId: msg.conversation_id,
-        runIds
-      };
-    }
-    if (wireMsg.type === "error") {
-      const msg = wireMsg;
-      const errorDetail = extractApiErrorDetail(msg.api_error);
-      const approvalConflict = isApprovalConflictSignal2({
-        detail: errorDetail,
-        message: msg.message,
-        stopReason: msg.stop_reason
-      });
-      const errorCode = approvalConflict ? "approval_conflict" : toSdkErrorCode2(msg.stop_reason);
-      return {
-        type: "error",
-        message: msg.message,
-        ...errorCode ? { errorCode } : {},
-        ...approvalConflict ? {
-          approvalConflict: true,
-          recoverable: true
-        } : {},
-        ...errorDetail ? { errorDetail } : {},
-        stopReason: msg.stop_reason,
-        runId: msg.run_id,
-        apiError: msg.api_error
-      };
-    }
-    if (wireMsg.type === "retry") {
-      const msg = wireMsg;
-      return {
-        type: "retry",
-        reason: msg.reason,
-        attempt: msg.attempt,
-        maxAttempts: msg.max_attempts,
-        delayMs: msg.delay_ms,
-        runId: msg.run_id
-      };
-    }
-    return null;
-  }
-}
-
-// src/client.ts
-class LettaAgentClient extends LettaAgentClientBase {
-  createLocalManagementTransport() {
-    if (this.useLegacyLocalStdio()) {
-      throw new Error('client.agents and client.conversations require the local "app-server" transport.');
-    }
-    const localOptions = this.options.appServer;
-    return new AppServerManagementTransport({
-      ...localOptions?.url !== undefined ? { url: localOptions.url } : {
-        connect: () => startLocalAppServer({
-          listen: localOptions?.listen,
-          backend: localOptions?.harnessBackend ?? "local",
-          startupTimeoutMs: localOptions?.startupTimeoutMs
-        })
-      },
-      ...localOptions?.WebSocket !== undefined ? { WebSocket: localOptions.WebSocket } : {},
-      ...localOptions?.requestTimeoutMs !== undefined ? { requestTimeoutMs: localOptions.requestTimeoutMs } : {},
-      ...localOptions?.idleLingerMs !== undefined ? { idleLingerMs: localOptions.idleLingerMs } : {}
-    });
-  }
-  async createLocalAgent(options) {
-    if (!this.useLegacyLocalStdio()) {
-      const localOptions = this.options;
-      const session2 = createLocalAppServerSession(localOptions.appServer, {
-        kind: "create-agent",
-        options
-      }, () => this.releaseIdleManagementConnection());
-      const initMsg2 = await session2.initialize();
-      session2.close();
-      return initMsg2.agentId;
-    }
-    const session = new Session({ ...options, createOnly: true });
-    const initMsg = await session.initialize();
-    session.close();
-    return initMsg.agentId;
-  }
-  createLocalSession(agentId, options, sessionOptions) {
-    if (!this.useLegacyLocalStdio() && agentId) {
-      const localOptions = this.options;
-      return createLocalAppServerSession(localOptions.appServer, {
-        kind: "session",
-        agentId,
-        newConversation: true,
-        options
-      }, () => this.releaseIdleManagementConnection());
-    }
-    if (agentId) {
-      return new Session({ ...sessionOptions, agentId, newConversation: true });
-    }
-    return new Session({ ...sessionOptions, newConversation: true });
-  }
-  resumeLocalSession(id, options, sessionOptions) {
-    if (!this.useLegacyLocalStdio()) {
-      const localOptions = this.options;
-      if (looksLikeConversationId2(id)) {
-        return createLocalAppServerSession(localOptions.appServer, {
-          kind: "session",
-          conversationId: id,
-          options
-        }, () => this.releaseIdleManagementConnection());
-      }
-      return createLocalAppServerSession(localOptions.appServer, {
-        kind: "session",
-        agentId: id,
-        defaultConversation: true,
-        options
-      }, () => this.releaseIdleManagementConnection());
-    }
-    if (looksLikeConversationId2(id)) {
-      return new Session({ ...sessionOptions, conversationId: id });
-    }
-    return new Session({
-      ...sessionOptions,
-      agentId: id,
-      defaultConversation: true
-    });
-  }
-}
-function looksLikeConversationId2(id) {
-  return id.startsWith("conv-") || id.startsWith("local-conv-");
-}
-// src/websocket.ts
-function createReactNativeWebSocketConstructor(WebSocket) {
-  class ReactNativeWebSocketAdapter {
-    constructor(url, options) {
-      return new WebSocket(url, undefined, options);
-    }
-  }
-  return ReactNativeWebSocketAdapter;
-}
-// src/stream-events.ts
-function extractTextFromContent2(content) {
-  if (typeof content === "string") {
-    return content;
-  }
-  if (Array.isArray(content)) {
-    const pieces = [];
-    for (const part of content) {
-      if (typeof part === "string") {
-        pieces.push(part);
-        continue;
-      }
-      if (!part || typeof part !== "object") {
-        continue;
-      }
-      const rec = part;
-      if (typeof rec.text === "string") {
-        pieces.push(rec.text);
-      }
-    }
-    const joined = pieces.join("");
-    return joined.length > 0 ? joined : null;
-  }
-  if (content && typeof content === "object") {
-    const rec = content;
-    if (typeof rec.text === "string") {
-      return rec.text;
-    }
-  }
-  return null;
-}
-function extractStreamTextDelta(event) {
-  if (!event || typeof event !== "object") {
-    return null;
-  }
-  const rec = event;
-  const maybeDelta = rec.delta;
-  if (maybeDelta && typeof maybeDelta === "object") {
-    const delta = maybeDelta;
-    if (typeof delta.reasoning === "string" && delta.reasoning.length > 0) {
-      return { kind: "reasoning", text: delta.reasoning };
-    }
-    if (typeof delta.text === "string" && delta.text.length > 0) {
-      return { kind: "assistant", text: delta.text };
-    }
-  }
-  const messageType = rec.message_type;
-  if (messageType === "reasoning_message") {
-    const reasoningText = typeof rec.reasoning === "string" ? rec.reasoning : extractTextFromContent2(rec.content);
-    if (reasoningText && reasoningText.length > 0) {
-      return { kind: "reasoning", text: reasoningText };
-    }
-  }
-  if (messageType === "assistant_message") {
-    const assistantText = extractTextFromContent2(rec.content);
-    if (assistantText && assistantText.length > 0) {
-      return { kind: "assistant", text: assistantText };
-    }
-  }
-  return null;
+  return null;
 }
 // src/tool-helpers.ts
 function jsonResult(payload) {
@@ -11190,17 +10071,14 @@ async function createAgent(options = {}) {
 }
 function createSession(agentId, options = {}) {
   validateCreateSessionOptions(options);
-  if (agentId) {
-    return new LettaAgentClient().createSession(agentId, options);
-  }
-  return new LettaAgentClient({ backend: "local", transport: "stdio" }).createSession(options);
+  return new LettaAgentClient().createSession(agentId, options);
 }
 function resumeSession(id, options = {}) {
   validateCreateSessionOptions(options);
   return new LettaAgentClient().resumeSession(id, options);
 }
-async function prompt(message, agentId) {
-  const session = agentId ? createSession(agentId) : createSession();
+async function prompt(message, agentId, options = {}) {
+  const session = createSession(agentId, options);
   try {
     return await session.runTurn(message);
   } finally {
@@ -11267,10 +10145,9 @@ export {
   createSession,
   createReactNativeWebSocketConstructor,
   createAgent,
-  Session,
   RepositoriesClient,
   LettaAgentClient,
   CloudManagedSandboxExpiredError
 };
 
-//# debugId=01C64A8CE3FD2BF964756E2164756E21
+//# debugId=3A7EA512AEF37C3B64756E2164756E21