@letta-ai/letta-agent-sdk 0.6.2 → 0.7.0

package/dist/client-entry.js

@@ -3073,7 +3073,7 @@ function isAppServerInfoResponseMessage(message) {
     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";
+  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" && (capabilityRecord.runtime_external_tools_update === undefined || typeof capabilityRecord.runtime_external_tools_update === "boolean") && typeof capabilityRecord.split_channels === "boolean";
 }
 var DEFAULT_REQUEST_TIMEOUT_MS = 30000;
 var WEBSOCKET_OPEN_STATE = 1;
@@ -3316,6 +3316,16 @@ class AppServerClient {
       predicate: (message) => message.type === "runtime_start_response"
     });
   }
+  runtimeExternalToolsUpdate(command, options = {}) {
+    return this.request({
+      type: "runtime_external_tools_update",
+      request_id: command.request_id ?? this.nextRequestId("runtime-external-tools"),
+      ...command
+    }, {
+      ...options,
+      predicate: (message) => message.type === "runtime_external_tools_update_response"
+    });
+  }
   sync(command, options = {}) {
     return this.request({
       type: "sync",
@@ -3836,12 +3846,7 @@ You **MUST** be proactive in creating crons when work extends beyond the current
 
 **Cost**: Self-invocation is critical, but expensive. Default to the longest interval that still serves the user. Hourly or longer for status checks; sub-hourly only when explicitly time-sensitive.
 
-Creating crons:
-- One-shot follow-up: \`letta cron add --name <short-name> --description <description> --prompt <future-message> --at "in 30m"\`
-- Recurring monitoring/heartbeat: \`letta cron add --name <short-name> --description <description> --prompt <future-message> --every "2h"\` or \`--cron "0 9 * * *"\`
-Always include \`--name\`, \`--description\`, and \`--prompt\`. \`$AGENT_ID\` is automatically injected into the shell environment, and \`letta cron\` uses it by default, so you do not need to specify which agent to invoke unless overriding the current agent intentionally.
-
-Where crons run: for cloud agents, schedules default to durable Cloud schedules that fire from the cloud and execute in your cloud sandbox — they survive local shutdown, so this is the right default. If the scheduled work must run on a specific computer (e.g. it needs that computer's filesystem or local services), add \`--computer <deviceId>\` (from \`letta environments list\`) to keep the durable Cloud schedule but execute on that computer, with sandbox fallback if it is offline. Use \`--runner local\` only when that fallback is unacceptable; local schedules only fire while a Letta session is running on that computer.
+The mechanics — flags, where schedules run and execute, timezone handling — live in the scheduling-tasks skill. Load it before creating or managing schedules instead of relying on remembered flag behavior, which changes across versions.
 
 # Harness Architecture
 
@@ -4018,12 +4023,7 @@ You **MUST** be proactive in creating crons when work extends beyond the current
 
 **Cost**: Self-invocation is critical, but expensive. Default to the longest interval that still serves the user. Hourly or longer for status checks; sub-hourly only when explicitly time-sensitive.
 
-Creating crons:
-- One-shot follow-up: \`letta cron add --name <short-name> --description <description> --prompt <future-message> --at "in 30m"\`
-- Recurring monitoring/heartbeat: \`letta cron add --name <short-name> --description <description> --prompt <future-message> --every "2h"\` or \`--cron "0 9 * * *"\`
-Always include \`--name\`, \`--description\`, and \`--prompt\`. \`$AGENT_ID\` is automatically injected into the shell environment, and \`letta cron\` uses it by default, so you do not need to specify which agent to invoke unless overriding the current agent intentionally.
-
-Where crons run: for cloud agents, schedules default to durable Cloud schedules that fire from the cloud and execute in your cloud sandbox — they survive local shutdown, so this is the right default. If the scheduled work must run on a specific computer (e.g. it needs that computer's filesystem or local services), add \`--computer <deviceId>\` (from \`letta environments list\`) to keep the durable Cloud schedule but execute on that computer, with sandbox fallback if it is offline. Use \`--runner local\` only when that fallback is unacceptable; local schedules only fire while a Letta session is running on that computer.
+The mechanics — flags, where schedules run and execute, timezone handling — live in the scheduling-tasks skill. Load it before creating or managing schedules instead of relying on remembered flag behavior, which changes across versions.
 
 # Harness Architecture
 
@@ -9050,6 +9050,20 @@ function toSessionDeviceStatus(status) {
 function normalizeSendMessage(message) {
   return message;
 }
+function normalizeCallerOtid(otid) {
+  if (otid === undefined)
+    return;
+  if (typeof otid !== "string" || otid.trim() === "") {
+    throw new Error("send() otid must be a non-empty string");
+  }
+  return otid;
+}
+function turnSendOptions(turn) {
+  return {
+    clientMessageId: turn.clientMessageId,
+    ...turn.otid !== undefined ? { otid: turn.otid } : {}
+  };
+}
 
 // src/remote-turn-coordinator.ts
 class RemoteTurnCoordinator {
@@ -9078,11 +9092,13 @@ class RemoteTurnCoordinator {
   hasInFlightTurn() {
     return this.activeTurn !== null || this.pendingTurns.length > 0;
   }
-  trackSentTurn(runtime) {
+  trackSentTurn(runtime, callerOtid) {
+    const otid = normalizeCallerOtid(callerOtid);
     const turn = {
       id: ++this.nextTurnId,
       runtime,
-      clientMessageId: `sdk-message-${Date.now()}-${++this.clientMessageCounter}`,
+      ...otid !== undefined ? { otid } : {},
+      clientMessageId: otid ?? `sdk-message-${Date.now()}-${++this.clientMessageCounter}`,
       queuedAt: Date.now(),
       startedAt: 0,
       assistantText: "",
@@ -9493,6 +9509,9 @@ class RemoteClientSessionCore {
   initializePromise = null;
   removeMessageHandler = null;
   detachTransportDisconnect = null;
+  idleTransportDisconnected = false;
+  transportRecoveryPromise = null;
+  transportDisconnectGeneration = 0;
   turns;
   toolNames;
   deviceStatusListeners = new Set;
@@ -9581,19 +9600,25 @@ class RemoteClientSessionCore {
     this.toolNames = undefined;
     this.initialized = false;
   }
-  async send(message) {
+  async send(message, options) {
+    if (this.closed)
+      throw new Error("Session is closed");
     if (!this.initialized) {
       await this.initialize();
     }
+    await this.recoverIdleTransportIfNeeded();
     if (!this.controller || !this.runtime) {
       throw new Error("Session is not initialized");
     }
     await this.beforeTurn();
-    const turn = this.turns.trackSentTurn(this.runtime);
+    const controller = this.controller;
+    const runtime = this.runtime;
+    if (!controller || !runtime) {
+      throw new Error("Session transport disconnected before the turn was sent");
+    }
+    const turn = this.turns.trackSentTurn(runtime, options?.otid);
     try {
-      this.controller.sendTurnMessage(this.runtime, message, {
-        clientMessageId: turn.clientMessageId
-      });
+      controller.sendTurnMessage(runtime, message, turnSendOptions(turn));
     } catch (error) {
       this.turns.removeTrackedTurn(turn);
       throw error;
@@ -9672,6 +9697,9 @@ class RemoteClientSessionCore {
     return this.controller.listModels();
   }
   async updateModel(update) {
+    if (this.mode.kind === "session" && this.mode.options.stateless === true) {
+      throw new Error("updateModel() is unavailable in a stateless session because it changes persisted agent configuration.");
+    }
     if (!this.initialized) {
       await this.initialize();
     }
@@ -9866,6 +9894,7 @@ class RemoteClientSessionCore {
     this.deviceStatusListeners.clear();
     this.controller?.close();
     this.controller = null;
+    this.idleTransportDisconnected = false;
     this.onCoreClose();
   }
   get agentId() {
@@ -9918,15 +9947,78 @@ class RemoteClientSessionCore {
     }, { predicate: (message) => message.type === "update_toolset_response" });
     ensureSuccess(response, "Failed to update toolset");
   }
-  watchTransportDisconnect(client) {
+  watchTransportDisconnect(client, options = {}) {
     this.detachTransportDisconnect?.();
     this.detachTransportDisconnect = client.onDisconnect(() => {
       if (this.closed)
         return;
+      this.transportDisconnectGeneration += 1;
+      if (options.recoverWhenIdle && !this.turns.hasInFlightTurn()) {
+        this.detachTransportDisconnect?.();
+        this.detachTransportDisconnect = null;
+        this.removeMessageHandler?.();
+        this.removeMessageHandler = null;
+        this.controller?.close();
+        this.controller = null;
+        const error = new Error(`${this.label} connection closed before send`);
+        for (const cancel of [...this.deviceStatusRefreshCancels])
+          cancel(error);
+        this.deviceStatusRefreshCancels.clear();
+        this.onIdleTransportDisconnect();
+        this.idleTransportDisconnected = true;
+        return;
+      }
       this.turns.closeWithError(`The ${this.label} connection closed unexpectedly; resume the conversation to continue.`);
       this.close();
     });
   }
+  async recoverIdleTransportIfNeeded() {
+    if (!this.idleTransportDisconnected)
+      return;
+    if (this.transportRecoveryPromise) {
+      await this.transportRecoveryPromise;
+      return;
+    }
+    const runtime = this.runtime;
+    if (!runtime)
+      throw new Error("Session transport disconnected without a runtime");
+    const generation = this.transportDisconnectGeneration;
+    const recovery = this.recoverIdleTransport(runtime).then(async (init) => {
+      if (this.closed || generation !== this.transportDisconnectGeneration) {
+        init.controller.close();
+        this.onRecoveredTransportDiscarded();
+        throw new Error(`${this.label} connection closed during recovery`);
+      }
+      if (init.runtime.agent_id !== runtime.agent_id || init.runtime.conversation_id !== runtime.conversation_id) {
+        init.controller.close();
+        this.onRecoveredTransportDiscarded();
+        throw new Error(`${this.label} transport recovered a different runtime`);
+      }
+      this.controller = init.controller;
+      this.runtime = init.runtime;
+      this._modelSettings = init.modelSettings ?? this._modelSettings;
+      if (typeof init.model === "string" && init.model)
+        this._model = init.model;
+      if (init.tools !== undefined)
+        this.toolNames = init.tools;
+      this.removeMessageHandler = this.controller.onMessage((message) => {
+        if (this.runtime)
+          this.turns.handleProtocolMessage(message, this.runtime);
+      });
+      this.idleTransportDisconnected = false;
+      await this.afterRuntimeInitialized();
+    }).finally(() => {
+      if (this.transportRecoveryPromise === recovery)
+        this.transportRecoveryPromise = null;
+    });
+    this.transportRecoveryPromise = recovery;
+    await recovery;
+  }
+  async recoverIdleTransport(_runtime) {
+    throw new Error(`${this.label} sessions do not support idle transport recovery`);
+  }
+  onIdleTransportDisconnect() {}
+  onRecoveredTransportDiscarded() {}
   async afterRuntimeInitialized() {}
   async beforeTurn() {}
   onCoreClose() {}
@@ -10008,7 +10100,8 @@ class RemoteClientSessionCore {
       ensureSuccess(response, "Failed to enable memfs");
     }
     const dreamingSettings = resolveDreamingSettings(options.dreaming);
-    if (dreamingSettings) {
+    const isStatelessSession = this.mode.kind === "session" && this.mode.options.stateless === true;
+    if (dreamingSettings && !isStatelessSession) {
       const response = await this.controller.request("set_reflection_settings", {
         runtime: this.runtime,
         settings: dreamingSettings,
@@ -10274,7 +10367,8 @@ class AppServerRuntimeController {
         {
           role: "user",
           content: normalizeSendMessage(message),
-          client_message_id: options.clientMessageId
+          client_message_id: options.clientMessageId,
+          ...options.otid !== undefined ? { otid: options.otid } : {}
         }
       ]
     };
@@ -10501,6 +10595,9 @@ class AppServerSession extends RemoteClientSessionCore {
       command.mode = mode;
     if (options.cwd !== undefined)
       command.cwd = options.cwd;
+    if (this.mode.kind === "session" && this.mode.options.stateless === true) {
+      command.stateless = true;
+    }
     if (options.skillSources !== undefined) {
       command.skill_sources = [...new Set(options.skillSources)];
     }
@@ -10670,6 +10767,132 @@ class CloudManagementTransport {
   }
 }
 
+// src/remote.ts
+function ensureOnline(environment, target) {
+  if (!environment.connectionId) {
+    const label = "deviceId" in target ? target.deviceId : ("environmentId" in target) ? target.environmentId : ("connectionName" in target) ? target.connectionName : environment.deviceId;
+    throw new Error(`Computer is offline: ${label}`);
+  }
+  return {
+    connectionId: environment.connectionId,
+    environment,
+    target
+  };
+}
+
+class RemoteEnvironmentClient {
+  client;
+  constructor(options = {}, client = createCloudClient({
+    backend: "cloud",
+    apiBaseUrl: options.baseUrl,
+    apiKey: options.apiKey,
+    headers: options.headers,
+    fetch: options.fetch
+  })) {
+    this.client = client;
+  }
+  async listEnvironments(options = {}) {
+    return await this.client.environments.list({
+      after: options.after,
+      limit: options.limit === undefined ? undefined : String(options.limit),
+      onlineOnly: options.onlineOnly === undefined ? undefined : String(options.onlineOnly)
+    });
+  }
+  async getEnvironmentByDeviceId(deviceId) {
+    return await this.client.environments.retrieve(deviceId);
+  }
+  async resolveEnvironment(target) {
+    if ("connectionId" in target) {
+      return { connectionId: target.connectionId, target };
+    }
+    if ("deviceId" in target) {
+      return ensureOnline(await this.getEnvironmentByDeviceId(target.deviceId), target);
+    }
+    const connections = [];
+    let after;
+    do {
+      const page = await this.listEnvironments({ limit: 100, after });
+      connections.push(...page.connections);
+      if (!page.hasNextPage || page.connections.length === 0)
+        break;
+      after = page.connections.at(-1)?.id;
+    } while (after !== undefined);
+    if ("environmentId" in target) {
+      const match = connections.find((env) => env.id === target.environmentId);
+      if (!match) {
+        throw new Error(`Remote environment not found: ${target.environmentId}`);
+      }
+      return ensureOnline(match, target);
+    }
+    const matches = connections.filter((env) => env.connectionName === target.connectionName);
+    if (matches.length === 0) {
+      throw new Error(`Computer not found: ${target.connectionName}`);
+    }
+    const onlineMatches = matches.filter((environment) => environment.connectionId !== null);
+    if (onlineMatches.length === 0) {
+      throw new Error(`Computer is offline: ${target.connectionName}`);
+    }
+    if (onlineMatches.length > 1) {
+      const candidates = onlineMatches.map((environment) => `${environment.connectionName} (${environment.deviceId}, online)`).join(", ");
+      throw new Error(`Computer name is ambiguous: ${target.connectionName}. Matches: ${candidates}. Select one by deviceId.`);
+    }
+    return ensureOnline(onlineMatches[0], target);
+  }
+}
+
+// src/computers.ts
+function selectorToRemoteTarget(selector) {
+  if (typeof selector === "string")
+    return { connectionName: selector };
+  if ("name" in selector)
+    return { connectionName: selector.name };
+  if ("id" in selector)
+    return { environmentId: selector.id };
+  if ("connectionId" in selector) {
+    return { connectionId: selector.connectionId };
+  }
+  return { deviceId: selector.deviceId };
+}
+function toComputer(environment) {
+  return {
+    id: environment.id,
+    deviceId: environment.deviceId,
+    connectionId: environment.connectionId,
+    name: environment.connectionName,
+    status: environment.connectionId ? "online" : "offline",
+    connectedAt: environment.connectedAt,
+    lastSeenAt: environment.lastSeenAt,
+    metadata: environment.metadata
+  };
+}
+
+class ComputersClientImpl {
+  environments;
+  constructor(client) {
+    this.environments = new RemoteEnvironmentClient({}, client);
+  }
+  async list(options = {}) {
+    const result = await this.environments.listEnvironments(options);
+    return {
+      computers: result.connections.map(toComputer),
+      hasNextPage: result.hasNextPage
+    };
+  }
+  async get(deviceId) {
+    if (typeof deviceId !== "string" || deviceId.trim().length === 0) {
+      throw new Error("Invalid deviceId. Expected a non-empty string.");
+    }
+    return toComputer(await this.environments.getEnvironmentByDeviceId(deviceId));
+  }
+  async resolve(selector) {
+    const result = await this.environments.resolveEnvironment(selectorToRemoteTarget(selector));
+    return {
+      connectionId: result.connectionId,
+      computer: result.environment ? toComputer(result.environment) : undefined
+    };
+  }
+}
+
 // src/cloud-status-transport.ts
 var CONNECTING = 0;
 var OPEN = 1;
@@ -10886,66 +11109,6 @@ function createCloudStatusTransportConstructor(options) {
   };
 }
 
-// src/remote.ts
-function ensureOnline(environment, target) {
-  if (!environment.connectionId) {
-    const label = "deviceId" in target ? target.deviceId : ("environmentId" in target) ? target.environmentId : ("connectionName" in target) ? target.connectionName : environment.deviceId;
-    throw new Error(`Remote environment is offline: ${label}`);
-  }
-  return {
-    connectionId: environment.connectionId,
-    environment,
-    target
-  };
-}
-
-class RemoteEnvironmentClient {
-  client;
-  constructor(options = {}, client = createCloudClient({
-    backend: "cloud",
-    apiBaseUrl: options.baseUrl,
-    apiKey: options.apiKey,
-    headers: options.headers,
-    fetch: options.fetch
-  })) {
-    this.client = client;
-  }
-  async listEnvironments() {
-    return await this.client.environments.list();
-  }
-  async getEnvironmentByDeviceId(deviceId) {
-    return await this.client.environments.retrieve(deviceId);
-  }
-  async resolveEnvironment(target) {
-    if ("connectionId" in target) {
-      return { connectionId: target.connectionId, target };
-    }
-    if ("deviceId" in target) {
-      return ensureOnline(await this.getEnvironmentByDeviceId(target.deviceId), target);
-    }
-    const { connections } = await this.listEnvironments();
-    if ("environmentId" in target) {
-      const match2 = connections.find((env) => env.id === target.environmentId);
-      if (!match2) {
-        throw new Error(`Remote environment not found: ${target.environmentId}`);
-      }
-      return ensureOnline(match2, target);
-    }
-    const matches = connections.filter((env) => env.connectionName === target.connectionName);
-    if (matches.length === 0) {
-      throw new Error(`Remote environment not found: ${target.connectionName}`);
-    }
-    if (matches.length > 1) {
-      throw new Error(`Remote environment name is ambiguous: ${target.connectionName}`);
-    }
-    const match = matches[0];
-    if (!match) {
-      throw new Error(`Remote environment not found: ${target.connectionName}`);
-    }
-    return ensureOnline(match, target);
-  }
-}
-
 // src/cloud-sandbox.ts
 var MIN_TTL_MINUTES = 1;
 var MAX_TTL_MINUTES = 60;
@@ -11044,8 +11207,12 @@ function validatePositiveInteger3(value, name) {
 function validateCloudClientOptions(options) {
   validatePositiveInteger3(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.");
+  if (options.computer !== undefined && options.environment !== undefined) {
+    throw new Error("Letta Cloud clients cannot specify both computer and deprecated environment.");
+  }
+  if ((options.computer !== undefined || options.environment !== undefined) && options.sandbox !== undefined) {
+    const field = options.computer !== undefined ? "computer" : "environment";
+    throw new Error(`Letta Cloud sessions cannot specify both ${field} and sandbox options.`);
   }
   if (options.webSocketAuth !== undefined && options.webSocketAuth !== "header" && options.webSocketAuth !== "query") {
     throw new Error("Invalid webSocketAuth. Valid values: header, query.");
@@ -11162,12 +11329,30 @@ class CloudEnvironmentSession extends RemoteClientSessionCore {
       throw error;
     });
     this.connectionId = connection.connectionId;
+    const options = this.currentOptions();
+    this.mcpBridge = await connectMcpServers("mcpServers" in options ? options.mcpServers : undefined, {
+      cwd: options.cwd,
+      reservedToolNames: this.externalTools.keys()
+    });
+    for (const tool of this.mcpBridge.tools) {
+      this.externalTools.set(tool.name, tool);
+    }
+    try {
+      return await this.openCloudTransport(resolved.runtime, connection.connectionId);
+    } catch (error) {
+      await this.closeMcpBridge();
+      await this.cleanupManagedSandbox();
+      await this.cleanupSessionRepositories(resolved.runtime.agent_id, resolved.runtime.conversation_id);
+      throw error;
+    }
+  }
+  async openCloudTransport(runtime, connectionId) {
     const apiKey = getCloudApiKey(this.cloudOptions);
     const url = buildCloudStatusWebSocketUrl({
       apiBaseUrl: this.cloudOptions.apiBaseUrl,
-      connectionId: connection.connectionId,
-      agentId: resolved.runtime.agent_id,
-      conversationId: resolved.runtime.conversation_id,
+      connectionId,
+      agentId: runtime.agent_id,
+      conversationId: runtime.conversation_id,
       apiKey,
       authMode: this.cloudOptions.webSocketAuth ?? "header"
     });
@@ -11178,33 +11363,19 @@ class CloudEnvironmentSession extends RemoteClientSessionCore {
         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
+        runtime
       }),
       requestTimeoutMs: this.cloudOptions.requestTimeoutMs ?? DEFAULT_TURN_TIMEOUT_MS
     }));
     const options = this.currentOptions();
-    this.mcpBridge = await connectMcpServers("mcpServers" in options ? options.mcpServers : undefined, {
-      cwd: options.cwd,
-      reservedToolNames: this.externalTools.keys()
-    });
-    for (const tool of this.mcpBridge.tools) {
-      this.externalTools.set(tool.name, tool);
-    }
-    this.removeControlRequestHandler = registerAppServerControlRequestHandler({
-      client,
-      getRuntime: () => this.runtime,
-      getOptions: () => this.currentOptions()
-    });
-    if (this.externalTools.size > 0) {
-      this.removeExternalToolHandler = client.onExternalToolCall(createExternalToolCallHandler(this.externalTools));
-    }
+    this.installTransportHandlers(client);
     try {
       await client.connect();
-      const response = await this.startCloudRuntime(client, resolved.runtime);
+      const response = await this.startCloudRuntime(client, runtime);
       if (!response.success || !response.runtime) {
         throw new Error(response.error ?? "Failed to start Cloud status runtime");
       }
-      this.watchTransportDisconnect(client);
+      this.watchTransportDisconnect(client, { recoverWhenIdle: true });
       const tools = agentToolNames(response.agent);
       const skillSources = options.skillSources;
       const clientToolset = "toolset" in options ? options.toolset : undefined;
@@ -11222,17 +11393,51 @@ class CloudEnvironmentSession extends RemoteClientSessionCore {
         ...skillSources !== undefined ? { skillSources: [...skillSources] } : {}
       };
     } catch (error) {
-      this.removeExternalToolHandler?.();
-      this.removeExternalToolHandler = null;
-      this.removeControlRequestHandler?.();
-      this.removeControlRequestHandler = null;
-      await this.closeMcpBridge();
+      this.cleanupTransportHandlers();
       client.close();
-      await this.cleanupManagedSandbox();
-      await this.cleanupSessionRepositories(resolved.runtime.agent_id, resolved.runtime.conversation_id);
       throw error;
     }
   }
+  installTransportHandlers(client) {
+    this.cleanupTransportHandlers();
+    this.removeControlRequestHandler = registerAppServerControlRequestHandler({
+      client,
+      getRuntime: () => this.runtime,
+      getOptions: () => this.currentOptions()
+    });
+    if (this.externalTools.size > 0) {
+      this.removeExternalToolHandler = client.onExternalToolCall(createExternalToolCallHandler(this.externalTools));
+    }
+  }
+  cleanupTransportHandlers() {
+    this.removeExternalToolHandler?.();
+    this.removeExternalToolHandler = null;
+    this.removeControlRequestHandler?.();
+    this.removeControlRequestHandler = null;
+  }
+  async recoverIdleTransport(runtime) {
+    const connection = await this.resolveRecoveryConnection(runtime);
+    this.connectionId = connection.connectionId;
+    return this.openCloudTransport(runtime, connection.connectionId);
+  }
+  async resolveRecoveryConnection(runtime) {
+    const sandbox = this.managedSandbox;
+    if (sandbox) {
+      await this.refreshManagedSandbox(sandbox);
+      return this.waitForManagedSandboxConnection(sandbox);
+    }
+    const environment = this.effectiveEnvironment();
+    if (!environment) {
+      throw new Error("Cloud idle transport recovery lost its execution target");
+    }
+    return this.resolveExplicitConnection(environment);
+  }
+  onIdleTransportDisconnect() {
+    this.cleanupTransportHandlers();
+  }
+  onRecoveredTransportDiscarded() {
+    this.cleanupTransportHandlers();
+  }
   async startCloudRuntime(client, runtime) {
     const options = this.currentOptions();
     const command = {
@@ -11250,6 +11455,8 @@ class CloudEnvironmentSession extends RemoteClientSessionCore {
       command.mode = mode;
     if (options.cwd !== undefined)
       command.cwd = options.cwd;
+    if (this.cloudMode.options.stateless === true)
+      command.stateless = true;
     if (options.skillSources !== undefined) {
       command.skill_sources = [...new Set(options.skillSources)];
     }
@@ -11275,10 +11482,7 @@ class CloudEnvironmentSession extends RemoteClientSessionCore {
     await this.refreshManagedSandbox(sandbox);
   }
   onCoreClose() {
-    this.removeExternalToolHandler?.();
-    this.removeExternalToolHandler = null;
-    this.removeControlRequestHandler?.();
-    this.removeControlRequestHandler = null;
+    this.cleanupTransportHandlers();
     this.mcpCleanup = this.closeMcpBridge();
     this.cleanupManagedSandbox();
     if (this.runtime?.agent_id) {
@@ -11602,8 +11806,8 @@ class CloudEnvironmentSession extends RemoteClientSessionCore {
     return new RemoteEnvironmentClient({}, this.apiClient);
   }
   effectiveEnvironment() {
-    const modeEnvironment = this.mode.kind === "session" ? this.mode.options.environment : undefined;
-    return modeEnvironment ?? this.cloudOptions.environment;
+    const modeComputer = this.mode.kind === "session" ? this.mode.options.computer ?? this.mode.options.environment : undefined;
+    return modeComputer ?? this.cloudOptions.computer ?? this.cloudOptions.environment;
   }
   effectiveSandboxOptions() {
     const modeSandbox = this.mode.kind === "session" ? this.mode.options.sandbox : undefined;
@@ -11857,6 +12061,20 @@ function validateMcpServers(servers) {
   }
 }
 function validateCreateSessionOptions(options) {
+  if (options.stateless !== undefined && typeof options.stateless !== "boolean") {
+    throw new Error("Invalid stateless. Expected a boolean.");
+  }
+  if (options.stateless) {
+    const persistedOption = [
+      ["model", options.model],
+      ["reasoningEffort", options.reasoningEffort],
+      ["dreaming", options.dreaming],
+      ["resources", options.resources]
+    ].find(([, value]) => value !== undefined);
+    if (persistedOption) {
+      throw new Error(`stateless sessions cannot set ${persistedOption[0]} because it changes persisted agent configuration.`);
+    }
+  }
   validateClientToolset(options.toolset);
   validateSkillSources(options.skillSources);
   validateMcpServers(options.mcpServers);
@@ -11903,14 +12121,17 @@ var VALID_BACKENDS = new Set([
 function isLettaCodeBackend(value) {
   return VALID_BACKENDS.has(value);
 }
-function getOptionsEnvironment(options) {
-  if ("environment" in options) {
-    return options.environment;
+function getOptionsComputer(options) {
+  if (!("computer" in options) && !("environment" in options))
+    return;
+  if (options.computer !== undefined && options.environment !== undefined) {
+    throw new Error('Specify either "computer" or deprecated "environment", not both.');
   }
-  return;
+  return options.computer ?? options.environment;
 }
 function stripCloudExecutionOptions(options) {
   const sessionOptions = { ...options };
+  delete sessionOptions.computer;
   delete sessionOptions.environment;
   delete sessionOptions.sandbox;
   delete sessionOptions.filesystemConfinement;
@@ -11928,12 +12149,14 @@ function looksLikeConversationId(id) {
 
 class LettaAgentClientBase {
   backend;
+  computer;
   environment;
   agents;
   conversations;
   models;
   options;
   repositoriesClient = null;
+  computersClient = null;
   agentRepositoriesClient = null;
   cloudClient = null;
   managementTransport = null;
@@ -11943,16 +12166,19 @@ class LettaAgentClientBase {
       throw new Error(`Invalid Letta Code backend '${String(backend)}'. Valid values: local, remote, cloud.`);
     }
     this.backend = backend;
-    this.environment = getOptionsEnvironment(options);
+    this.computer = getOptionsComputer(options);
+    this.environment = this.computer;
     this.options = options;
     this.agents = createAgentsClient(() => this.getManagementTransport(), () => this.getAgentRepositoriesClient());
     this.conversations = createConversationsClient(() => this.getManagementTransport());
     this.models = createModelsClient(() => this.getManagementTransport());
-    if (this.backend === "local" && this.environment !== undefined) {
-      throw new Error('LettaAgentClient environment is only valid with backend: "cloud".');
+    if (this.backend === "local" && this.computer !== undefined) {
+      const field = "computer" in options && options.computer !== undefined ? "computer" : "environment";
+      throw new Error(`LettaAgentClient ${field} is only valid with backend: "cloud".`);
     }
-    if (this.backend === "remote" && this.environment !== undefined) {
-      throw new Error('LettaAgentClient environment is only valid with backend: "cloud"; remote url selects the app-server runtime.');
+    if (this.backend === "remote" && this.computer !== undefined) {
+      const field = "computer" in options && options.computer !== undefined ? "computer" : "environment";
+      throw new Error(`LettaAgentClient ${field} is only valid with backend: "cloud"; remote url selects the app-server runtime.`);
     }
     if (this.backend !== "cloud" && options.sandbox !== undefined) {
       throw new Error('LettaAgentClient sandbox options are only valid with backend: "cloud".');
@@ -11986,6 +12212,9 @@ class LettaAgentClientBase {
   get repositories() {
     return this.getRepositoriesClient();
   }
+  get computers() {
+    return this.getComputersClient();
+  }
   async createAgent(options = {}) {
     if (hasCreateAgentEnvironment(options)) {
       throw new Error("createAgent() does not accept environment. Set a client default or pass environment to resumeSession()/createSession().");
@@ -12075,13 +12304,17 @@ class LettaAgentClientBase {
     }
   }
   assertSessionBackend(action, options) {
+    if (options.computer !== undefined && options.environment !== undefined) {
+      throw new Error(`${action}() cannot specify both computer and deprecated environment.`);
+    }
     if (options.filesystemConfinement !== undefined && options.filesystemConfinement !== "memory") {
       throw new Error(`Invalid filesystemConfinement '${String(options.filesystemConfinement)}'. Valid value: memory.`);
     }
-    const effectiveEnvironment = options.environment ?? this.environment;
+    const effectiveComputer = options.computer ?? options.environment ?? this.computer;
     if (this.backend === "local") {
-      if (effectiveEnvironment !== undefined) {
-        throw new Error(`${action}() environment overrides are only valid with backend: "cloud".`);
+      if (effectiveComputer !== undefined) {
+        const field = options.computer !== undefined ? "computer" : "environment";
+        throw new Error(`${action}() ${field} overrides are only valid with backend: "cloud".`);
       }
       if (options.sandbox !== undefined) {
         throw new Error(`${action}() sandbox options are only valid with backend: "cloud".`);
@@ -12101,8 +12334,9 @@ class LettaAgentClientBase {
       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.`);
+      if (options.computer !== undefined || options.environment !== undefined) {
+        const field = options.computer !== undefined ? "computer" : "environment";
+        throw new Error(`${action}() ${field} overrides are only valid with backend: "cloud"; remote url selects the app-server runtime.`);
       }
       if (options.sandbox !== undefined) {
         throw new Error(`${action}() sandbox options are only valid with backend: "cloud"; remote url selects the app-server runtime.`);
@@ -12117,11 +12351,13 @@ class LettaAgentClientBase {
         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.`);
+      if (this.computer !== undefined && options.sandbox !== undefined) {
+        const field = cloudOptions.computer !== undefined ? "computer" : "environment";
+        throw new Error(`Letta Cloud ${action}() cannot specify sandbox options when the client has a default ${field}.`);
       }
-      if (cloudOptions.sandbox !== undefined && options.environment !== undefined) {
-        throw new Error(`Letta Cloud ${action}() cannot specify an environment when the client has default sandbox options.`);
+      if (cloudOptions.sandbox !== undefined && (options.computer !== undefined || options.environment !== undefined)) {
+        const field = options.computer !== undefined ? "a computer" : "an environment";
+        throw new Error(`Letta Cloud ${action}() cannot specify ${field} when the client has default sandbox options.`);
       }
       assertCloudSessionOptionsSupported(action, options);
       return;
@@ -12152,6 +12388,13 @@ class LettaAgentClientBase {
   appServerSessionOptions() {
     return this.remoteOptions();
   }
+  getComputersClient() {
+    if (this.backend !== "cloud") {
+      throw new Error('client.computers is only available with backend: "cloud".');
+    }
+    this.computersClient ??= new ComputersClientImpl(this.getCloudClient());
+    return this.computersClient;
+  }
   getRepositoriesClient() {
     if (this.backend !== "cloud") {
       throw new Error('client.repositories is only available with backend: "cloud".');
@@ -12260,6 +12503,440 @@ function extractStreamTextDelta(event) {
   }
   return null;
 }
+// src/transcript-accumulator.ts
+var SEP = ":";
+var MAX_TRACKED_RUNS = 64;
+var ANONYMOUS_RUN = "";
+function familyOtidAlias(kind, otid) {
+  return `${kind}${SEP}otid${SEP}${otid}`;
+}
+function familyUuidAlias(kind, uuid) {
+  return `${kind}${SEP}uuid${SEP}${uuid}`;
+}
+function toolRowKey(toolCallId) {
+  return `tool_call${SEP}id${SEP}${toolCallId}`;
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+function readString(record, field) {
+  const value = record[field];
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function readNumber(record, field) {
+  const value = record[field];
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function parseJsonObject(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.length === 0)
+    return;
+  try {
+    return asRecord(JSON.parse(trimmed));
+  } catch {
+    return;
+  }
+}
+function isRawArgumentsWrapper(input, rawArguments) {
+  if (!input)
+    return false;
+  const keys = Object.keys(input);
+  if (keys.length !== 1 || keys[0] !== "raw")
+    return false;
+  const wrapped = input.raw;
+  if (typeof wrapped !== "string")
+    return false;
+  return rawArguments === undefined || wrapped === rawArguments;
+}
+function toolStatus(row) {
+  if (row.result)
+    return "complete";
+  return row.argumentsComplete ? "ready" : "streaming";
+}
+function mergeToolArguments(previous, merge) {
+  let { rawArguments, toolInput, argumentsComplete } = previous;
+  const fragment = merge.rawArguments;
+  const wrapped = isRawArgumentsWrapper(merge.toolInput, fragment);
+  if (fragment !== undefined && fragment.length > 0) {
+    const whole = parseJsonObject(fragment);
+    if (whole) {
+      return { rawArguments: fragment, toolInput: whole, argumentsComplete: true };
+    }
+    if (argumentsComplete) {
+      return previous;
+    }
+    if (merge.mode === "whole") {
+      return { rawArguments: rawArguments ?? fragment, toolInput, argumentsComplete };
+    }
+    rawArguments = (rawArguments ?? "") + fragment;
+    const parsed = parseJsonObject(rawArguments);
+    if (parsed) {
+      return { rawArguments, toolInput: parsed, argumentsComplete: true };
+    }
+    return { rawArguments, toolInput, argumentsComplete: false };
+  }
+  if (!wrapped && merge.toolInput) {
+    const keys = Object.keys(merge.toolInput);
+    if (keys.length > 0) {
+      return { rawArguments, toolInput: merge.toolInput, argumentsComplete: true };
+    }
+    if (rawArguments === undefined) {
+      return { rawArguments, toolInput, argumentsComplete: true };
+    }
+  }
+  return previous;
+}
+
+class TranscriptAccumulatorImpl {
+  byKey = new Map;
+  aliasByOtid = new Map;
+  aliasByUuid = new Map;
+  seqThresholds = new Map;
+  snapshot = null;
+  anonymousCounter = 0;
+  apply(message) {
+    switch (message.type) {
+      case "assistant":
+      case "reasoning":
+        this.applyText({
+          kind: message.type,
+          text: message.content,
+          uuid: message.uuid,
+          otid: typeof message.otid === "string" ? message.otid : undefined,
+          runId: message.runId,
+          seqId: message.seqId
+        });
+        break;
+      case "tool_call":
+        this.mergeToolCall({
+          toolCallId: message.toolCallId,
+          toolName: message.toolName,
+          toolInput: message.toolInput,
+          rawArguments: message.rawArguments,
+          uuid: message.uuid,
+          runId: message.runId,
+          mode: "fragment"
+        });
+        break;
+      case "tool_result":
+        this.mergeToolResult({
+          toolCallId: message.toolCallId,
+          content: message.content,
+          isError: message.isError,
+          uuid: message.uuid,
+          runId: message.runId
+        });
+        break;
+      case "stream_event":
+        this.applyStreamEvent(message);
+        break;
+      default:
+        break;
+    }
+    return this.rows();
+  }
+  rebase(page, options) {
+    const messages = normalizeHistoryPage(page, options?.order);
+    if (messages.length === 0)
+      return this.rows();
+    const historyKeys = [];
+    const seen = new Set;
+    for (const message of messages) {
+      const key = this.applyHistoryMessage(message);
+      if (!key || seen.has(key))
+        continue;
+      seen.add(key);
+      historyKeys.push(key);
+    }
+    this.reorder(historyKeys);
+    return this.rows();
+  }
+  rows() {
+    if (!this.snapshot) {
+      this.snapshot = Array.from(this.byKey.values());
+    }
+    return this.snapshot;
+  }
+  reset() {
+    this.byKey.clear();
+    this.aliasByOtid.clear();
+    this.aliasByUuid.clear();
+    this.seqThresholds.clear();
+    this.anonymousCounter = 0;
+    this.snapshot = null;
+  }
+  isReplay(runId, seqId) {
+    if (seqId === undefined)
+      return false;
+    const bucket = runId ?? ANONYMOUS_RUN;
+    const threshold = this.seqThresholds.get(bucket);
+    if (threshold !== undefined && seqId <= threshold)
+      return true;
+    this.rememberSeq(bucket, seqId);
+    return false;
+  }
+  rememberSeq(bucket, seqId) {
+    const threshold = this.seqThresholds.get(bucket);
+    if (threshold !== undefined && threshold >= seqId)
+      return;
+    this.seqThresholds.set(bucket, seqId);
+    while (this.seqThresholds.size > MAX_TRACKED_RUNS) {
+      const oldest = this.seqThresholds.keys().next();
+      if (oldest.done)
+        break;
+      this.seqThresholds.delete(oldest.value);
+    }
+  }
+  applyText(slice) {
+    if (this.isReplay(slice.runId, slice.seqId))
+      return;
+    this.writeText(slice, "append");
+  }
+  writeText(slice, write) {
+    const key = this.resolveTextKey(slice.kind, slice.uuid, slice.otid);
+    const existing = this.byKey.get(key);
+    const previous = existing && existing.kind === slice.kind ? existing : undefined;
+    this.setRow(key, {
+      kind: slice.kind,
+      key,
+      text: write === "append" ? (previous?.text ?? "") + slice.text : slice.text,
+      uuid: previous?.uuid ?? slice.uuid,
+      otid: slice.otid ?? previous?.otid,
+      runId: slice.runId ?? previous?.runId,
+      seqId: maxDefined(slice.seqId, previous?.seqId)
+    });
+    return key;
+  }
+  resolveTextKey(kind, uuid, otid) {
+    const otidAlias = otid ? familyOtidAlias(kind, otid) : undefined;
+    const uuidAlias = uuid ? familyUuidAlias(kind, uuid) : undefined;
+    const fromOtid = otidAlias ? this.aliasByOtid.get(otidAlias) : undefined;
+    const fromUuid = uuidAlias ? this.aliasByUuid.get(uuidAlias) : undefined;
+    let key = fromOtid ?? fromUuid;
+    if (key && !fromOtid && otid) {
+      const existing = this.byKey.get(key);
+      if (existing && existing.otid !== undefined && existing.otid !== otid) {
+        key = undefined;
+      }
+    }
+    if (!key) {
+      key = otidAlias ?? uuidAlias ?? `${kind}${SEP}auto${SEP}${++this.anonymousCounter}`;
+    }
+    if (otidAlias)
+      this.aliasByOtid.set(otidAlias, key);
+    if (uuidAlias)
+      this.aliasByUuid.set(uuidAlias, key);
+    return key;
+  }
+  mergeToolCall(merge) {
+    const key = toolRowKey(merge.toolCallId);
+    const existing = this.byKey.get(key);
+    const previous = existing && existing.kind === "tool_call" ? existing : undefined;
+    const args = mergeToolArguments({
+      rawArguments: previous?.rawArguments,
+      toolInput: previous?.toolInput ?? {},
+      argumentsComplete: previous?.argumentsComplete ?? false
+    }, merge);
+    const toolName = merge.toolName && merge.toolName !== "?" ? merge.toolName : previous?.toolName ?? merge.toolName ?? "?";
+    const next = {
+      kind: "tool_call",
+      key,
+      toolCallId: merge.toolCallId,
+      toolName,
+      toolInput: args.toolInput,
+      ...args.rawArguments !== undefined ? { rawArguments: args.rawArguments } : {},
+      argumentsComplete: args.argumentsComplete,
+      ...previous?.result ? { result: previous.result } : {},
+      status: "streaming",
+      uuid: previous?.uuid ?? merge.uuid,
+      runId: merge.runId ?? previous?.runId,
+      seqId: maxDefined(merge.seqId, previous?.seqId)
+    };
+    next.status = toolStatus(next);
+    this.setRow(key, next);
+    return key;
+  }
+  mergeToolResult(merge) {
+    const key = toolRowKey(merge.toolCallId);
+    const existing = this.byKey.get(key);
+    const previous = existing && existing.kind === "tool_call" ? existing : undefined;
+    this.setRow(key, {
+      kind: "tool_call",
+      key,
+      toolCallId: merge.toolCallId,
+      toolName: previous?.toolName ?? "?",
+      toolInput: previous?.toolInput ?? {},
+      ...previous?.rawArguments !== undefined ? { rawArguments: previous.rawArguments } : {},
+      argumentsComplete: previous?.argumentsComplete ?? false,
+      result: {
+        content: merge.content,
+        isError: merge.isError,
+        ...merge.uuid ? { uuid: merge.uuid } : {}
+      },
+      status: "complete",
+      uuid: previous?.uuid,
+      runId: merge.runId ?? previous?.runId,
+      seqId: maxDefined(merge.seqId, previous?.seqId)
+    });
+    return key;
+  }
+  applyStreamEvent(message) {
+    const delta = extractStreamTextDelta(message.event);
+    if (!delta)
+      return;
+    const payload = asRecord(message.event);
+    const otid = payload ? readString(payload, "otid") : undefined;
+    const payloadId = payload ? readString(payload, "id") : undefined;
+    const identified = otid !== undefined || payloadId !== undefined;
+    this.applyText({
+      kind: delta.kind,
+      text: delta.text,
+      uuid: identified ? payloadId : `${delta.kind}${SEP}live`,
+      otid,
+      runId: payload ? readString(payload, "run_id") : undefined,
+      seqId: payload ? readNumber(payload, "seq_id") : undefined
+    });
+  }
+  applyHistoryMessage(message) {
+    const record = asRecord(message);
+    if (!record)
+      return;
+    const messageType = readString(record, "message_type");
+    if (!messageType)
+      return;
+    const uuid = readString(record, "id");
+    const otid = readString(record, "otid");
+    const runId = readString(record, "run_id");
+    const seqId = readNumber(record, "seq_id");
+    if (seqId !== undefined) {
+      this.rememberSeq(runId ?? ANONYMOUS_RUN, seqId);
+    }
+    switch (messageType) {
+      case "user_message":
+      case "assistant_message": {
+        const text = extractTextFromContent(record.content);
+        if (text === null)
+          return;
+        return this.writeText({
+          kind: messageType === "user_message" ? "user" : "assistant",
+          text,
+          uuid,
+          otid,
+          runId,
+          seqId
+        }, "replace");
+      }
+      case "reasoning_message": {
+        const text = typeof record.reasoning === "string" ? record.reasoning : extractTextFromContent(record.content);
+        if (text === null || text === undefined)
+          return;
+        return this.writeText({ kind: "reasoning", text, uuid, otid, runId, seqId }, "replace");
+      }
+      case "tool_call_message":
+      case "approval_request_message": {
+        const toolCall = firstToolCall(record);
+        if (!toolCall)
+          return;
+        const fn = asRecord(toolCall.function);
+        const toolCallId = (typeof toolCall.tool_call_id === "string" ? toolCall.tool_call_id : undefined) ?? (typeof toolCall.id === "string" ? toolCall.id : undefined);
+        if (!toolCallId)
+          return;
+        const args = toolCall.arguments ?? fn?.arguments;
+        return this.mergeToolCall({
+          toolCallId,
+          toolName: (typeof toolCall.name === "string" ? toolCall.name : undefined) ?? (typeof fn?.name === "string" ? fn.name : undefined),
+          toolInput: asRecord(args),
+          rawArguments: typeof args === "string" ? args : undefined,
+          uuid,
+          runId,
+          seqId,
+          mode: "whole"
+        });
+      }
+      case "tool_return_message": {
+        const toolReturn = firstToolReturn(record) ?? record;
+        const toolCallId = readString(record, "tool_call_id") ?? (typeof toolReturn.tool_call_id === "string" ? toolReturn.tool_call_id : undefined);
+        if (!toolCallId)
+          return;
+        const content = extractTextFromContent(record.tool_return ?? toolReturn.tool_return ?? toolReturn.content) ?? "";
+        const status = readString(record, "status") ?? (typeof toolReturn.status === "string" ? toolReturn.status : undefined);
+        return this.mergeToolResult({
+          toolCallId,
+          content,
+          isError: status === "error",
+          uuid,
+          runId,
+          seqId
+        });
+      }
+      default:
+        return;
+    }
+  }
+  setRow(key, row) {
+    this.byKey.set(key, row);
+    this.snapshot = null;
+  }
+  reorder(historyKeys) {
+    if (historyKeys.length === 0)
+      return;
+    const historySet = new Set(historyKeys);
+    const reordered = new Map;
+    for (const key of historyKeys) {
+      const row = this.byKey.get(key);
+      if (row)
+        reordered.set(key, row);
+    }
+    for (const [key, row] of this.byKey) {
+      if (historySet.has(key))
+        continue;
+      reordered.set(key, row);
+    }
+    this.byKey = reordered;
+    this.snapshot = null;
+  }
+}
+function maxDefined(next, previous) {
+  if (next === undefined)
+    return previous;
+  if (previous === undefined)
+    return next;
+  return Math.max(next, previous);
+}
+function normalizeHistoryPage(page, order) {
+  const messages = Array.isArray(page) ? page : page.messages ?? [];
+  if (messages.length < 2)
+    return messages;
+  const descending = order ? order === "desc" : detectDescending(messages);
+  return descending ? [...messages].reverse() : messages;
+}
+function detectDescending(messages) {
+  const seqIds = [];
+  const dates = [];
+  for (const message of messages) {
+    const record = asRecord(message);
+    if (!record)
+      continue;
+    const seqId = readNumber(record, "seq_id");
+    if (seqId !== undefined)
+      seqIds.push(seqId);
+    const date = readString(record, "date");
+    if (!date)
+      continue;
+    const parsed = Date.parse(date);
+    if (!Number.isNaN(parsed))
+      dates.push(parsed);
+  }
+  const ordered = seqIds.length >= 2 ? seqIds : dates;
+  if (ordered.length < 2)
+    return false;
+  const first = ordered[0];
+  const last = ordered[ordered.length - 1];
+  return last < first;
+}
+function createTranscriptAccumulator() {
+  return new TranscriptAccumulatorImpl;
+}
 // src/websocket.ts
 function createReactNativeWebSocketConstructor(WebSocket) {
   class ReactNativeWebSocketAdapter {
@@ -12281,10 +12958,11 @@ class LettaAgentClient extends LettaAgentClientBase {
 }
 export {
   extractStreamTextDelta,
+  createTranscriptAccumulator,
   createReactNativeWebSocketConstructor,
   RepositoriesClient,
   LettaAgentClient,
   CloudManagedSandboxExpiredError
 };
 
-//# debugId=B03015C0FF639CFA64756E2164756E21
+//# debugId=EF77573F8BD0F2C464756E2164756E21