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

package/dist/client-entry.js

@@ -1,3 +1,5 @@
+// Generated bundle. Canonical modules are published under src/ and maintained in the letta-agent-sdk repository.
+
 // src/repositories.ts
 var DEFAULT_CLOUD_API_BASE_URL = "https://api.letta.com";
 function getDefaultApiKey() {
@@ -242,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() {
@@ -261,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) {
@@ -376,6 +390,7 @@ function streamDeltaErrorMessage(message) {
 }
 
 class AppServerClient {
+  socket;
   control;
   stream;
   requestTimeoutMs;
@@ -394,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() {
@@ -421,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);
@@ -441,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";
@@ -475,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",
@@ -694,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);
@@ -768,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");
@@ -843,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)
@@ -934,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({
@@ -949,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);
   }
@@ -981,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
@@ -5711,7 +5594,7 @@ function buildCanUseToolContext(request, requestId) {
   return context;
 }
 
-// src/remote-client-session-core.ts
+// src/remote-session-protocol.ts
 var FAILURE_STOP_REASONS = new Set([
   "error",
   "llm_api_error",
@@ -5948,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;
 }
@@ -6106,168 +5995,572 @@ function normalizeSendMessage(message) {
   return message;
 }
 
-class RemoteClientSessionCore {
-  mode;
-  controller = null;
-  runtime = null;
-  initialized = false;
-  closed = false;
-  activeTurnStartedAt = 0;
-  _agentId = null;
-  _sessionId = null;
-  _conversationId = null;
-  _model = "";
-  _modelSettings = null;
+// src/remote-turn-coordinator.ts
+class RemoteTurnCoordinator {
   label;
   requestTimeoutMs;
-  initializePromise = null;
+  onDeviceStatus;
   streamQueue = [];
   streamResolvers = [];
-  removeMessageHandler = null;
   activeTurn = null;
   pendingTurns = [];
   nextTurnId = 0;
   messageCounter = 0;
   clientMessageCounter = 0;
-  toolNames;
-  deviceStatusListeners = new Set;
-  deviceStatusRefreshCancels = new Set;
-  constructor(mode, config) {
-    this.mode = mode;
+  closed = false;
+  _activeTurnStartedAt = 0;
+  constructor(config) {
     this.label = config.label;
     this.requestTimeoutMs = config.requestTimeoutMs;
+    this.onDeviceStatus = config.onDeviceStatus;
   }
-  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() {
-    const init = await this.initializeRuntimeController();
-    this.controller = init.controller;
-    this.runtime = init.runtime;
-    this._agentId = init.runtime.agent_id;
-    this._conversationId = init.runtime.conversation_id;
-    this._sessionId = `${init.runtime.agent_id}:${init.runtime.conversation_id}`;
-    this._modelSettings = init.modelSettings ?? null;
-    this._model = typeof init.model === "string" ? init.model : typeof this._modelSettings?.model === "string" ? this._modelSettings.model : "";
-    this.toolNames = init.tools;
-    this.removeMessageHandler = this.controller.onMessage(this.handleProtocolMessage);
-    await this.afterRuntimeInitialized();
-    await this.applyPostInitializeOptions();
-    if (this.closed) {
-      throw new Error("Session is closed");
-    }
-    this.initialized = true;
-    const initMessage = {
-      type: "init",
-      agentId: init.runtime.agent_id,
-      sessionId: this._sessionId,
-      conversationId: init.runtime.conversation_id,
-      model: this._model
-    };
-    if (this.toolNames !== undefined)
-      initMessage.tools = this.toolNames;
-    if (init.skillSources !== undefined) {
-      initMessage.skillSources = init.skillSources;
-    }
-    return initMessage;
-  }
-  cleanupFailedInitialize() {
-    this.removeMessageHandler?.();
-    this.removeMessageHandler = null;
-    this.controller?.close();
-    this.controller = null;
-    this.onCoreClose();
-    this.runtime = null;
-    this._agentId = null;
-    this._conversationId = null;
-    this._sessionId = null;
-    this._modelSettings = null;
-    this._model = "";
-    this.toolNames = undefined;
-    this.initialized = false;
+  get activeTurnStartedAt() {
+    return this._activeTurnStartedAt;
   }
-  async send(message) {
-    if (!this.initialized) {
-      await this.initialize();
-    }
-    if (!this.controller || !this.runtime) {
-      throw new Error("Session is not initialized");
-    }
-    await this.beforeTurn();
-    const turn = this.trackSentTurn(this.runtime);
-    try {
-      this.controller.sendTurnMessage(this.runtime, message, {
-        clientMessageId: turn.clientMessageId
-      });
-    } catch (error) {
-      this.removeTrackedTurn(turn);
-      throw error;
-    }
+  hasInFlightTurn() {
+    return this.activeTurn !== null || this.pendingTurns.length > 0;
   }
-  async runTurn(message, _options = {}) {
-    if (this.activeTurn || this.pendingTurns.length > 0) {
-      throw new Error(`A turn is already in flight for this ${this.label} session. Use send() and stream() to let the listener queue messages.`);
-    }
-    await this.send(message);
-    for await (const msg of this.stream()) {
-      if (msg.type === "result") {
-        return msg;
-      }
-    }
-    return {
-      type: "result",
-      success: false,
-      error: "stream_closed",
-      errorCode: "stream_closed",
-      recoverable: false,
-      errorDetail: "Stream ended before terminal result",
-      durationMs: Date.now() - this.activeTurnStartedAt,
-      conversationId: this._conversationId
+  trackSentTurn(runtime) {
+    const turn = {
+      id: ++this.nextTurnId,
+      runtime,
+      clientMessageId: `sdk-message-${Date.now()}-${++this.clientMessageCounter}`,
+      queuedAt: Date.now(),
+      startedAt: 0,
+      assistantText: "",
+      runIds: new Set,
+      observedTurnEvidence: false,
+      observedRequiresApprovalStop: false,
+      abortRequested: false,
+      timeout: null
     };
-  }
-  async* stream() {
-    while (true) {
-      const msg = await this.nextMessage();
-      if (!msg)
-        break;
-      yield msg;
-      if (msg.type === "result")
-        break;
+    if (this.activeTurn) {
+      this.pendingTurns.push(turn);
+    } else {
+      this.activateTurn(turn);
     }
+    return turn;
   }
-  async abort() {
-    if (!this.initialized)
-      return;
-    if (!this.controller || !this.runtime)
+  removeTrackedTurn(turn) {
+    if (turn.timeout)
+      clearTimeout(turn.timeout);
+    if (this.activeTurn === turn) {
+      this.activeTurn = null;
       return;
+    }
+    const index = this.pendingTurns.indexOf(turn);
+    if (index !== -1)
+      this.pendingTurns.splice(index, 1);
+  }
+  markAbortRequested() {
     if (this.activeTurn)
       this.activeTurn.abortRequested = true;
-    await this.controller.abort(this.runtime);
   }
-  async sendCommand(command, options) {
-    if (!this.initialized) {
-      await this.initialize();
+  handleProtocolMessage(message, runtime) {
+    if (!sameRuntime2(message, runtime))
+      return;
+    const statusRecord = deviceStatusRecord(message);
+    if (statusRecord) {
+      const status = toSessionDeviceStatus(statusRecord);
+      if (status)
+        this.onDeviceStatus(status);
+      return;
     }
-    if (!this.controller) {
+    if (message.type === "update_queue") {
+      const sdkMessage2 = {
+        type: "queue_update",
+        queue: queueItems(message)
+      };
+      this.enqueue(sdkMessage2);
+      return;
+    }
+    if (message.type === "update_loop_status") {
+      this.handleLoopStatusMessage(message);
+      return;
+    }
+    const delta = streamDeltaRecord(message);
+    if (!delta)
+      return;
+    const active = this.activateNextTurnFromProtocol();
+    if (active) {
+      active.observedTurnEvidence = true;
+      const runId = streamDeltaRunId2(delta);
+      if (runId)
+        active.runIds.add(runId);
+    }
+    const sdkMessage = this.transformStreamDelta(delta);
+    if (sdkMessage)
+      this.enqueue(sdkMessage);
+    this.handleTurnTerminalDelta(delta, sdkMessage);
+  }
+  nextMessage() {
+    const next = this.streamQueue.shift();
+    if (next)
+      return Promise.resolve(next);
+    if (this.closed)
+      return Promise.resolve(null);
+    return new Promise((resolve) => {
+      this.streamResolvers.push(resolve);
+    });
+  }
+  close() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    if (this.activeTurn?.timeout)
+      clearTimeout(this.activeTurn.timeout);
+    for (const turn of this.pendingTurns) {
+      if (turn.timeout)
+        clearTimeout(turn.timeout);
+    }
+    this.activeTurn = null;
+    this.pendingTurns.length = 0;
+    this.resolveAll(null);
+  }
+  activateTurn(turn) {
+    this.activeTurn = turn;
+    turn.startedAt = Date.now();
+    this._activeTurnStartedAt = turn.startedAt;
+    if (this.requestTimeoutMs !== undefined) {
+      turn.timeout = setTimeout(() => {
+        this.failTurn(turn, `Timed out waiting for ${this.label} turn`);
+      }, this.requestTimeoutMs);
+      turn.timeout.unref?.();
+    }
+  }
+  activateNextTurnFromProtocol() {
+    if (this.activeTurn)
+      return this.activeTurn;
+    const next = this.pendingTurns.shift();
+    if (!next)
+      return null;
+    this.activateTurn(next);
+    return next;
+  }
+  failTurn(turn, detail) {
+    if (this.activeTurn !== turn)
+      return;
+    this.enqueue({
+      type: "error",
+      message: detail,
+      errorCode: "error",
+      stopReason: "error",
+      errorDetail: detail,
+      recoverable: false
+    });
+    this.completeActiveTurn({
+      runtime: turn.runtime,
+      stopReason: "error",
+      runIds: [...turn.runIds],
+      success: false,
+      detail,
+      errorCode: "error"
+    });
+  }
+  completeActiveTurn(turn) {
+    const active = this.activeTurn;
+    if (!active)
+      return;
+    if (active.timeout) {
+      clearTimeout(active.timeout);
+      active.timeout = null;
+    }
+    this.enqueue(this.resultFromTurn(turn, active));
+    this.activeTurn = null;
+  }
+  handleLoopStatusMessage(message) {
+    const status = loopStatusValue(message);
+    if (!status)
+      return;
+    const activeRunIds = loopStatusRunIds(message);
+    const sdkMessage = {
+      type: "loop_status",
+      status,
+      activeRunIds
+    };
+    this.enqueue(sdkMessage);
+    const active = this.activeTurn;
+    if (!active)
+      return;
+    for (const runId of activeRunIds)
+      active.runIds.add(runId);
+    const hadTurnEvidence = active.observedTurnEvidence || active.observedRequiresApprovalStop;
+    if (!hadTurnEvidence)
+      return;
+    if (status === "WAITING_ON_APPROVAL") {
+      this.completeActiveTurn({
+        runtime: active.runtime,
+        stopReason: "requires_approval",
+        runIds: [...active.runIds]
+      });
+      return;
+    }
+    if (status === "WAITING_ON_INPUT" && active.abortRequested) {
+      this.completeActiveTurn({
+        runtime: active.runtime,
+        stopReason: "interrupted",
+        runIds: [...active.runIds],
+        success: false,
+        detail: "Interrupted",
+        errorCode: "interrupted"
+      });
+      return;
+    }
+    if (status === "WAITING_ON_INPUT" && active.observedTurnEvidence) {
+      this.completeActiveTurn({
+        runtime: active.runtime,
+        stopReason: null,
+        runIds: [...active.runIds]
+      });
+    }
+  }
+  handleTurnTerminalDelta(delta, sdkMessage) {
+    const active = this.activeTurn;
+    if (!active)
+      return;
+    const messageType = streamDeltaMessageType2(delta);
+    if (messageType === "stop_reason") {
+      const stopReason = streamDeltaStopReason2(delta) ?? null;
+      if (stopReason === "requires_approval") {
+        active.observedRequiresApprovalStop = true;
+        return;
+      }
+      this.completeActiveTurn({
+        runtime: active.runtime,
+        stopReason,
+        runIds: [...active.runIds]
+      });
+      return;
+    }
+    if (sdkMessage?.type === "error") {
+      this.completeActiveTurn({
+        runtime: active.runtime,
+        stopReason: sdkMessage.stopReason,
+        runIds: [...active.runIds],
+        success: false,
+        detail: sdkMessage.errorDetail ?? sdkMessage.message,
+        errorCode: sdkMessage.errorCode
+      });
+    }
+  }
+  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);
+      if (!content)
+        return null;
+      if (this.activeTurn)
+        this.activeTurn.assistantText += content;
+      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,
+        ...otid !== undefined ? { otid } : {},
+        ...seqId !== undefined ? { seqId } : {},
+        runId
+      };
+    }
+    if (messageType === "tool_call_message" || messageType === "approval_request_message") {
+      const toolCall = firstToolCall(delta);
+      if (!toolCall)
+        return null;
+      const fn = toolCall.function && typeof toolCall.function === "object" ? toolCall.function : undefined;
+      const toolCallId = (typeof toolCall.tool_call_id === "string" ? toolCall.tool_call_id : undefined) ?? (typeof toolCall.id === "string" ? toolCall.id : undefined);
+      if (!toolCallId) {
+        const detail = `Missing tool_call_id in ${messageType} (uuid=${uuid})`;
+        return {
+          type: "error",
+          message: detail,
+          errorCode: "protocol_error",
+          stopReason: "protocol_error",
+          runId,
+          recoverable: false,
+          errorDetail: detail
+        };
+      }
+      const toolName = (typeof toolCall.name === "string" ? toolCall.name : undefined) ?? (typeof fn?.name === "string" ? fn.name : undefined) ?? "?";
+      const { input, raw } = toolInputFromArguments(toolCall.arguments ?? fn?.arguments);
+      return {
+        type: "tool_call",
+        toolCallId,
+        toolName,
+        toolInput: input,
+        rawArguments: raw,
+        uuid,
+        runId
+      };
+    }
+    if (messageType === "tool_return_message") {
+      const toolReturn = firstToolReturn(delta) ?? delta;
+      const toolCallId = (typeof delta.tool_call_id === "string" ? delta.tool_call_id : undefined) ?? (typeof toolReturn.tool_call_id === "string" ? toolReturn.tool_call_id : undefined);
+      if (!toolCallId)
+        return null;
+      const content = extractTextFromContent(delta.tool_return ?? toolReturn.tool_return ?? toolReturn.content) ?? "";
+      const status = typeof delta.status === "string" ? delta.status : toolReturn.status;
+      return {
+        type: "tool_result",
+        toolCallId,
+        content,
+        isError: status === "error",
+        uuid,
+        runId
+      };
+    }
+    if (messageType === "error_message" || messageType === "loop_error") {
+      const detail = (typeof delta.detail === "string" ? delta.detail : undefined) ?? (typeof delta.message === "string" ? delta.message : undefined) ?? `${this.label} turn failed`;
+      const stopReason = (typeof delta.stop_reason === "string" ? delta.stop_reason : undefined) ?? (typeof delta.error_type === "string" ? delta.error_type : undefined) ?? "error";
+      const approvalConflict = isApprovalConflictSignal({
+        detail,
+        message: typeof delta.message === "string" ? delta.message : undefined,
+        stopReason
+      });
+      return {
+        type: "error",
+        message: detail,
+        errorCode: approvalConflict ? "approval_conflict" : toSdkErrorCode(stopReason),
+        approvalConflict: approvalConflict || undefined,
+        recoverable: approvalConflict ? true : false,
+        errorDetail: detail,
+        stopReason,
+        runId
+      };
+    }
+    if (messageType === "retry") {
+      return {
+        type: "retry",
+        reason: typeof delta.reason === "string" ? delta.reason : "error",
+        attempt: typeof delta.attempt === "number" ? delta.attempt : 0,
+        maxAttempts: typeof delta.max_attempts === "number" ? delta.max_attempts : 0,
+        delayMs: typeof delta.delay_ms === "number" ? delta.delay_ms : 0,
+        runId
+      };
+    }
+    if (messageType === "stop_reason" || messageType === "ping") {
+      return null;
+    }
+    return {
+      type: "stream_event",
+      event: delta,
+      uuid
+    };
+  }
+  resultFromTurn(turn, tracker) {
+    const stopReason = turn.stopReason ?? (turn.success === false ? "error" : undefined);
+    const approvalConflict = isApprovalConflictSignal({
+      detail: turn.detail,
+      stopReason
+    });
+    const success = turn.success !== undefined ? turn.success && !approvalConflict && !FAILURE_STOP_REASONS.has(stopReason ?? "") : !approvalConflict && !FAILURE_STOP_REASONS.has(stopReason ?? "");
+    const errorCode = approvalConflict ? "approval_conflict" : turn.errorCode ?? toSdkErrorCode(stopReason);
+    return {
+      type: "result",
+      success,
+      result: success ? tracker?.assistantText || undefined : undefined,
+      error: success ? undefined : errorCode ?? stopReason ?? "error",
+      errorCode: success ? undefined : errorCode ?? "error",
+      approvalConflict: approvalConflict || undefined,
+      recoverable: approvalConflict ? true : success ? undefined : false,
+      errorDetail: success ? undefined : turn.detail,
+      stopReason,
+      durationMs: Date.now() - (tracker?.startedAt || this._activeTurnStartedAt),
+      conversationId: turn.runtime.conversation_id,
+      runIds: turn.runIds.length > 0 ? turn.runIds : undefined
+    };
+  }
+  enqueue(message) {
+    const resolver = this.streamResolvers.shift();
+    if (resolver) {
+      resolver(message);
+      return;
+    }
+    this.streamQueue.push(message);
+  }
+  resolveAll(value) {
+    for (const resolve of this.streamResolvers.splice(0)) {
+      resolve(value);
+    }
+  }
+}
+// src/remote-client-session-core.ts
+class RemoteClientSessionCore {
+  mode;
+  controller = null;
+  runtime = null;
+  initialized = false;
+  closed = false;
+  _agentId = null;
+  _sessionId = null;
+  _conversationId = null;
+  _model = "";
+  _modelSettings = null;
+  label;
+  requestTimeoutMs;
+  initializePromise = null;
+  removeMessageHandler = null;
+  turns;
+  toolNames;
+  deviceStatusListeners = new Set;
+  deviceStatusRefreshCancels = new Set;
+  constructor(mode, config) {
+    this.mode = mode;
+    this.label = config.label;
+    this.requestTimeoutMs = config.requestTimeoutMs;
+    this.turns = new RemoteTurnCoordinator({
+      label: config.label,
+      requestTimeoutMs: config.requestTimeoutMs,
+      onDeviceStatus: (status) => this.emitDeviceStatus(status)
+    });
+  }
+  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() {
+    const init = await this.initializeRuntimeController();
+    this.controller = init.controller;
+    this.runtime = init.runtime;
+    this._agentId = init.runtime.agent_id;
+    this._conversationId = init.runtime.conversation_id;
+    this._sessionId = `${init.runtime.agent_id}:${init.runtime.conversation_id}`;
+    this._modelSettings = init.modelSettings ?? null;
+    this._model = typeof init.model === "string" ? init.model : typeof this._modelSettings?.model === "string" ? this._modelSettings.model : "";
+    this.toolNames = init.tools;
+    this.removeMessageHandler = this.controller.onMessage((message) => {
+      if (this.runtime)
+        this.turns.handleProtocolMessage(message, this.runtime);
+    });
+    await this.afterRuntimeInitialized();
+    await this.applyPostInitializeOptions();
+    if (this.closed) {
+      throw new Error("Session is closed");
+    }
+    this.initialized = true;
+    const initMessage = {
+      type: "init",
+      agentId: init.runtime.agent_id,
+      sessionId: this._sessionId,
+      conversationId: init.runtime.conversation_id,
+      model: this._model
+    };
+    if (this.toolNames !== undefined)
+      initMessage.tools = this.toolNames;
+    if (init.skillSources !== undefined) {
+      initMessage.skillSources = init.skillSources;
+    }
+    return initMessage;
+  }
+  cleanupFailedInitialize() {
+    this.removeMessageHandler?.();
+    this.removeMessageHandler = null;
+    this.controller?.close();
+    this.controller = null;
+    this.onCoreClose();
+    this.runtime = null;
+    this._agentId = null;
+    this._conversationId = null;
+    this._sessionId = null;
+    this._modelSettings = null;
+    this._model = "";
+    this.toolNames = undefined;
+    this.initialized = false;
+  }
+  async send(message) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    if (!this.controller || !this.runtime) {
+      throw new Error("Session is not initialized");
+    }
+    await this.beforeTurn();
+    const turn = this.turns.trackSentTurn(this.runtime);
+    try {
+      this.controller.sendTurnMessage(this.runtime, message, {
+        clientMessageId: turn.clientMessageId
+      });
+    } catch (error) {
+      this.turns.removeTrackedTurn(turn);
+      throw error;
+    }
+  }
+  async runTurn(message, _options = {}) {
+    if (this.turns.hasInFlightTurn()) {
+      throw new Error(`A turn is already in flight for this ${this.label} session. Use send() and stream() to let the listener queue messages.`);
+    }
+    await this.send(message);
+    for await (const msg of this.stream()) {
+      if (msg.type === "result") {
+        return msg;
+      }
+    }
+    return {
+      type: "result",
+      success: false,
+      error: "stream_closed",
+      errorCode: "stream_closed",
+      recoverable: false,
+      errorDetail: "Stream ended before terminal result",
+      durationMs: Date.now() - this.turns.activeTurnStartedAt,
+      conversationId: this._conversationId
+    };
+  }
+  async* stream() {
+    while (true) {
+      const msg = await this.turns.nextMessage();
+      if (!msg)
+        break;
+      yield msg;
+      if (msg.type === "result")
+        break;
+    }
+  }
+  async abort() {
+    if (!this.initialized)
+      return;
+    if (!this.controller || !this.runtime)
+      return;
+    this.turns.markAbortRequested();
+    await this.controller.abort(this.runtime);
+  }
+  async sendCommand(command, options) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    if (!this.controller) {
       throw new Error("Session is not initialized");
     }
     if (!command || typeof command !== "object" || Array.isArray(command)) {
@@ -6481,14 +6774,7 @@ class RemoteClientSessionCore {
     this.closed = true;
     this.removeMessageHandler?.();
     this.removeMessageHandler = null;
-    if (this.activeTurn?.timeout)
-      clearTimeout(this.activeTurn.timeout);
-    for (const turn of this.pendingTurns) {
-      if (turn.timeout)
-        clearTimeout(turn.timeout);
-    }
-    this.activeTurn = null;
-    this.pendingTurns.length = 0;
+    this.turns.close();
     for (const cancel of [...this.deviceStatusRefreshCancels]) {
       cancel(new Error(`Session closed while waiting for ${this.label} device status`));
     }
@@ -6497,7 +6783,6 @@ class RemoteClientSessionCore {
     this.controller?.close();
     this.controller = null;
     this.onCoreClose();
-    this.resolveAll(null);
   }
   get agentId() {
     return this._agentId;
@@ -6558,95 +6843,12 @@ class RemoteClientSessionCore {
     return false;
   }
   enableMemfsBody() {
-    if (!this.runtime)
-      return {};
-    return { agent_id: this.runtime.agent_id };
-  }
-  setModel(model) {
-    this._model = model;
-  }
-  trackSentTurn(runtime) {
-    const turn = {
-      id: ++this.nextTurnId,
-      runtime,
-      clientMessageId: `sdk-message-${Date.now()}-${++this.clientMessageCounter}`,
-      queuedAt: Date.now(),
-      startedAt: 0,
-      assistantText: "",
-      runIds: new Set,
-      observedTurnEvidence: false,
-      observedRequiresApprovalStop: false,
-      abortRequested: false,
-      timeout: null
-    };
-    if (this.activeTurn) {
-      this.pendingTurns.push(turn);
-    } else {
-      this.activateTurn(turn);
-    }
-    return turn;
-  }
-  activateTurn(turn) {
-    this.activeTurn = turn;
-    turn.startedAt = Date.now();
-    this.activeTurnStartedAt = turn.startedAt;
-    if (this.requestTimeoutMs !== undefined) {
-      turn.timeout = setTimeout(() => {
-        this.failTurn(turn, `Timed out waiting for ${this.label} turn`);
-      }, this.requestTimeoutMs);
-      turn.timeout.unref?.();
-    }
-  }
-  activateNextTurnFromProtocol() {
-    if (this.activeTurn)
-      return this.activeTurn;
-    const next = this.pendingTurns.shift();
-    if (!next)
-      return null;
-    this.activateTurn(next);
-    return next;
-  }
-  removeTrackedTurn(turn) {
-    if (turn.timeout)
-      clearTimeout(turn.timeout);
-    if (this.activeTurn === turn) {
-      this.activeTurn = null;
-      return;
-    }
-    const index = this.pendingTurns.indexOf(turn);
-    if (index !== -1)
-      this.pendingTurns.splice(index, 1);
-  }
-  failTurn(turn, detail) {
-    if (this.activeTurn !== turn)
-      return;
-    this.enqueue({
-      type: "error",
-      message: detail,
-      errorCode: "error",
-      stopReason: "error",
-      errorDetail: detail,
-      recoverable: false
-    });
-    this.completeActiveTurn({
-      runtime: turn.runtime,
-      stopReason: "error",
-      runIds: [...turn.runIds],
-      success: false,
-      detail,
-      errorCode: "error"
-    });
-  }
-  completeActiveTurn(turn) {
-    const active = this.activeTurn;
-    if (!active)
-      return;
-    if (active.timeout) {
-      clearTimeout(active.timeout);
-      active.timeout = null;
-    }
-    this.enqueue(this.resultFromTurn(turn, active));
-    this.activeTurn = null;
+    if (!this.runtime)
+      return {};
+    return { agent_id: this.runtime.agent_id };
+  }
+  setModel(model) {
+    this._model = model;
   }
   async resolveUpdateModelPayload(input) {
     if (input.reasoningEffort === undefined) {
@@ -6711,287 +6913,28 @@ class RemoteClientSessionCore {
       ensureSuccess(response, "Failed to enable memfs");
     }
     const dreamingSettings = resolveDreamingSettings(options.dreaming);
-    if (dreamingSettings) {
-      const response = await this.controller.request("set_reflection_settings", {
-        runtime: this.runtime,
-        settings: dreamingSettings,
-        scope: "both"
-      }, { predicate: (message) => message.type === "set_reflection_settings_response" });
-      ensureSuccess(response, "Failed to update dreaming settings");
-    }
-    if (this.mode.kind !== "session")
-      return;
-    if (this.mode.options.model !== undefined || this.mode.options.reasoningEffort !== undefined) {
-      await this.applyModelUpdate({
-        ...this.mode.options.model !== undefined ? { model: this.mode.options.model } : {},
-        ...this.mode.options.reasoningEffort !== undefined ? { reasoningEffort: this.mode.options.reasoningEffort } : {}
-      });
-    }
-  }
-  handleProtocolMessage = (message) => {
-    if (!this.runtime || !sameRuntime2(message, this.runtime))
-      return;
-    const deviceStatus = deviceStatusRecord(message);
-    if (deviceStatus) {
-      const status = toSessionDeviceStatus(deviceStatus);
-      if (!status)
-        return;
-      for (const listener of [...this.deviceStatusListeners]) {
-        try {
-          listener(status);
-        } catch {}
-      }
-      return;
-    }
-    if (message.type === "update_queue") {
-      const sdkMessage2 = {
-        type: "queue_update",
-        queue: queueItems(message)
-      };
-      this.enqueue(sdkMessage2);
-      return;
-    }
-    if (message.type === "update_loop_status") {
-      this.handleLoopStatusMessage(message);
-      return;
-    }
-    const delta = streamDeltaRecord(message);
-    if (!delta)
-      return;
-    const active = this.activateNextTurnFromProtocol();
-    if (active) {
-      active.observedTurnEvidence = true;
-      const runId = streamDeltaRunId2(delta);
-      if (runId)
-        active.runIds.add(runId);
-    }
-    const sdkMessage = this.transformStreamDelta(delta);
-    if (sdkMessage) {
-      this.enqueue(sdkMessage);
-    }
-    this.handleTurnTerminalDelta(delta, sdkMessage);
-  };
-  handleLoopStatusMessage(message) {
-    const status = loopStatusValue(message);
-    if (!status)
-      return;
-    const activeRunIds = loopStatusRunIds(message);
-    const sdkMessage = {
-      type: "loop_status",
-      status,
-      activeRunIds
-    };
-    this.enqueue(sdkMessage);
-    const active = this.activeTurn;
-    if (!active)
-      return;
-    for (const runId of activeRunIds)
-      active.runIds.add(runId);
-    const hadTurnEvidence = active.observedTurnEvidence || active.observedRequiresApprovalStop;
-    if (!hadTurnEvidence)
-      return;
-    if (status === "WAITING_ON_APPROVAL") {
-      this.completeActiveTurn({
-        runtime: active.runtime,
-        stopReason: "requires_approval",
-        runIds: [...active.runIds]
-      });
-      return;
-    }
-    if (status === "WAITING_ON_INPUT" && active.abortRequested) {
-      this.completeActiveTurn({
-        runtime: active.runtime,
-        stopReason: "interrupted",
-        runIds: [...active.runIds],
-        success: false,
-        detail: "Interrupted",
-        errorCode: "interrupted"
-      });
-      return;
-    }
-    if (status === "WAITING_ON_INPUT" && active.observedTurnEvidence) {
-      this.completeActiveTurn({
-        runtime: active.runtime,
-        stopReason: null,
-        runIds: [...active.runIds]
-      });
-    }
-  }
-  handleTurnTerminalDelta(delta, sdkMessage) {
-    const active = this.activeTurn;
-    if (!active)
-      return;
-    const messageType = streamDeltaMessageType2(delta);
-    if (messageType === "stop_reason") {
-      const stopReason = streamDeltaStopReason2(delta) ?? null;
-      if (stopReason === "requires_approval") {
-        active.observedRequiresApprovalStop = true;
-        return;
-      }
-      this.completeActiveTurn({
-        runtime: active.runtime,
-        stopReason,
-        runIds: [...active.runIds]
-      });
-      return;
-    }
-    if (sdkMessage?.type === "error") {
-      this.completeActiveTurn({
-        runtime: active.runtime,
-        stopReason: sdkMessage.stopReason,
-        runIds: [...active.runIds],
-        success: false,
-        detail: sdkMessage.errorDetail ?? sdkMessage.message,
-        errorCode: sdkMessage.errorCode
-      });
-    }
-  }
-  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 uuid = typeof delta.id === "string" ? delta.id : `${this.label}-${++this.messageCounter}`;
-    if (messageType === "assistant_message") {
-      const content = extractTextFromContent(delta.content);
-      if (!content)
-        return null;
-      if (this.activeTurn)
-        this.activeTurn.assistantText += content;
-      return { type: "assistant", content, uuid, 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 };
-    }
-    if (messageType === "tool_call_message" || messageType === "approval_request_message") {
-      const toolCall = firstToolCall(delta);
-      if (!toolCall)
-        return null;
-      const fn = toolCall.function && typeof toolCall.function === "object" ? toolCall.function : undefined;
-      const toolCallId = (typeof toolCall.tool_call_id === "string" ? toolCall.tool_call_id : undefined) ?? (typeof toolCall.id === "string" ? toolCall.id : undefined);
-      if (!toolCallId) {
-        const detail = `Missing tool_call_id in ${messageType} (uuid=${uuid})`;
-        return {
-          type: "error",
-          message: detail,
-          errorCode: "protocol_error",
-          stopReason: "protocol_error",
-          runId,
-          recoverable: false,
-          errorDetail: detail
-        };
-      }
-      const toolName = (typeof toolCall.name === "string" ? toolCall.name : undefined) ?? (typeof fn?.name === "string" ? fn.name : undefined) ?? "?";
-      const { input, raw } = toolInputFromArguments(toolCall.arguments ?? fn?.arguments);
-      return {
-        type: "tool_call",
-        toolCallId,
-        toolName,
-        toolInput: input,
-        rawArguments: raw,
-        uuid,
-        runId
-      };
-    }
-    if (messageType === "tool_return_message") {
-      const toolReturn = firstToolReturn(delta) ?? delta;
-      const toolCallId = (typeof delta.tool_call_id === "string" ? delta.tool_call_id : undefined) ?? (typeof toolReturn.tool_call_id === "string" ? toolReturn.tool_call_id : undefined);
-      if (!toolCallId)
-        return null;
-      const content = extractTextFromContent(delta.tool_return ?? toolReturn.tool_return ?? toolReturn.content) ?? "";
-      const status = typeof delta.status === "string" ? delta.status : toolReturn.status;
-      return {
-        type: "tool_result",
-        toolCallId,
-        content,
-        isError: status === "error",
-        uuid,
-        runId
-      };
-    }
-    if (messageType === "error_message" || messageType === "loop_error") {
-      const detail = (typeof delta.detail === "string" ? delta.detail : undefined) ?? (typeof delta.message === "string" ? delta.message : undefined) ?? `${this.label} turn failed`;
-      const stopReason = (typeof delta.stop_reason === "string" ? delta.stop_reason : undefined) ?? (typeof delta.error_type === "string" ? delta.error_type : undefined) ?? "error";
-      const approvalConflict = isApprovalConflictSignal({
-        detail,
-        message: typeof delta.message === "string" ? delta.message : undefined,
-        stopReason
-      });
-      return {
-        type: "error",
-        message: detail,
-        errorCode: approvalConflict ? "approval_conflict" : toSdkErrorCode(stopReason),
-        approvalConflict: approvalConflict || undefined,
-        recoverable: approvalConflict ? true : false,
-        errorDetail: detail,
-        stopReason,
-        runId
-      };
-    }
-    if (messageType === "retry") {
-      return {
-        type: "retry",
-        reason: typeof delta.reason === "string" ? delta.reason : "error",
-        attempt: typeof delta.attempt === "number" ? delta.attempt : 0,
-        maxAttempts: typeof delta.max_attempts === "number" ? delta.max_attempts : 0,
-        delayMs: typeof delta.delay_ms === "number" ? delta.delay_ms : 0,
-        runId
-      };
-    }
-    if (messageType === "stop_reason" || messageType === "ping") {
-      return null;
-    }
-    return {
-      type: "stream_event",
-      event: delta,
-      uuid
-    };
-  }
-  resultFromTurn(turn, tracker) {
-    const stopReason = turn.stopReason ?? (turn.success === false ? "error" : undefined);
-    const approvalConflict = isApprovalConflictSignal({
-      detail: turn.detail,
-      stopReason
-    });
-    const success = turn.success !== undefined ? turn.success && !approvalConflict && !FAILURE_STOP_REASONS.has(stopReason ?? "") : !approvalConflict && !FAILURE_STOP_REASONS.has(stopReason ?? "");
-    const errorCode = approvalConflict ? "approval_conflict" : turn.errorCode ?? toSdkErrorCode(stopReason);
-    return {
-      type: "result",
-      success,
-      result: success ? tracker?.assistantText || undefined : undefined,
-      error: success ? undefined : errorCode ?? stopReason ?? "error",
-      errorCode: success ? undefined : errorCode ?? "error",
-      approvalConflict: approvalConflict || undefined,
-      recoverable: approvalConflict ? true : success ? undefined : false,
-      errorDetail: success ? undefined : turn.detail,
-      stopReason,
-      durationMs: Date.now() - (tracker?.startedAt || this.activeTurnStartedAt),
-      conversationId: turn.runtime.conversation_id,
-      runIds: turn.runIds.length > 0 ? turn.runIds : undefined
-    };
-  }
-  enqueue(message) {
-    const resolver = this.streamResolvers.shift();
-    if (resolver) {
-      resolver(message);
+    if (dreamingSettings) {
+      const response = await this.controller.request("set_reflection_settings", {
+        runtime: this.runtime,
+        settings: dreamingSettings,
+        scope: "both"
+      }, { predicate: (message) => message.type === "set_reflection_settings_response" });
+      ensureSuccess(response, "Failed to update dreaming settings");
+    }
+    if (this.mode.kind !== "session")
       return;
+    if (this.mode.options.model !== undefined || this.mode.options.reasoningEffort !== undefined) {
+      await this.applyModelUpdate({
+        ...this.mode.options.model !== undefined ? { model: this.mode.options.model } : {},
+        ...this.mode.options.reasoningEffort !== undefined ? { reasoningEffort: this.mode.options.reasoningEffort } : {}
+      });
     }
-    this.streamQueue.push(message);
-  }
-  nextMessage() {
-    const next = this.streamQueue.shift();
-    if (next)
-      return Promise.resolve(next);
-    if (this.closed)
-      return Promise.resolve(null);
-    return new Promise((resolve) => {
-      this.streamResolvers.push(resolve);
-    });
   }
-  resolveAll(value) {
-    for (const resolve of this.streamResolvers.splice(0)) {
-      resolve(value);
+  emitDeviceStatus(status) {
+    for (const listener of [...this.deviceStatusListeners]) {
+      try {
+        listener(status);
+      } catch {}
     }
   }
 }
@@ -7035,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") {
@@ -7485,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 } : {},
@@ -7797,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") {
@@ -7892,13 +8029,58 @@ class RemoteEnvironmentClient {
   }
 }
 
+// src/cloud-sandbox.ts
+var MIN_TTL_MINUTES = 1;
+var MAX_TTL_MINUTES = 60;
+var MAX_GITHUB_REPOSITORIES = 10;
+var GITHUB_OWNER_PATTERN = /^[A-Za-z0-9-]+$/;
+var GITHUB_REPOSITORY_PATTERN = /^[A-Za-z0-9._-]+$/;
+function validatePositiveInteger(value, name) {
+  if (value !== undefined && (!Number.isInteger(value) || value <= 0)) {
+    throw new Error(`Invalid ${name}. Expected a positive integer.`);
+  }
+}
+function validateCloudSandboxOptions(options, name) {
+  if (options === undefined)
+    return;
+  if (options === null || typeof options !== "object" || Array.isArray(options)) {
+    throw new Error(`Invalid ${name}. Expected an object.`);
+  }
+  if (options.ttlMinutes !== undefined && (!Number.isInteger(options.ttlMinutes) || options.ttlMinutes < MIN_TTL_MINUTES || options.ttlMinutes > MAX_TTL_MINUTES)) {
+    throw new Error(`Invalid ${name}.ttlMinutes. Expected an integer between ${MIN_TTL_MINUTES} and ${MAX_TTL_MINUTES}.`);
+  }
+  validatePositiveInteger(options.readyTimeoutMs, `${name}.readyTimeoutMs`);
+  validatePositiveInteger(options.readyPollIntervalMs, `${name}.readyPollIntervalMs`);
+  validatePositiveInteger(options.refreshIntervalMs, `${name}.refreshIntervalMs`);
+  if (options.githubRepositories !== undefined) {
+    if (!Array.isArray(options.githubRepositories)) {
+      throw new Error(`Invalid ${name}.githubRepositories. Expected an array.`);
+    }
+    if (options.githubRepositories.length > MAX_GITHUB_REPOSITORIES) {
+      throw new Error(`Invalid ${name}.githubRepositories. Expected at most ${MAX_GITHUB_REPOSITORIES} repositories.`);
+    }
+    for (const [index, repository] of options.githubRepositories.entries()) {
+      if (repository === null || typeof repository !== "object" || Array.isArray(repository)) {
+        throw new Error(`Invalid ${name}.githubRepositories[${index}]. Expected an object.`);
+      }
+      if (typeof repository.owner !== "string" || !GITHUB_OWNER_PATTERN.test(repository.owner)) {
+        throw new Error(`Invalid ${name}.githubRepositories[${index}].owner.`);
+      }
+      if (typeof repository.repo !== "string" || !GITHUB_REPOSITORY_PATTERN.test(repository.repo)) {
+        throw new Error(`Invalid ${name}.githubRepositories[${index}].repo.`);
+      }
+    }
+  }
+  if (options.terminateOnClose !== undefined && typeof options.terminateOnClose !== "boolean") {
+    throw new Error(`Invalid ${name}.terminateOnClose. Expected a boolean.`);
+  }
+}
+
 // src/cloud-session.ts
 var DEFAULT_CLOUD_API_BASE_URL3 = "https://api.letta.com";
 var DEFAULT_TURN_TIMEOUT_MS = 120000;
 var DEFAULT_PING_INTERVAL_MS = 30000;
 var DEFAULT_SANDBOX_TTL_MINUTES = 5;
-var MIN_SANDBOX_TTL_MINUTES = 1;
-var MAX_SANDBOX_TTL_MINUTES = 60;
 var DEFAULT_SANDBOX_READY_TIMEOUT_MS = 120000;
 var DEFAULT_SANDBOX_READY_POLL_INTERVAL_MS = 1000;
 var DEFAULT_REPOSITORY_ATTACH_TIMEOUT_MS = 1e4;
@@ -8009,34 +8191,13 @@ function assertOkResponse2(response, body, action, url) {
     throw new Error(parts.join(" — "));
   }
 }
-function validatePositiveInteger(value, name) {
+function validatePositiveInteger2(value, name) {
   if (value !== undefined && (!Number.isInteger(value) || value <= 0)) {
     throw new Error(`Invalid ${name}. Expected a positive integer.`);
   }
 }
-function validateIntegerRange(value, name, min, max) {
-  if (value === undefined)
-    return;
-  if (!Number.isInteger(value) || value < min || value > max) {
-    throw new Error(`Invalid ${name}. Expected an integer between ${min} and ${max}.`);
-  }
-}
-function validateCloudSandboxOptions(options, name) {
-  if (options === undefined)
-    return;
-  if (options === null || typeof options !== "object" || Array.isArray(options)) {
-    throw new Error(`Invalid ${name}. Expected an object.`);
-  }
-  validateIntegerRange(options.ttlMinutes, `${name}.ttlMinutes`, MIN_SANDBOX_TTL_MINUTES, MAX_SANDBOX_TTL_MINUTES);
-  validatePositiveInteger(options.readyTimeoutMs, `${name}.readyTimeoutMs`);
-  validatePositiveInteger(options.readyPollIntervalMs, `${name}.readyPollIntervalMs`);
-  validatePositiveInteger(options.refreshIntervalMs, `${name}.refreshIntervalMs`);
-  if (options.terminateOnClose !== undefined && typeof options.terminateOnClose !== "boolean") {
-    throw new Error(`Invalid ${name}.terminateOnClose. Expected a boolean.`);
-  }
-}
 function validateCloudClientOptions(options) {
-  validatePositiveInteger(options.requestTimeoutMs, "requestTimeoutMs");
+  validatePositiveInteger2(options.requestTimeoutMs, "requestTimeoutMs");
   validateCloudSandboxOptions(options.sandbox, "sandbox");
   if (options.environment !== undefined && options.sandbox !== undefined) {
     throw new Error("Letta Cloud sessions cannot specify both environment and sandbox options.");
@@ -8081,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");
 }
@@ -8309,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 {
@@ -8366,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
@@ -8639,10 +8600,15 @@ class CloudEnvironmentSession extends RemoteClientSessionCore {
   async createManagedSandbox(agentId, conversationId) {
     const fetchImpl = getFetch3(this.cloudOptions.fetch);
     const baseUrl = normalizeCloudApiBaseUrl2(this.cloudOptions.apiBaseUrl);
+    const sandboxOptions = this.resolvedSandboxOptions();
+    const githubRepositories = sandboxOptions.githubRepositories;
     const response = await fetchImpl(`${baseUrl}/v1/agents/${encodeURIComponent(agentId)}/sandboxes`, {
       method: "POST",
       headers: cloudHeaders2(this.cloudOptions),
-      body: JSON.stringify(conversationId ? { conversationId } : {})
+      body: JSON.stringify({
+        ...conversationId ? { conversationId } : {},
+        ...githubRepositories && githubRepositories.length > 0 ? { githubRepositories } : {}
+      })
     });
     const body = await parseJsonResponse3(response);
     assertOkResponse2(response, body, "Cloud create managed sandbox", `${baseUrl}/v1/agents/${encodeURIComponent(agentId)}/sandboxes`);
@@ -8653,7 +8619,6 @@ class CloudEnvironmentSession extends RemoteClientSessionCore {
     if (responseConversationId !== null && responseConversationId !== conversationId) {
       throw new Error(`Cloud managed sandbox response conversation mismatch: expected ${conversationId ?? "none"}, got ${responseConversationId}.`);
     }
-    const sandboxOptions = this.resolvedSandboxOptions();
     const ttlMinutes = sandboxOptions.ttlMinutes ?? DEFAULT_SANDBOX_TTL_MINUTES;
     const readyTimeoutMs = sandboxOptions.readyTimeoutMs ?? DEFAULT_SANDBOX_READY_TIMEOUT_MS;
     const readyPollIntervalMs = sandboxOptions.readyPollIntervalMs ?? DEFAULT_SANDBOX_READY_POLL_INTERVAL_MS;
@@ -8951,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.");
   }
 }
@@ -9001,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);
@@ -9059,6 +9037,7 @@ function stripCloudExecutionOptions(options) {
   const sessionOptions = { ...options };
   delete sessionOptions.environment;
   delete sessionOptions.sandbox;
+  delete sessionOptions.filesystemConfinement;
   return sessionOptions;
 }
 function hasRepositoryResources(options) {
@@ -9102,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.");
@@ -9125,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);
@@ -9155,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(), {
@@ -9219,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 {
@@ -9230,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) {
@@ -9241,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.`);
       }
@@ -9256,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.`);
@@ -9272,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() {
@@ -9297,10 +9272,7 @@ class LettaAgentClientBase {
     return this.options;
   }
   appServerSessionOptions() {
-    return {
-      ...this.remoteOptions(),
-      beforeConnect: () => this.releaseIdleManagementConnection()
-    };
+    return this.remoteOptions();
   }
   getRepositoriesClient() {
     if (this.backend !== "cloud") {
@@ -9309,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;
@@ -9419,4 +9388,4 @@ export {
   CloudManagedSandboxExpiredError
 };
 
-//# debugId=EACEDA2AA17A075B64756E2164756E21
+//# debugId=AAFE1DD6848E90C364756E2164756E21