@letta-ai/letta-agent-sdk 0.6.1 → 0.6.3

package/dist/index.js

@@ -3195,36 +3195,6 @@ function appServerSocketOptions(authToken) {
   }
   return { headers: { Authorization: `Bearer ${token}` } };
 }
-function sameRuntime(a, b) {
-  return a?.agent_id === b.agent_id && a?.conversation_id === b.conversation_id;
-}
-function isWaitingLoopStatus(message) {
-  return message.loop_status.status === "WAITING_ON_INPUT";
-}
-function isWaitingOnApprovalLoopStatus(message) {
-  return message.loop_status.status === "WAITING_ON_APPROVAL";
-}
-function streamDeltaRunId(message) {
-  const runId = message.delta.run_id;
-  return typeof runId === "string" ? runId : null;
-}
-function streamDeltaMessageType(message) {
-  const messageType = message.delta.message_type;
-  return typeof messageType === "string" ? messageType : null;
-}
-function streamDeltaStopReason(message) {
-  const stopReason = message.delta.stop_reason;
-  return typeof stopReason === "string" ? stopReason : null;
-}
-function streamDeltaErrorMessage(message) {
-  const delta = message.delta;
-  const apiMessage = delta.api_error?.message ?? delta.api_error?.detail;
-  if (typeof apiMessage === "string" && apiMessage.length > 0)
-    return apiMessage;
-  if (typeof delta.message === "string" && delta.message.length > 0)
-    return delta.message;
-  return "App-server turn failed";
-}
 
 class AppServerClient {
   socket;
@@ -3235,7 +3205,6 @@ class AppServerClient {
   messageHandlers = new Set;
   sendHandlers = new Set;
   disconnectHandlers = new Set;
-  activeTurnRuntimes = new Set;
   explicitlyClosed = false;
   disconnectNotified = false;
   nextRequestNumber = 0;
@@ -3418,111 +3387,15 @@ class AppServerClient {
   input(command) {
     this.send({ type: "input", ...command });
   }
-  runTurn(command, options = {}) {
-    const runtimeKey = `${command.runtime.agent_id}/${command.runtime.conversation_id}`;
-    if (this.activeTurnRuntimes.has(runtimeKey)) {
-      return Promise.reject(new Error(`A turn is already in flight for ${runtimeKey}`));
-    }
-    this.activeTurnRuntimes.add(runtimeKey);
-    const timeoutMs = options.timeoutMs ?? this.requestTimeoutMs;
-    const commandWithIds = this.withClientMessageIds(command);
-    const runIds = new Set;
-    let observedTurnEvidence = false;
-    let observedRequiresApprovalStop = false;
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        cleanup();
-        reject(new Error(`Timed out waiting for app-server turn on ${command.runtime.agent_id}/${command.runtime.conversation_id}`));
-      }, timeoutMs);
-      const cleanup = () => {
-        clearTimeout(timeout);
-        this.activeTurnRuntimes.delete(runtimeKey);
-        offMessage();
-      };
-      const finish = (completedBy, terminalMessage, stopReason) => {
-        cleanup();
-        resolve({
-          runtime: command.runtime,
-          stopReason,
-          runIds: [...runIds],
-          clientMessageIds: commandWithIds.clientMessageIds,
-          completedBy,
-          terminalMessage
-        });
-      };
-      const fail = (error) => {
-        cleanup();
-        reject(error);
-      };
-      const offMessage = this.onMessage((message) => {
-        if (!sameRuntime(message.runtime, command.runtime)) {
-          return;
-        }
-        if (message.type === "stream_delta") {
-          observedTurnEvidence = true;
-          const runId = streamDeltaRunId(message);
-          if (runId)
-            runIds.add(runId);
-          const messageType = streamDeltaMessageType(message);
-          if (messageType === "loop_error" || messageType === "error_message") {
-            fail(new Error(streamDeltaErrorMessage(message)));
-            return;
-          }
-          if (messageType === "stop_reason") {
-            const stopReason = streamDeltaStopReason(message);
-            if (stopReason === "requires_approval") {
-              observedRequiresApprovalStop = true;
-              return;
-            }
-            finish("stop_reason", message, stopReason);
-          }
-          return;
-        }
-        if (message.type === "update_loop_status") {
-          const hadTurnEvidenceBeforeLoopStatus = observedTurnEvidence || observedRequiresApprovalStop;
-          if (!hadTurnEvidenceBeforeLoopStatus && (isWaitingOnApprovalLoopStatus(message) || options.allowLoopStatusFallback === true && isWaitingLoopStatus(message))) {
-            return;
-          }
-          for (const runId of message.loop_status.active_run_ids) {
-            observedTurnEvidence = true;
-            runIds.add(runId);
-          }
-          if (hadTurnEvidenceBeforeLoopStatus && isWaitingOnApprovalLoopStatus(message)) {
-            finish("loop_status_waiting_on_approval", message, "requires_approval");
-            return;
-          }
-          if (options.allowLoopStatusFallback === true && hadTurnEvidenceBeforeLoopStatus && isWaitingLoopStatus(message)) {
-            finish("loop_status_waiting_fallback", message, null);
-          }
-        }
-      });
-      try {
-        this.input(commandWithIds.command);
-      } catch (error) {
-        fail(error instanceof Error ? error : new Error(String(error)));
-      }
-    });
-  }
-  withClientMessageIds(command) {
-    if (command.payload.kind !== "create_message") {
-      return { command, clientMessageIds: [] };
-    }
-    const clientMessageIds = [];
-    const messages = command.payload.messages.map((message) => {
-      if (message.role !== "user")
-        return message;
-      const existing = message.client_message_id;
-      const clientMessageId = typeof existing === "string" && existing.length > 0 ? existing : this.nextRequestId("client-message");
-      clientMessageIds.push(clientMessageId);
-      return { ...message, client_message_id: clientMessageId };
+  submitInput(command, options = {}) {
+    return this.request({
+      type: "input",
+      request_id: command.request_id ?? this.nextRequestId("input"),
+      ...command
+    }, {
+      ...options,
+      predicate: (message) => message.type === "input_accepted"
     });
-    return {
-      command: {
-        ...command,
-        payload: { ...command.payload, messages }
-      },
-      clientMessageIds
-    };
   }
   handleMessage(event, channel) {
     const message = parseProtocolMessage(event);
@@ -6456,6 +6329,73 @@ var models_default = {
         parallel_tool_calls: true
       }
     },
+    {
+      id: "opus-5",
+      handle: "anthropic/claude-opus-5",
+      label: "Opus 5",
+      description: "Opus 5 (high reasoning)",
+      updateArgs: {
+        context_window: 200000,
+        max_output_tokens: 128000,
+        enable_reasoner: true,
+        reasoning_effort: "high",
+        parallel_tool_calls: true
+      }
+    },
+    {
+      id: "opus-5-low",
+      handle: "anthropic/claude-opus-5",
+      label: "Opus 5",
+      description: "Opus 5 (low reasoning)",
+      updateArgs: {
+        context_window: 200000,
+        max_output_tokens: 128000,
+        enable_reasoner: true,
+        reasoning_effort: "low",
+        max_reasoning_tokens: 4000,
+        parallel_tool_calls: true
+      }
+    },
+    {
+      id: "opus-5-medium",
+      handle: "anthropic/claude-opus-5",
+      label: "Opus 5",
+      description: "Opus 5 (med reasoning)",
+      updateArgs: {
+        context_window: 200000,
+        max_output_tokens: 128000,
+        enable_reasoner: true,
+        reasoning_effort: "medium",
+        max_reasoning_tokens: 12000,
+        parallel_tool_calls: true
+      }
+    },
+    {
+      id: "opus-5-xhigh",
+      handle: "anthropic/claude-opus-5",
+      label: "Opus 5",
+      description: "Opus 5 (extra-high reasoning)",
+      updateArgs: {
+        context_window: 200000,
+        max_output_tokens: 128000,
+        enable_reasoner: true,
+        reasoning_effort: "xhigh",
+        parallel_tool_calls: true
+      }
+    },
+    {
+      id: "opus-5-max",
+      handle: "anthropic/claude-opus-5",
+      label: "Opus 5",
+      description: "Opus 5 (max reasoning)",
+      updateArgs: {
+        context_window: 200000,
+        max_output_tokens: 128000,
+        enable_reasoner: true,
+        reasoning_effort: "max",
+        parallel_tool_calls: true
+      }
+    },
     {
       id: "opus",
       handle: "anthropic/claude-opus-4-8",
@@ -6730,7 +6670,7 @@ var models_default = {
       id: "sonnet-5-xhigh",
       handle: "anthropic/claude-sonnet-5",
       label: "Sonnet 5",
-      description: "Sonnet 5 (max reasoning)",
+      description: "Sonnet 5 (extra-high reasoning)",
       updateArgs: {
         context_window: 1e6,
         max_output_tokens: 128000,
@@ -6739,6 +6679,19 @@ var models_default = {
         parallel_tool_calls: true
       }
     },
+    {
+      id: "sonnet-5-max",
+      handle: "anthropic/claude-sonnet-5",
+      label: "Sonnet 5",
+      description: "Sonnet 5 (max reasoning)",
+      updateArgs: {
+        context_window: 1e6,
+        max_output_tokens: 128000,
+        reasoning_effort: "max",
+        enable_reasoner: true,
+        parallel_tool_calls: true
+      }
+    },
     {
       id: "sonnet-4.6",
       handle: "anthropic/claude-sonnet-4-6",
@@ -8289,7 +8242,6 @@ var models_default = {
   ]
 };
 var models = models_default.models;
-var MODEL_PRESETS = models;
 function resolveModel(modelIdentifier) {
   const byId = models.find((m) => m.id === modelIdentifier);
   if (byId)
@@ -8517,75 +8469,128 @@ function buildPersonalityMemoryBlocks(personalityId, defaultMemoryBlocks, enviro
 }
 var LETTA_CODE_AGENT_TYPE = "letta_v1_agent";
 var DEFAULT_CREATED_AGENT_BASE_TOOLS = ["web_search", "fetch_webpage"];
-async function buildCreateAgentRequestForPersonality(params) {
-  const { personalityId, name, description, model, extraTags } = params;
-  const personality = getPersonalityOption(personalityId);
-  const modelIdentifier = model ?? personality.defaultModel;
+function mergeMemoryBlocks(base, overrides) {
+  const blocks = base.map((block) => ({ ...block }));
+  for (const override of overrides ?? []) {
+    const index = blocks.findIndex((block) => block.label === override.label);
+    if (index >= 0) {
+      blocks[index] = { ...override };
+    } else {
+      blocks.push({ ...override });
+    }
+  }
+  return blocks;
+}
+async function buildCreateAgentRequest(options = {}) {
+  const personality = options.personalityId ? getPersonalityOption(options.personalityId) : undefined;
+  const modelIdentifier = options.model ?? personality?.defaultModel;
   const modelHandle = modelIdentifier ? resolveModel(modelIdentifier) : getDefaultModel();
   if (!modelHandle) {
     throw new Error(`Unknown model: ${modelIdentifier}`);
   }
-  const defaultMemoryBlocks = await getDefaultMemoryBlocks();
+  if (!options.isSubagent && options.enableMemfs !== undefined && options.memoryPromptMode !== undefined && options.enableMemfs !== (options.memoryPromptMode !== "standard")) {
+    throw new Error("enableMemfs and memoryPromptMode must describe the same memory mode");
+  }
+  const enableMemfs = options.isSubagent ? false : options.enableMemfs ?? options.memoryPromptMode !== "standard";
+  const memoryPromptMode = options.isSubagent ? "standard" : options.memoryPromptMode ?? (enableMemfs ? "memfs" : "standard");
+  const personalityTags = options.personalityId ? getPersonalityCreationTags(options.personalityId) : [];
+  const personalityBlocks = options.personalityId ? buildPersonalityMemoryBlocks(options.personalityId, await getDefaultMemoryBlocks()) : [];
+  const memoryBlocks = options.isSubagent ? undefined : options.personalityId || options.memoryBlocks !== undefined ? mergeMemoryBlocks(personalityBlocks, options.memoryBlocks) : undefined;
+  const blockIds = options.isSubagent ? undefined : options.blockIds;
   return {
     agent_type: LETTA_CODE_AGENT_TYPE,
-    name: name ?? personality.label,
-    description: description ?? personality.description,
+    ...options.name !== undefined || personality ? { name: options.name ?? personality?.label } : {},
+    ...options.description !== undefined || personality ? { description: options.description ?? personality?.description } : {},
     model: modelHandle,
-    system: buildSystemPrompt("default", "memfs"),
-    memory_blocks: buildPersonalityMemoryBlocks(personalityId, defaultMemoryBlocks),
+    system: options.system ?? buildSystemPrompt("default", memoryPromptMode),
+    ...memoryBlocks !== undefined ? { memory_blocks: memoryBlocks } : {},
+    ...blockIds && blockIds.length > 0 ? { block_ids: blockIds } : {},
     tags: buildCreatedAgentTags({
-      enableMemfs: true,
-      tags: [
-        ...getPersonalityCreationTags(personalityId),
-        ...extraTags ?? []
-      ]
+      enableMemfs,
+      isSubagent: options.isSubagent,
+      tags: [...personalityTags, ...options.extraTags ?? []]
     }),
-    tools: [...DEFAULT_CREATED_AGENT_BASE_TOOLS],
+    tools: [...options.baseTools ?? DEFAULT_CREATED_AGENT_BASE_TOOLS],
     include_base_tools: false,
     include_base_tool_rules: false,
     initial_message_sequence: [],
-    parallel_tool_calls: true,
-    compaction_settings: { model: DEFAULT_SUMMARIZATION_MODEL }
+    parallel_tool_calls: options.parallelToolCalls ?? true,
+    compaction_settings: {
+      model: options.compactionModel ?? DEFAULT_SUMMARIZATION_MODEL
+    },
+    ...options.embedding !== undefined ? { embedding: options.embedding } : {},
+    ...options.isSubagent ? { hidden: true } : options.hidden !== undefined ? { hidden: options.hidden } : {}
   };
 }
 
 // src/agent-creation.ts
-var DEFAULT_MODEL_ID = "auto";
-var DEFAULT_SUMMARIZATION_MODEL2 = "letta/auto";
-function resolveModel2(modelIdentifier) {
-  const preset = MODEL_PRESETS.find((model) => model.id === modelIdentifier || model.handle === modelIdentifier);
-  if (preset)
-    return preset.handle;
-  if (modelIdentifier.includes("/"))
-    return modelIdentifier;
-  throw new Error(`Unknown model: ${modelIdentifier}`);
+function isPresetSystemPrompt(value) {
+  return [
+    "default",
+    "letta-claude",
+    "letta-codex",
+    "letta-gemini",
+    "claude",
+    "codex",
+    "gemini"
+  ].includes(value);
 }
-async function buildInitialAgentBody(options) {
-  if (options.personality !== undefined) {
-    return {
-      ...await buildCreateAgentRequestForPersonality({
-        personalityId: options.personality,
-        ...options.name !== undefined ? { name: options.name } : {},
-        ...options.description !== undefined ? { description: options.description } : {},
-        ...options.model !== undefined ? { model: options.model } : {},
-        ...options.tags !== undefined ? { extraTags: options.tags } : {}
-      })
-    };
+function assertCreateAgentOptionsSupported(options) {
+  if (options.allowedTools !== undefined || options.disallowedTools !== undefined) {
+    throw new Error("App-server createAgent() does not yet support allowedTools/disallowedTools.");
+  }
+  if (options.canUseTool !== undefined) {
+    throw new Error("App-server createAgent() does not yet support canUseTool callbacks.");
+  }
+  if (options.systemInfoReminder !== undefined) {
+    throw new Error("App-server createAgent() does not yet support systemInfoReminder overrides.");
+  }
+  if (options.dreaming?.behavior !== undefined) {
+    throw new Error("App-server createAgent() does not yet support dreaming.behavior overrides.");
   }
-  return {
-    agent_type: LETTA_CODE_AGENT_TYPE,
-    ...options.name !== undefined ? { name: options.name } : {},
-    ...options.description !== undefined ? { description: options.description } : {},
-    model: resolveModel2(options.model ?? DEFAULT_MODEL_ID),
-    system: buildSystemPrompt("default", "memfs"),
-    tags: buildCreatedAgentTags({
-      enableMemfs: true,
-      tags: options.tags ?? []
-    }),
-    initial_message_sequence: [],
-    parallel_tool_calls: true,
-    compaction_settings: { model: DEFAULT_SUMMARIZATION_MODEL2 }
-  };
+}
+async function createAgentBody(options) {
+  assertCreateAgentOptionsSupported(options);
+  let system;
+  if (options.systemPrompt !== undefined) {
+    if (typeof options.systemPrompt !== "string" || isPresetSystemPrompt(options.systemPrompt)) {
+      throw new Error("createAgent() does not yet support system prompt presets for this backend.");
+    }
+    system = options.systemPrompt;
+  }
+  const memoryBlocks = [];
+  const blockIds = [];
+  for (const item of options.memory ?? []) {
+    if (typeof item === "string") {
+      throw new Error("App-server createAgent() does not yet support memory preset names.");
+    }
+    if ("blockId" in item) {
+      blockIds.push(item.blockId);
+    } else {
+      memoryBlocks.push({ ...item });
+    }
+  }
+  if (options.persona !== undefined) {
+    memoryBlocks.push({ label: "persona", value: options.persona });
+  }
+  if (options.human !== undefined) {
+    memoryBlocks.push({ label: "human", value: options.human });
+  }
+  const hasMemoryConfiguration = options.memory !== undefined || options.persona !== undefined || options.human !== undefined;
+  return buildCreateAgentRequest({
+    personalityId: options.personality,
+    name: options.name,
+    description: options.description,
+    model: options.model,
+    system,
+    memoryBlocks: hasMemoryConfiguration ? memoryBlocks : undefined,
+    blockIds,
+    extraTags: options.tags,
+    enableMemfs: options.memfs ?? true,
+    baseTools: options.baseTools,
+    embedding: options.embedding,
+    hidden: options.hidden
+  });
 }
 
 // src/interactiveToolPolicy.ts
@@ -8877,7 +8882,7 @@ function firstToolReturn(delta) {
   }
   return;
 }
-function sameRuntime2(message, runtime) {
+function sameRuntime(message, runtime) {
   const msgRuntime = message.runtime;
   if (msgRuntime) {
     return msgRuntime.agent_id === runtime.agent_id && msgRuntime.conversation_id === runtime.conversation_id;
@@ -8896,10 +8901,10 @@ function streamDeltaRecord(message) {
   const delta = message.delta;
   return delta && typeof delta === "object" && !Array.isArray(delta) ? delta : null;
 }
-function streamDeltaMessageType2(delta) {
+function streamDeltaMessageType(delta) {
   return typeof delta.message_type === "string" ? delta.message_type : undefined;
 }
-function streamDeltaRunId2(delta) {
+function streamDeltaRunId(delta) {
   return typeof delta.run_id === "string" ? delta.run_id : undefined;
 }
 function streamDeltaOtid(delta) {
@@ -8908,7 +8913,7 @@ function streamDeltaOtid(delta) {
 function streamDeltaSeqId(delta) {
   return typeof delta.seq_id === "number" ? delta.seq_id : undefined;
 }
-function streamDeltaStopReason2(delta) {
+function streamDeltaStopReason(delta) {
   return typeof delta.stop_reason === "string" ? delta.stop_reason : undefined;
 }
 function loopStatusRecord(message) {
@@ -9131,7 +9136,7 @@ class RemoteTurnCoordinator {
       this.activeTurn.abortRequested = true;
   }
   handleProtocolMessage(message, runtime) {
-    if (!sameRuntime2(message, runtime))
+    if (!sameRuntime(message, runtime))
       return;
     const statusRecord = deviceStatusRecord(message);
     if (statusRecord) {
@@ -9158,7 +9163,7 @@ class RemoteTurnCoordinator {
     const active = this.activateNextTurnFromProtocol();
     if (active) {
       active.observedTurnEvidence = true;
-      const runId = streamDeltaRunId2(delta);
+      const runId = streamDeltaRunId(delta);
       if (runId)
         active.runIds.add(runId);
     }
@@ -9177,6 +9182,24 @@ class RemoteTurnCoordinator {
       this.streamResolvers.push(resolve);
     });
   }
+  closeWithError(detail) {
+    if (this.closed)
+      return;
+    const active = this.activeTurn;
+    if (active) {
+      this.failTurn(active, detail);
+    } else {
+      this.enqueue({
+        type: "error",
+        message: detail,
+        errorCode: "error",
+        stopReason: "error",
+        errorDetail: detail,
+        recoverable: false
+      });
+    }
+    this.close();
+  }
   close() {
     if (this.closed)
       return;
@@ -9294,9 +9317,9 @@ class RemoteTurnCoordinator {
     const active = this.activeTurn;
     if (!active)
       return;
-    const messageType = streamDeltaMessageType2(delta);
+    const messageType = streamDeltaMessageType(delta);
     if (messageType === "stop_reason") {
-      const stopReason = streamDeltaStopReason2(delta) ?? null;
+      const stopReason = streamDeltaStopReason(delta) ?? null;
       if (stopReason === "requires_approval") {
         active.observedRequiresApprovalStop = true;
         return;
@@ -9490,6 +9513,10 @@ class RemoteClientSessionCore {
   requestTimeoutMs;
   initializePromise = null;
   removeMessageHandler = null;
+  detachTransportDisconnect = null;
+  idleTransportDisconnected = false;
+  transportRecoveryPromise = null;
+  transportDisconnectGeneration = 0;
   turns;
   toolNames;
   deviceStatusListeners = new Set;
@@ -9564,6 +9591,8 @@ class RemoteClientSessionCore {
   cleanupFailedInitialize() {
     this.removeMessageHandler?.();
     this.removeMessageHandler = null;
+    this.detachTransportDisconnect?.();
+    this.detachTransportDisconnect = null;
     this.controller?.close();
     this.controller = null;
     this.onCoreClose();
@@ -9577,16 +9606,24 @@ class RemoteClientSessionCore {
     this.initialized = false;
   }
   async send(message) {
+    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);
     try {
-      this.controller.sendTurnMessage(this.runtime, message, {
+      controller.sendTurnMessage(runtime, message, {
         clientMessageId: turn.clientMessageId
       });
     } catch (error) {
@@ -9851,6 +9888,8 @@ class RemoteClientSessionCore {
     this.closed = true;
     this.removeMessageHandler?.();
     this.removeMessageHandler = null;
+    this.detachTransportDisconnect?.();
+    this.detachTransportDisconnect = null;
     this.turns.close();
     for (const cancel of [...this.deviceStatusRefreshCancels]) {
       cancel(new Error(`Session closed while waiting for ${this.label} device status`));
@@ -9859,6 +9898,7 @@ class RemoteClientSessionCore {
     this.deviceStatusListeners.clear();
     this.controller?.close();
     this.controller = null;
+    this.idleTransportDisconnected = false;
     this.onCoreClose();
   }
   get agentId() {
@@ -9911,6 +9951,78 @@ class RemoteClientSessionCore {
     }, { predicate: (message) => message.type === "update_toolset_response" });
     ensureSuccess(response, "Failed to update toolset");
   }
+  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() {}
@@ -10032,111 +10144,6 @@ function agentToolNames(agent) {
     return typeof name === "string" && name.length > 0 ? [name] : [];
   });
 }
-function isPresetSystemPrompt(value) {
-  return [
-    "default",
-    "letta-claude",
-    "letta-codex",
-    "letta-gemini",
-    "claude",
-    "codex",
-    "gemini"
-  ].includes(value);
-}
-function assertRemoteCreateAgentOptionsSupported(options) {
-  if (options.allowedTools !== undefined || options.disallowedTools !== undefined) {
-    throw new Error("App-server createAgent() does not yet support allowedTools/disallowedTools.");
-  }
-  if (options.canUseTool !== undefined) {
-    throw new Error("App-server createAgent() does not yet support canUseTool callbacks.");
-  }
-  if (options.systemInfoReminder !== undefined) {
-    throw new Error("App-server createAgent() does not yet support systemInfoReminder overrides.");
-  }
-  if (options.dreaming?.behavior !== undefined) {
-    throw new Error("App-server createAgent() does not yet support dreaming.behavior overrides.");
-  }
-}
-function normalizeMemoryBlock(block) {
-  const normalized = { ...block };
-  if (normalized.value === undefined && typeof normalized.content === "string") {
-    normalized.value = normalized.content;
-  }
-  return normalized;
-}
-function upsertMemoryBlock(blocks, block) {
-  const label = block.label;
-  if (typeof label === "string") {
-    const existingIndex = blocks.findIndex((candidate) => candidate.label === label);
-    if (existingIndex >= 0) {
-      blocks[existingIndex] = block;
-      return;
-    }
-  }
-  blocks.push(block);
-}
-async function createAgentBody(options, settings = {}) {
-  assertRemoteCreateAgentOptionsSupported(options);
-  const includeOriginTag = settings.includeSdkOriginTag ?? true;
-  const body = await buildInitialAgentBody(options);
-  if (Array.isArray(body.tags)) {
-    body.tags = body.tags.filter((tag) => (includeOriginTag || tag !== LETTA_CODE_ORIGIN_TAG) && (options.memfs !== false || tag !== GIT_MEMORY_ENABLED_TAG));
-  }
-  if (options.embedding !== undefined)
-    body.embedding = options.embedding;
-  if (options.hidden !== undefined)
-    body.hidden = options.hidden;
-  if (options.baseTools === undefined) {
-    delete body.tools;
-    delete body.include_base_tools;
-    delete body.include_base_tool_rules;
-  } else {
-    body.tools = options.baseTools;
-    body.include_base_tools = false;
-    body.include_base_tool_rules = false;
-  }
-  if (options.systemPrompt === undefined) {
-    if (options.memfs === false) {
-      body.system = buildSystemPrompt("default", "standard");
-    }
-  } else {
-    if (typeof options.systemPrompt === "string") {
-      if (isPresetSystemPrompt(options.systemPrompt)) {
-        throw new Error("createAgent() does not yet support system prompt presets for this backend.");
-      }
-      body.system = options.systemPrompt;
-    } else {
-      throw new Error("createAgent() does not yet support system prompt preset objects for this backend.");
-    }
-  }
-  const hasMemoryConfiguration = Array.isArray(body.memory_blocks) || options.memory !== undefined || options.persona !== undefined || options.human !== undefined;
-  const memoryBlocks = Array.isArray(body.memory_blocks) ? body.memory_blocks.filter((block) => block !== null && typeof block === "object").map((block) => ({ ...block })) : [];
-  const blockIds = [];
-  for (const item of options.memory ?? []) {
-    if (typeof item === "string") {
-      throw new Error("App-server createAgent() does not yet support memory preset names.");
-    }
-    if ("blockId" in item) {
-      blockIds.push(item.blockId);
-    } else {
-      upsertMemoryBlock(memoryBlocks, normalizeMemoryBlock(item));
-    }
-  }
-  if (options.persona !== undefined) {
-    upsertMemoryBlock(memoryBlocks, {
-      label: "persona",
-      value: options.persona
-    });
-  }
-  if (options.human !== undefined) {
-    upsertMemoryBlock(memoryBlocks, { label: "human", value: options.human });
-  }
-  if (hasMemoryConfiguration)
-    body.memory_blocks = memoryBlocks;
-  if (blockIds.length > 0)
-    body.block_ids = blockIds;
-  return body;
-}
 function externalToolGroups(tools) {
   if (!tools || tools.length === 0)
     return;
@@ -10515,6 +10522,7 @@ class AppServerSession extends RemoteClientSessionCore {
       if (!response.success || !response.runtime) {
         throw new Error(response.error ?? "Failed to start app-server runtime");
       }
+      this.watchTransportDisconnect(client);
       const tools = agentToolNames(response.agent);
       const skillSources = options.skillSources;
       const clientToolset = "toolset" in options ? options.toolset : undefined;
@@ -10597,9 +10605,7 @@ class AppServerSession extends RemoteClientSessionCore {
       command.external_tools = groups;
     if (this.mode.kind === "create-agent") {
       command.create_agent = {
-        body: await createAgentBody(this.mode.options, {
-          includeSdkOriginTag: this.remoteOptions.includeSdkOriginTag
-        }),
+        body: await createAgentBody(this.mode.options),
         pin_global: this.remoteOptions.pinGlobalAgent ?? this.mode.options.hidden !== true,
         ...this.mode.options.memfs === false ? { memfs: false } : {}
       };
@@ -10760,6 +10766,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;
@@ -10976,66 +11108,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;
@@ -11134,8 +11206,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.");
@@ -11252,12 +11328,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"
     });
@@ -11268,32 +11362,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, { recoverWhenIdle: true });
       const tools = agentToolNames(response.agent);
       const skillSources = options.skillSources;
       const clientToolset = "toolset" in options ? options.toolset : undefined;
@@ -11311,17 +11392,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 = {
@@ -11364,10 +11479,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) {
@@ -11691,8 +11803,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;
@@ -11992,14 +12104,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;
@@ -12017,12 +12132,14 @@ function looksLikeConversationId(id) {
 
 class LettaAgentClientBase {
   backend;
+  computer;
   environment;
   agents;
   conversations;
   models;
   options;
   repositoriesClient = null;
+  computersClient = null;
   agentRepositoriesClient = null;
   cloudClient = null;
   managementTransport = null;
@@ -12032,16 +12149,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".');
@@ -12075,6 +12195,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().");
@@ -12164,13 +12287,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".`);
@@ -12190,8 +12317,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.`);
@@ -12206,11 +12334,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;
@@ -12241,6 +12371,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".');
@@ -29499,7 +29636,7 @@ class StreamableHTTPClientTransport {
 }
 var DEFAULT_CLIENT_INFO = {
   name: "letta-code",
-  version: "0.30.0"
+  version: "0.30.5"
 };
 async function connectMcpServer(config2, options = {}) {
   let client = new Client(options.clientInfo ?? DEFAULT_CLIENT_INFO);
@@ -29997,4 +30134,4 @@ export {
   CloudManagedSandboxExpiredError
 };
 
-//# debugId=240CAF4E9D69510064756E2164756E21
+//# debugId=C079C2D0B42E0C4F64756E2164756E21