@letta-ai/letta-code 0.32.6 → 0.32.7

package/letta.js

@@ -5515,7 +5515,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.32.6",
+    version: "0.32.7",
     lettaStartupLogProtocol: 1,
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
@@ -101244,6 +101244,8 @@ function createConversationRuntime(listener, agentId, conversationId) {
     pendingApprovalResolvers: new Map,
     recoveredApprovalState: null,
     syncApprovalRecoveryCompleted: false,
+    expectedTeleportId: null,
+    expectedTeleportExpiresAt: null,
     get lastStopReason() {
       return turnLifecycle.lastStopReason;
     },
@@ -101319,6 +101321,8 @@ function clearConversationRuntimeState(runtime) {
   runtime.pendingInterruptedResults = null;
   runtime.pendingInterruptedContext = null;
   runtime.pendingInterruptedToolCallIds = null;
+  runtime.expectedTeleportId = null;
+  runtime.expectedTeleportExpiresAt = null;
   runtime.dequeuedClientMessageIdsByBatchId.clear();
   runtime.continuationEpoch += 1;
   runtime.pendingTurns = 0;
@@ -122333,6 +122337,17 @@ function actingUserRequestOptions(actingUserId) {
 var ACTING_USER_ID_HEADER = "X-Letta-Acting-User-Id", ACTING_USER_ID_ENV = "LETTA_ACTING_USER_ID";
 
 // src/backend/api/agent-message.ts
+function normalizeAgentMessageComputer(value) {
+  if (value == null)
+    return;
+  if (typeof value !== "string") {
+    throw new Error("computer must be a computer name, or omitted to use the conversation's current destination.");
+  }
+  const computer = value.trim();
+  if (!computer)
+    return;
+  return ["cloud", "cloud-sandbox"].includes(computer.toLowerCase()) ? "cloud" : computer;
+}
 function buildAgentSendContent(sender, noWait, message) {
   const reminder = buildAgentSendReminder(sender, noWait);
   return [
@@ -122454,9 +122469,7 @@ async function send_agent_message(args, deps = {}) {
     }
     if (!args.message?.trim())
       throw new Error("Message must not be empty.");
-    if (args.computer !== undefined && !args.computer.trim()) {
-      throw new Error("Computer selector must not be empty.");
-    }
+    const computer = normalizeAgentMessageComputer(args.computer);
     const context3 = getRuntimeContext();
     const sender = {
       agentId: validateAddress(context3?.agentId ?? undefined, "agent"),
@@ -122479,12 +122492,11 @@ async function send_agent_message(args, deps = {}) {
     }, backend, signal);
     signal.throwIfAborted();
     submissionAttempted = true;
-    const computer = args.computer;
     const receipt = await (deps.enqueue ?? enqueueConversationMessage)({
       ...destination,
       clientMessageId,
       content: buildAgentSendContent(sender, true, args.message),
-      computer: computer && ["cloud", "cloud-sandbox"].includes(computer.trim().toLowerCase()) ? "cloud" : computer,
+      computer,
       actingUserId
     }, signal);
     return {
@@ -126548,8 +126560,8 @@ var init_SendAgentMessage2 = __esm(() => {
         description: "The existing message thread to send to. Each conversation has its own message history. A conv-... ID is sufficient; to use an agent's default thread, also supply agent_id."
       },
       computer: {
-        type: "string",
-        description: "Optional computer where the recipient should run: cloud, an online computer name, or its stable device ID. Omit to use its active computer or saved destination (a computer or Cloud sandbox). An offline saved computer does not trigger a Cloud-sandbox fallback."
+        type: ["string", "null"],
+        description: "Optional computer where the recipient should run: cloud, an online computer name, or its stable device ID. Omitted, null, and blank values use its active computer or saved destination (a computer or Cloud sandbox). An offline saved computer does not trigger a Cloud-sandbox fallback."
       }
     },
     required: ["message"],
@@ -222814,7 +222826,7 @@ function isRuntimeStartCommand(value) {
   if (!value || typeof value !== "object")
     return false;
   const c = value;
-  return c.type === "runtime_start" && typeof c.request_id === "string" && (c.agent_id === undefined || typeof c.agent_id === "string") && (c.create_agent === undefined || isRuntimeStartCreateAgentOptions(c.create_agent)) && (c.conversation_id === undefined || typeof c.conversation_id === "string") && (c.create_conversation === undefined || isRuntimeStartCreateConversationOptions(c.create_conversation)) && (c.conversation_source_tags === undefined || isStringArray8(c.conversation_source_tags)) && (c.cwd === undefined || c.cwd === null || typeof c.cwd === "string") && (c.mode === undefined || isDevicePermissionMode(c.mode)) && (c.execution_settings === undefined || isRuntimeExecutionSettings(c.execution_settings)) && (c.workspace_sandbox === undefined || isRuntimeStartWorkspaceSandbox(c.workspace_sandbox)) && (c.skill_sources === undefined || isSkillSourceArray(c.skill_sources)) && (c.preserve_skill_sources === undefined || typeof c.preserve_skill_sources === "boolean") && (c.client_info === undefined || isRuntimeStartClientInfo(c.client_info)) && (c.recover_approvals === undefined || typeof c.recover_approvals === "boolean") && (c.force_device_status === undefined || typeof c.force_device_status === "boolean") && (c.wait_for_replay === undefined || typeof c.wait_for_replay === "boolean") && (c.external_tools === undefined || Array.isArray(c.external_tools) && c.external_tools.every(isRuntimeStartExternalToolsGroup));
+  return c.type === "runtime_start" && typeof c.request_id === "string" && (c.agent_id === undefined || typeof c.agent_id === "string") && (c.create_agent === undefined || isRuntimeStartCreateAgentOptions(c.create_agent)) && (c.conversation_id === undefined || typeof c.conversation_id === "string") && (c.create_conversation === undefined || isRuntimeStartCreateConversationOptions(c.create_conversation)) && (c.conversation_source_tags === undefined || isStringArray8(c.conversation_source_tags)) && (c.cwd === undefined || c.cwd === null || typeof c.cwd === "string") && (c.mode === undefined || isDevicePermissionMode(c.mode)) && (c.execution_settings === undefined || isRuntimeExecutionSettings(c.execution_settings)) && (c.workspace_sandbox === undefined || isRuntimeStartWorkspaceSandbox(c.workspace_sandbox)) && (c.skill_sources === undefined || isSkillSourceArray(c.skill_sources)) && (c.preserve_skill_sources === undefined || typeof c.preserve_skill_sources === "boolean") && (c.client_info === undefined || isRuntimeStartClientInfo(c.client_info)) && (c.recover_approvals === undefined || typeof c.recover_approvals === "boolean") && (c.force_device_status === undefined || typeof c.force_device_status === "boolean") && (c.wait_for_replay === undefined || typeof c.wait_for_replay === "boolean") && (c.teleport_id === undefined || typeof c.teleport_id === "string") && (c.external_tools === undefined || Array.isArray(c.external_tools) && c.external_tools.every(isRuntimeStartExternalToolsGroup));
 }
 function isRuntimeStartCreateAgentOptions(value) {
   if (!isObjectRecord2(value))
@@ -397765,6 +397777,497 @@ function assertRuntimeWorkspaceSandboxChangeAllowed(listener, runtime, next) {
   }
 }
 
+// src/channels/teleport-guard.ts
+function getLocalChannelTeleportError(scope) {
+  const channels = getSupportedChannelIds().filter((channelId) => {
+    return readRoutes(channelId).some((route) => route.agentId === scope.agentId && route.conversationId === scope.conversationId && route.enabled !== false && route.outboundEnabled !== false);
+  });
+  if (channels.length === 0)
+    return null;
+  return `This conversation is bound to ${channels.join(", ")} on this computer. Teleport is blocked because MessageChannel cannot follow the conversation to another computer yet. Remove the channel route or continue locally.`;
+}
+var init_teleport_guard = __esm(() => {
+  init_plugin_registry();
+  init_routing();
+});
+
+// src/websocket/listener/recoverable-notices.ts
+function getRecoverableStatusNoticeVisibility(kind) {
+  switch (kind) {
+    case "stale_approval_conflict_recovery":
+      return "debug_only";
+    default:
+      return "transcript";
+  }
+}
+function getRecoverableRetryNoticeVisibility(kind) {
+  switch (kind) {
+    case "transient_provider_retry":
+      return "transcript";
+    default:
+      return "transcript";
+  }
+}
+function isDesktopDebugPanelMirrorEnabled() {
+  return process.env.LETTA_DESKTOP_MODE === "1";
+}
+function mirrorRecoverableNoticeToDesktopDebugPanel(message) {
+  if (!isDesktopDebugPanelMirrorEnabled()) {
+    return;
+  }
+  try {
+    process.stderr.write(`${DESKTOP_DEBUG_PANEL_INFO_PREFIX} ${message}
+`);
+  } catch {}
+}
+function toStructuredApiError(errorInfo) {
+  if (!errorInfo?.error_type || !errorInfo.run_id) {
+    return;
+  }
+  return {
+    message_type: "error_message",
+    message: errorInfo.message || errorInfo.detail || "An error occurred",
+    error_type: errorInfo.error_type,
+    run_id: errorInfo.run_id,
+    ...errorInfo.detail ? { detail: errorInfo.detail } : {}
+  };
+}
+function getStructuredApiErrorFromError(error4) {
+  if (!(error4 instanceof Error)) {
+    return;
+  }
+  const errorWithStructuredInfo = error4;
+  return errorWithStructuredInfo.apiError ?? toStructuredApiError(errorWithStructuredInfo.runErrorInfo);
+}
+function buildStructuredFormatInput(apiError) {
+  return {
+    error: {
+      error: {
+        type: apiError.error_type,
+        message: apiError.message,
+        ...apiError.detail ? { detail: apiError.detail } : {}
+      },
+      run_id: apiError.run_id
+    }
+  };
+}
+function isAbortLikeError(error4) {
+  if (error4 instanceof APIUserAbortError) {
+    return true;
+  }
+  if (!(error4 instanceof Error)) {
+    return false;
+  }
+  const errorWithCode = error4;
+  return error4.name === "AbortError" || error4.message === "The operation was aborted" || errorWithCode.code === "ABORT_ERR";
+}
+function isTerminatedProcessNoise(message) {
+  return message.trim().toLowerCase() === "terminated";
+}
+function isProxyTransportError(detail, error4, message) {
+  if (error4 instanceof APIError && error4.status >= 500 && detail.toLowerCase().includes("trying to proxy")) {
+    return true;
+  }
+  return detail.toLowerCase().includes("error occurred while trying to proxy") || message.toLowerCase().includes("error occurred while trying to proxy");
+}
+function getLoopErrorNoticeDecision(params) {
+  const apiError = params.apiError ?? toStructuredApiError(params.errorInfo) ?? toStructuredApiError(params.runErrorInfo) ?? getStructuredApiErrorFromError(params.error);
+  const detail = apiError?.detail ?? params.errorInfo?.detail ?? params.runErrorInfo?.detail ?? extractConflictDetail(params.error) ?? "";
+  if (params.cancelRequested || params.abortSignal?.aborted || isAbortLikeError(params.error) || isTerminatedProcessNoise(params.message)) {
+    return {
+      visibility: "debug_only",
+      message: params.message
+    };
+  }
+  const cloudflareMessage = checkCloudflareEdgeError(detail) ?? checkCloudflareEdgeError(params.message);
+  if (cloudflareMessage) {
+    return {
+      visibility: "transcript",
+      message: cloudflareMessage,
+      apiError
+    };
+  }
+  if (isProxyTransportError(detail, params.error, params.message)) {
+    return {
+      visibility: "transcript",
+      message: "Connection to Letta service failed. Please retry.",
+      apiError
+    };
+  }
+  const formattedMessage = formatErrorDetails2(apiError ? buildStructuredFormatInput(apiError) : params.error ?? params.message, params.agentId ?? undefined, params.conversationId ?? undefined, {
+    surface: params.surface,
+    unclassifiedFallback: params.unclassifiedFallback
+  });
+  return {
+    visibility: "transcript",
+    message: formattedMessage,
+    apiError
+  };
+}
+function getTranscriptLoopErrorMessage(params) {
+  const decision = getLoopErrorNoticeDecision({
+    ...params,
+    surface: "plain",
+    unclassifiedFallback: "generic"
+  });
+  return decision.visibility === "transcript" ? decision.message : undefined;
+}
+function getConsumerLoopErrorMessage(params) {
+  const decision = getLoopErrorNoticeDecision({
+    ...params,
+    surface: "plain"
+  });
+  return decision.visibility === "transcript" ? decision.message : undefined;
+}
+function emitLoopErrorNotice(socket, runtime, params) {
+  const decision = getLoopErrorNoticeDecision(params);
+  if (decision.visibility === "debug_only") {
+    debugLog("recovery", `Debug-only loop error (${params.stopReason}): ${params.message}`);
+    mirrorRecoverableNoticeToDesktopDebugPanel(params.message);
+    return null;
+  }
+  emitLoopErrorDelta(socket, runtime, {
+    message: decision.message,
+    stopReason: params.stopReason,
+    isTerminal: params.isTerminal,
+    runId: params.runId,
+    agentId: params.agentId,
+    conversationId: params.conversationId,
+    apiError: decision.apiError
+  });
+  return decision.message;
+}
+function emitRecoverableStatusNotice(socket, runtime, params) {
+  const visibility = getRecoverableStatusNoticeVisibility(params.kind);
+  if (visibility === "debug_only") {
+    debugLog("recovery", `Debug-only lifecycle notice (${params.kind}): ${params.message}`);
+    mirrorRecoverableNoticeToDesktopDebugPanel(params.message);
+    return;
+  }
+  emitStatusDelta(socket, runtime, {
+    message: params.message,
+    level: params.level,
+    runId: params.runId,
+    agentId: params.agentId,
+    conversationId: params.conversationId
+  });
+}
+function emitRecoverableRetryNotice(socket, runtime, params) {
+  const visibility = getRecoverableRetryNoticeVisibility(params.kind);
+  if (visibility === "debug_only") {
+    debugLog("recovery", `Debug-only retry notice (${params.kind}, attempt ${params.attempt}/${params.maxAttempts}): ${params.message}`);
+    mirrorRecoverableNoticeToDesktopDebugPanel(params.message);
+    return;
+  }
+  emitRetryDelta(socket, runtime, {
+    message: params.message,
+    reason: params.reason,
+    attempt: params.attempt,
+    maxAttempts: params.maxAttempts,
+    delayMs: params.delayMs,
+    runId: params.runId,
+    agentId: params.agentId,
+    conversationId: params.conversationId
+  });
+}
+var DESKTOP_DEBUG_PANEL_INFO_PREFIX = "[LETTA_DESKTOP_DEBUG_PANEL_INFO]";
+var init_recoverable_notices = __esm(() => {
+  init_error();
+  init_turn_recovery_policy();
+  init_error_formatter();
+  init_debug();
+  init_protocol_outbound();
+});
+
+// src/websocket/listener/teleport.ts
+function expectInboundTeleport(runtime, teleportId) {
+  runtime.expectedTeleportId = teleportId;
+  runtime.expectedTeleportExpiresAt = Date.now() + INBOUND_TELEPORT_CONTINUE_TTL_MS;
+}
+function isInboundTeleportExpected(runtime) {
+  if (runtime.expectedTeleportId === null)
+    return false;
+  if (runtime.expectedTeleportExpiresAt !== null && runtime.expectedTeleportExpiresAt <= Date.now()) {
+    clearExpectedInboundTeleport(runtime);
+    return false;
+  }
+  return true;
+}
+function clearExpectedInboundTeleport(runtime) {
+  runtime.expectedTeleportId = null;
+  runtime.expectedTeleportExpiresAt = null;
+}
+function buildTeleportContinuationMessages(params) {
+  return [
+    {
+      type: "approval",
+      approvals: params.approvals,
+      otid: params.teleportId
+    },
+    {
+      role: "system",
+      content: "<system-reminder>Teleportation to this environment is complete. Continue the existing task from this environment now.</system-reminder>",
+      otid: `${params.teleportId}:continue`
+    }
+  ];
+}
+function escapeSystemReminderText(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function buildTeleportFailureMessages(params) {
+  const messages = [];
+  if (params.approvals && params.approvals.length > 0) {
+    messages.push({
+      type: "approval",
+      approvals: params.approvals,
+      otid: params.teleportId
+    });
+  }
+  messages.push({
+    role: "system",
+    content: `<system-reminder>Teleportation failed.
+
+Error: ${escapeSystemReminderText(params.error)}
+
+Continue the existing task from this environment now.</system-reminder>`,
+    otid: `${params.teleportId}:failed`
+  });
+  return messages;
+}
+function getPendingTeleports(runtime) {
+  runtime.pendingTeleports ??= new Map;
+  return runtime.pendingTeleports;
+}
+function findPendingTeleportForRuntime(runtime, agentId, conversationId) {
+  for (const pending of getPendingTeleports(runtime).values()) {
+    if (pending.agentId === agentId && pending.conversationId === conversationId && pending.readyAt === undefined) {
+      return pending;
+    }
+  }
+  return null;
+}
+function isRuntimeTeleportPending(runtime, agentId, conversationId) {
+  if (!agentId)
+    return false;
+  return [...runtime.pendingTeleports?.values() ?? []].some((pending) => !pending.error && pending.agentId === agentId && pending.conversationId === conversationId);
+}
+function clearPriorReadyTeleports(params) {
+  const pendingTeleports = params.listener.pendingTeleports;
+  if (!pendingTeleports)
+    return;
+  for (const [teleportId, pending] of pendingTeleports) {
+    if (teleportId === params.currentTeleportId || pending.readyAt === undefined) {
+      continue;
+    }
+    if (pending.agentId === params.agentId && pending.conversationId === params.conversationId) {
+      pendingTeleports.delete(teleportId);
+    }
+  }
+}
+function hasAcceptedInputsWaiting(runtime, includeQueuePump) {
+  return runtime.queueRuntime.length > 0 || runtime.pendingTurns > 0 || runtime.queuedMessagesByItemId.size > 0 || includeQueuePump && (runtime.queuePumpActive || runtime.queuePumpScheduled);
+}
+function sendTeleportReady(runtime, pending, input) {
+  const connection = runtime.connections.get(pending.connectionId);
+  if (!connection || !isListenerTransportOpen(connection.writer))
+    return false;
+  const mode = getOrCreateConversationPermissionModeStateRef(runtime, pending.agentId, pending.conversationId).mode;
+  const message = {
+    type: "teleport_ready",
+    teleport_id: pending.teleportId,
+    runtime: {
+      agent_id: pending.agentId,
+      conversation_id: pending.conversationId
+    },
+    success: input.success,
+    active_turn: pending.activeTurn,
+    mode,
+    ...pending.continuation ? { continuation: pending.continuation } : {},
+    ...input.error ? { error: input.error } : {}
+  };
+  emitProtocolV2Message(connection.writer, runtime, message, message.runtime, toListenerConnection(pending.connectionId));
+  return true;
+}
+function retainTeleportForRecovery(runtime, pending) {
+  const timeout = setTimeout(() => {
+    const current = runtime.pendingTeleports?.get(pending.teleportId);
+    if (current === pending) {
+      runtime.pendingTeleports?.delete(pending.teleportId);
+    }
+  }, TELEPORT_RECOVERY_TTL_MS);
+  timeout.unref?.();
+}
+function handleTeleportProbe(command, socket, safeSocketSend) {
+  safeSocketSend(socket, {
+    type: "teleport_probe_response",
+    request_id: command.request_id,
+    runtime: command.runtime,
+    supported: resolveBackendMode() === "api",
+    drains_accepted_inputs: true,
+    idempotent_continuation: true
+  }, "teleport_probe_response", "teleport_probe");
+}
+function handleTeleportRequest(params) {
+  const { listener, command, connectionId } = params;
+  const pendingTeleports = getPendingTeleports(listener);
+  const existing = pendingTeleports.get(command.teleport_id);
+  if (existing) {
+    if (existing.readyAt !== undefined) {
+      sendTeleportReady(listener, existing, {
+        success: existing.error === undefined,
+        error: existing.error
+      });
+    }
+    return;
+  }
+  const pending = {
+    teleportId: command.teleport_id,
+    connectionId,
+    agentId: command.runtime.agent_id,
+    conversationId: command.runtime.conversation_id,
+    requestedAt: Date.now(),
+    drainAcceptedInputs: false,
+    activeTurn: false
+  };
+  const channelError = getLocalChannelTeleportError(pending);
+  if (channelError) {
+    pending.readyAt = Date.now();
+    pending.error = channelError;
+    pendingTeleports.set(pending.teleportId, pending);
+    sendTeleportReady(listener, pending, {
+      success: false,
+      error: channelError
+    });
+    retainTeleportForRecovery(listener, pending);
+    return;
+  }
+  const conflicting = findPendingTeleportForRuntime(listener, pending.agentId, pending.conversationId);
+  if (conflicting) {
+    pendingTeleports.set(pending.teleportId, pending);
+    pending.readyAt = Date.now();
+    pending.error = "Conversation already has a teleport pending";
+    sendTeleportReady(listener, pending, {
+      success: false,
+      error: pending.error
+    });
+    retainTeleportForRecovery(listener, pending);
+    return;
+  }
+  pendingTeleports.set(pending.teleportId, pending);
+  const conversationRuntime = getConversationRuntime(listener, pending.agentId, pending.conversationId);
+  pending.drainAcceptedInputs = conversationRuntime ? hasAcceptedInputsWaiting(conversationRuntime, true) : false;
+  if (!conversationRuntime?.isProcessing && !pending.drainAcceptedInputs) {
+    if (sendTeleportReady(listener, pending, { success: true })) {
+      pending.readyAt = Date.now();
+      retainTeleportForRecovery(listener, pending);
+    }
+  }
+}
+function claimPendingTeleportAtBoundary(params) {
+  const pending = findPendingTeleportForRuntime(params.listener, params.agentId, params.conversationId);
+  if (!pending)
+    return null;
+  if (pending.drainAcceptedInputs) {
+    if (params.activeTurn)
+      return null;
+    const runtime = getConversationRuntime(params.listener, params.agentId, params.conversationId);
+    if (runtime && hasAcceptedInputsWaiting(runtime, false))
+      return null;
+  }
+  const connection = params.listener.connections.get(pending.connectionId);
+  if (!connection || !isListenerTransportOpen(connection.writer))
+    return null;
+  pending.readyAt = Date.now();
+  pending.activeTurn = params.activeTurn;
+  pending.continuation = params.continuation;
+  return pending;
+}
+function emitClaimedTeleportReady(listener, pending) {
+  const sent = sendTeleportReady(listener, pending, { success: true });
+  if (sent) {
+    retainTeleportForRecovery(listener, pending);
+  }
+  return sent;
+}
+function finishTeleport(runtime, lease, pending) {
+  const transition = runtime.turnLifecycle.finish(lease, "cancelled");
+  if (!transition.finished)
+    return transition;
+  emitRuntimeStateUpdates(runtime, {
+    agent_id: pending.agentId,
+    conversation_id: pending.conversationId
+  });
+  emitClaimedTeleportReady(runtime.listener, pending);
+  return transition;
+}
+function finishPendingTeleport(runtime) {
+  if (!runtime.agentId)
+    return;
+  const pending = findPendingTeleportForRuntime(runtime.listener, runtime.agentId, runtime.conversationId);
+  if (!pending || runtime.lastStopReason !== "end_turn" && !pending.drainAcceptedInputs) {
+    return;
+  }
+  const claimed = claimPendingTeleportAtBoundary({
+    listener: runtime.listener,
+    agentId: runtime.agentId,
+    conversationId: runtime.conversationId,
+    activeTurn: false
+  });
+  if (claimed)
+    emitClaimedTeleportReady(runtime.listener, claimed);
+}
+function takeFailedTeleport(params) {
+  const pending = params.listener.pendingTeleports?.get(params.teleportId);
+  if (!pending || pending.agentId !== params.agentId || pending.conversationId !== params.conversationId) {
+    return null;
+  }
+  params.listener.pendingTeleports?.delete(params.teleportId);
+  return pending;
+}
+function handleTeleportFailure(params) {
+  const pending = takeFailedTeleport({
+    listener: params.listener,
+    teleportId: params.command.teleport_id,
+    agentId: params.command.runtime.agent_id,
+    conversationId: params.command.runtime.conversation_id
+  });
+  if (!pending || pending.error)
+    return;
+  const runtime = params.getOrCreateScopedRuntime(params.listener, pending.agentId, pending.conversationId);
+  emitLoopErrorNotice(params.socket, runtime, {
+    message: `Teleport failed: ${params.command.error}`,
+    stopReason: "error",
+    isTerminal: false,
+    agentId: pending.agentId,
+    conversationId: pending.conversationId
+  });
+  params.runDetachedListenerTask("teleport_failed", async () => {
+    await params.processIncomingMessage({
+      type: "message",
+      connectionId: pending.connectionId,
+      agentId: pending.agentId,
+      conversationId: pending.conversationId,
+      messages: buildTeleportFailureMessages({
+        teleportId: params.command.teleport_id,
+        error: params.command.error,
+        approvals: pending.continuation?.approvals
+      })
+    }, params.socket, runtime, params.onStatusChange, pending.connectionId);
+  });
+}
+var TELEPORT_RECOVERY_TTL_MS, INBOUND_TELEPORT_CONTINUE_TTL_MS = 60000;
+var init_teleport = __esm(() => {
+  init_backend_mode();
+  init_teleport_guard();
+  init_connection();
+  init_permission_mode();
+  init_protocol_outbound();
+  init_recoverable_notices();
+  init_runtime();
+  init_transport();
+  TELEPORT_RECOVERY_TTL_MS = 5 * 60000;
+});
+
 // src/websocket/listener/commands/runtime-start.ts
 function buildDefaultConversation(agent) {
   const now2 = new Date().toISOString();
@@ -397984,6 +398487,9 @@ async function handleRuntimeStartCommand(parsed, context3) {
     assertConnectionOpen();
     const scopedRuntime = context3.getOrCreateScopedRuntime(context3.runtime, runtimeScope.agent_id, runtimeScope.conversation_id);
     await applyRuntimeStartState(parsed, context3, runtimeScope, scopedRuntime);
+    if (parsed.teleport_id) {
+      expectInboundTeleport(scopedRuntime, parsed.teleport_id);
+    }
     assertConnectionOpen();
     subscribeListenerConnection(context3.runtime, connectionId, runtimeScope);
     registerRuntimeExternalTools(context3.runtime, connectionId, runtimeScope, parsed.external_tools ?? []);
@@ -398045,6 +398551,7 @@ var init_runtime_start = __esm(async () => {
   init_cwd_change();
   init_permission_mode();
   init_runtime_start_validation();
+  init_teleport();
   await init_external_tools();
   LEGACY_SUMMARY_PREFIX_BY_SOURCE_TAG = {
     "channel:discord": "discord",
@@ -398923,194 +399430,6 @@ var init_interrupts = __esm(() => {
   STREAMING_TOOL_OUTPUT_MAX_CHARS = LIMITS.BASH_OUTPUT_CHARS;
 });
 
-// src/websocket/listener/recoverable-notices.ts
-function getRecoverableStatusNoticeVisibility(kind) {
-  switch (kind) {
-    case "stale_approval_conflict_recovery":
-      return "debug_only";
-    default:
-      return "transcript";
-  }
-}
-function getRecoverableRetryNoticeVisibility(kind) {
-  switch (kind) {
-    case "transient_provider_retry":
-      return "transcript";
-    default:
-      return "transcript";
-  }
-}
-function isDesktopDebugPanelMirrorEnabled() {
-  return process.env.LETTA_DESKTOP_MODE === "1";
-}
-function mirrorRecoverableNoticeToDesktopDebugPanel(message) {
-  if (!isDesktopDebugPanelMirrorEnabled()) {
-    return;
-  }
-  try {
-    process.stderr.write(`${DESKTOP_DEBUG_PANEL_INFO_PREFIX} ${message}
-`);
-  } catch {}
-}
-function toStructuredApiError(errorInfo) {
-  if (!errorInfo?.error_type || !errorInfo.run_id) {
-    return;
-  }
-  return {
-    message_type: "error_message",
-    message: errorInfo.message || errorInfo.detail || "An error occurred",
-    error_type: errorInfo.error_type,
-    run_id: errorInfo.run_id,
-    ...errorInfo.detail ? { detail: errorInfo.detail } : {}
-  };
-}
-function getStructuredApiErrorFromError(error4) {
-  if (!(error4 instanceof Error)) {
-    return;
-  }
-  const errorWithStructuredInfo = error4;
-  return errorWithStructuredInfo.apiError ?? toStructuredApiError(errorWithStructuredInfo.runErrorInfo);
-}
-function buildStructuredFormatInput(apiError) {
-  return {
-    error: {
-      error: {
-        type: apiError.error_type,
-        message: apiError.message,
-        ...apiError.detail ? { detail: apiError.detail } : {}
-      },
-      run_id: apiError.run_id
-    }
-  };
-}
-function isAbortLikeError(error4) {
-  if (error4 instanceof APIUserAbortError) {
-    return true;
-  }
-  if (!(error4 instanceof Error)) {
-    return false;
-  }
-  const errorWithCode = error4;
-  return error4.name === "AbortError" || error4.message === "The operation was aborted" || errorWithCode.code === "ABORT_ERR";
-}
-function isTerminatedProcessNoise(message) {
-  return message.trim().toLowerCase() === "terminated";
-}
-function isProxyTransportError(detail, error4, message) {
-  if (error4 instanceof APIError && error4.status >= 500 && detail.toLowerCase().includes("trying to proxy")) {
-    return true;
-  }
-  return detail.toLowerCase().includes("error occurred while trying to proxy") || message.toLowerCase().includes("error occurred while trying to proxy");
-}
-function getLoopErrorNoticeDecision(params) {
-  const apiError = params.apiError ?? toStructuredApiError(params.errorInfo) ?? toStructuredApiError(params.runErrorInfo) ?? getStructuredApiErrorFromError(params.error);
-  const detail = apiError?.detail ?? params.errorInfo?.detail ?? params.runErrorInfo?.detail ?? extractConflictDetail(params.error) ?? "";
-  if (params.cancelRequested || params.abortSignal?.aborted || isAbortLikeError(params.error) || isTerminatedProcessNoise(params.message)) {
-    return {
-      visibility: "debug_only",
-      message: params.message
-    };
-  }
-  const cloudflareMessage = checkCloudflareEdgeError(detail) ?? checkCloudflareEdgeError(params.message);
-  if (cloudflareMessage) {
-    return {
-      visibility: "transcript",
-      message: cloudflareMessage,
-      apiError
-    };
-  }
-  if (isProxyTransportError(detail, params.error, params.message)) {
-    return {
-      visibility: "transcript",
-      message: "Connection to Letta service failed. Please retry.",
-      apiError
-    };
-  }
-  const formattedMessage = formatErrorDetails2(apiError ? buildStructuredFormatInput(apiError) : params.error ?? params.message, params.agentId ?? undefined, params.conversationId ?? undefined, {
-    surface: params.surface,
-    unclassifiedFallback: params.unclassifiedFallback
-  });
-  return {
-    visibility: "transcript",
-    message: formattedMessage,
-    apiError
-  };
-}
-function getTranscriptLoopErrorMessage(params) {
-  const decision = getLoopErrorNoticeDecision({
-    ...params,
-    surface: "plain",
-    unclassifiedFallback: "generic"
-  });
-  return decision.visibility === "transcript" ? decision.message : undefined;
-}
-function getConsumerLoopErrorMessage(params) {
-  const decision = getLoopErrorNoticeDecision({
-    ...params,
-    surface: "plain"
-  });
-  return decision.visibility === "transcript" ? decision.message : undefined;
-}
-function emitLoopErrorNotice(socket, runtime, params) {
-  const decision = getLoopErrorNoticeDecision(params);
-  if (decision.visibility === "debug_only") {
-    debugLog("recovery", `Debug-only loop error (${params.stopReason}): ${params.message}`);
-    mirrorRecoverableNoticeToDesktopDebugPanel(params.message);
-    return null;
-  }
-  emitLoopErrorDelta(socket, runtime, {
-    message: decision.message,
-    stopReason: params.stopReason,
-    isTerminal: params.isTerminal,
-    runId: params.runId,
-    agentId: params.agentId,
-    conversationId: params.conversationId,
-    apiError: decision.apiError
-  });
-  return decision.message;
-}
-function emitRecoverableStatusNotice(socket, runtime, params) {
-  const visibility = getRecoverableStatusNoticeVisibility(params.kind);
-  if (visibility === "debug_only") {
-    debugLog("recovery", `Debug-only lifecycle notice (${params.kind}): ${params.message}`);
-    mirrorRecoverableNoticeToDesktopDebugPanel(params.message);
-    return;
-  }
-  emitStatusDelta(socket, runtime, {
-    message: params.message,
-    level: params.level,
-    runId: params.runId,
-    agentId: params.agentId,
-    conversationId: params.conversationId
-  });
-}
-function emitRecoverableRetryNotice(socket, runtime, params) {
-  const visibility = getRecoverableRetryNoticeVisibility(params.kind);
-  if (visibility === "debug_only") {
-    debugLog("recovery", `Debug-only retry notice (${params.kind}, attempt ${params.attempt}/${params.maxAttempts}): ${params.message}`);
-    mirrorRecoverableNoticeToDesktopDebugPanel(params.message);
-    return;
-  }
-  emitRetryDelta(socket, runtime, {
-    message: params.message,
-    reason: params.reason,
-    attempt: params.attempt,
-    maxAttempts: params.maxAttempts,
-    delayMs: params.delayMs,
-    runId: params.runId,
-    agentId: params.agentId,
-    conversationId: params.conversationId
-  });
-}
-var DESKTOP_DEBUG_PANEL_INFO_PREFIX = "[LETTA_DESKTOP_DEBUG_PANEL_INFO]";
-var init_recoverable_notices = __esm(() => {
-  init_error();
-  init_turn_recovery_policy();
-  init_error_formatter();
-  init_debug();
-  init_protocol_outbound();
-});
-
 // src/cli/helpers/compaction-utils.ts
 function extractCompactionSummary(text2) {
   try {
@@ -403268,292 +403587,6 @@ var init_stream_recovery_status = __esm(() => {
   init_protocol_outbound();
 });
 
-// src/channels/teleport-guard.ts
-function getLocalChannelTeleportError(scope) {
-  const channels = getSupportedChannelIds().filter((channelId) => {
-    return readRoutes(channelId).some((route) => route.agentId === scope.agentId && route.conversationId === scope.conversationId && route.enabled !== false && route.outboundEnabled !== false);
-  });
-  if (channels.length === 0)
-    return null;
-  return `This conversation is bound to ${channels.join(", ")} on this computer. Teleport is blocked because MessageChannel cannot follow the conversation to another computer yet. Remove the channel route or continue locally.`;
-}
-var init_teleport_guard = __esm(() => {
-  init_plugin_registry();
-  init_routing();
-});
-
-// src/websocket/listener/teleport.ts
-function buildTeleportContinuationMessages(params) {
-  return [
-    {
-      type: "approval",
-      approvals: params.approvals,
-      otid: params.teleportId
-    },
-    {
-      role: "system",
-      content: "<system-reminder>Teleportation to this environment is complete. Continue the existing task from this environment now.</system-reminder>",
-      otid: `${params.teleportId}:continue`
-    }
-  ];
-}
-function escapeSystemReminderText(value) {
-  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-function buildTeleportFailureMessages(params) {
-  const messages = [];
-  if (params.approvals && params.approvals.length > 0) {
-    messages.push({
-      type: "approval",
-      approvals: params.approvals,
-      otid: params.teleportId
-    });
-  }
-  messages.push({
-    role: "system",
-    content: `<system-reminder>Teleportation failed.
-
-Error: ${escapeSystemReminderText(params.error)}
-
-Continue the existing task from this environment now.</system-reminder>`,
-    otid: `${params.teleportId}:failed`
-  });
-  return messages;
-}
-function getPendingTeleports(runtime) {
-  runtime.pendingTeleports ??= new Map;
-  return runtime.pendingTeleports;
-}
-function findPendingTeleportForRuntime(runtime, agentId, conversationId) {
-  for (const pending of getPendingTeleports(runtime).values()) {
-    if (pending.agentId === agentId && pending.conversationId === conversationId && pending.readyAt === undefined) {
-      return pending;
-    }
-  }
-  return null;
-}
-function isRuntimeTeleportPending(runtime, agentId, conversationId) {
-  if (!agentId)
-    return false;
-  return [...runtime.pendingTeleports?.values() ?? []].some((pending) => !pending.error && pending.agentId === agentId && pending.conversationId === conversationId);
-}
-function clearPriorReadyTeleports(params) {
-  const pendingTeleports = params.listener.pendingTeleports;
-  if (!pendingTeleports)
-    return;
-  for (const [teleportId, pending] of pendingTeleports) {
-    if (teleportId === params.currentTeleportId || pending.readyAt === undefined) {
-      continue;
-    }
-    if (pending.agentId === params.agentId && pending.conversationId === params.conversationId) {
-      pendingTeleports.delete(teleportId);
-    }
-  }
-}
-function hasAcceptedInputsWaiting(runtime, includeQueuePump) {
-  return runtime.queueRuntime.length > 0 || runtime.pendingTurns > 0 || runtime.queuedMessagesByItemId.size > 0 || includeQueuePump && (runtime.queuePumpActive || runtime.queuePumpScheduled);
-}
-function sendTeleportReady(runtime, pending, input) {
-  const connection = runtime.connections.get(pending.connectionId);
-  if (!connection || !isListenerTransportOpen(connection.writer))
-    return false;
-  const mode = getOrCreateConversationPermissionModeStateRef(runtime, pending.agentId, pending.conversationId).mode;
-  const message = {
-    type: "teleport_ready",
-    teleport_id: pending.teleportId,
-    runtime: {
-      agent_id: pending.agentId,
-      conversation_id: pending.conversationId
-    },
-    success: input.success,
-    active_turn: pending.activeTurn,
-    mode,
-    ...pending.continuation ? { continuation: pending.continuation } : {},
-    ...input.error ? { error: input.error } : {}
-  };
-  emitProtocolV2Message(connection.writer, runtime, message, message.runtime, toListenerConnection(pending.connectionId));
-  return true;
-}
-function retainTeleportForRecovery(runtime, pending) {
-  const timeout = setTimeout(() => {
-    const current = runtime.pendingTeleports?.get(pending.teleportId);
-    if (current === pending) {
-      runtime.pendingTeleports?.delete(pending.teleportId);
-    }
-  }, TELEPORT_RECOVERY_TTL_MS);
-  timeout.unref?.();
-}
-function handleTeleportProbe(command, socket, safeSocketSend) {
-  safeSocketSend(socket, {
-    type: "teleport_probe_response",
-    request_id: command.request_id,
-    runtime: command.runtime,
-    supported: resolveBackendMode() === "api",
-    drains_accepted_inputs: true,
-    idempotent_continuation: true
-  }, "teleport_probe_response", "teleport_probe");
-}
-function handleTeleportRequest(params) {
-  const { listener, command, connectionId } = params;
-  const pendingTeleports = getPendingTeleports(listener);
-  const existing = pendingTeleports.get(command.teleport_id);
-  if (existing) {
-    if (existing.readyAt !== undefined) {
-      sendTeleportReady(listener, existing, {
-        success: existing.error === undefined,
-        error: existing.error
-      });
-    }
-    return;
-  }
-  const pending = {
-    teleportId: command.teleport_id,
-    connectionId,
-    agentId: command.runtime.agent_id,
-    conversationId: command.runtime.conversation_id,
-    requestedAt: Date.now(),
-    drainAcceptedInputs: false,
-    activeTurn: false
-  };
-  const channelError = getLocalChannelTeleportError(pending);
-  if (channelError) {
-    pending.readyAt = Date.now();
-    pending.error = channelError;
-    pendingTeleports.set(pending.teleportId, pending);
-    sendTeleportReady(listener, pending, {
-      success: false,
-      error: channelError
-    });
-    retainTeleportForRecovery(listener, pending);
-    return;
-  }
-  const conflicting = findPendingTeleportForRuntime(listener, pending.agentId, pending.conversationId);
-  if (conflicting) {
-    pendingTeleports.set(pending.teleportId, pending);
-    pending.readyAt = Date.now();
-    pending.error = "Conversation already has a teleport pending";
-    sendTeleportReady(listener, pending, {
-      success: false,
-      error: pending.error
-    });
-    retainTeleportForRecovery(listener, pending);
-    return;
-  }
-  pendingTeleports.set(pending.teleportId, pending);
-  const conversationRuntime = getConversationRuntime(listener, pending.agentId, pending.conversationId);
-  pending.drainAcceptedInputs = conversationRuntime ? hasAcceptedInputsWaiting(conversationRuntime, true) : false;
-  if (!conversationRuntime?.isProcessing && !pending.drainAcceptedInputs) {
-    if (sendTeleportReady(listener, pending, { success: true })) {
-      pending.readyAt = Date.now();
-      retainTeleportForRecovery(listener, pending);
-    }
-  }
-}
-function claimPendingTeleportAtBoundary(params) {
-  const pending = findPendingTeleportForRuntime(params.listener, params.agentId, params.conversationId);
-  if (!pending)
-    return null;
-  if (pending.drainAcceptedInputs) {
-    if (params.activeTurn)
-      return null;
-    const runtime = getConversationRuntime(params.listener, params.agentId, params.conversationId);
-    if (runtime && hasAcceptedInputsWaiting(runtime, false))
-      return null;
-  }
-  const connection = params.listener.connections.get(pending.connectionId);
-  if (!connection || !isListenerTransportOpen(connection.writer))
-    return null;
-  pending.readyAt = Date.now();
-  pending.activeTurn = params.activeTurn;
-  pending.continuation = params.continuation;
-  return pending;
-}
-function emitClaimedTeleportReady(listener, pending) {
-  const sent = sendTeleportReady(listener, pending, { success: true });
-  if (sent) {
-    retainTeleportForRecovery(listener, pending);
-  }
-  return sent;
-}
-function finishTeleport(runtime, lease, pending) {
-  const transition = runtime.turnLifecycle.finish(lease, "cancelled");
-  if (!transition.finished)
-    return transition;
-  emitRuntimeStateUpdates(runtime, {
-    agent_id: pending.agentId,
-    conversation_id: pending.conversationId
-  });
-  emitClaimedTeleportReady(runtime.listener, pending);
-  return transition;
-}
-function finishPendingTeleport(runtime) {
-  if (!runtime.agentId)
-    return;
-  const pending = findPendingTeleportForRuntime(runtime.listener, runtime.agentId, runtime.conversationId);
-  if (!pending || runtime.lastStopReason !== "end_turn" && !pending.drainAcceptedInputs) {
-    return;
-  }
-  const claimed = claimPendingTeleportAtBoundary({
-    listener: runtime.listener,
-    agentId: runtime.agentId,
-    conversationId: runtime.conversationId,
-    activeTurn: false
-  });
-  if (claimed)
-    emitClaimedTeleportReady(runtime.listener, claimed);
-}
-function takeFailedTeleport(params) {
-  const pending = params.listener.pendingTeleports?.get(params.teleportId);
-  if (!pending || pending.agentId !== params.agentId || pending.conversationId !== params.conversationId) {
-    return null;
-  }
-  params.listener.pendingTeleports?.delete(params.teleportId);
-  return pending;
-}
-function handleTeleportFailure(params) {
-  const pending = takeFailedTeleport({
-    listener: params.listener,
-    teleportId: params.command.teleport_id,
-    agentId: params.command.runtime.agent_id,
-    conversationId: params.command.runtime.conversation_id
-  });
-  if (!pending || pending.error)
-    return;
-  const runtime = params.getOrCreateScopedRuntime(params.listener, pending.agentId, pending.conversationId);
-  emitLoopErrorNotice(params.socket, runtime, {
-    message: `Teleport failed: ${params.command.error}`,
-    stopReason: "error",
-    isTerminal: false,
-    agentId: pending.agentId,
-    conversationId: pending.conversationId
-  });
-  params.runDetachedListenerTask("teleport_failed", async () => {
-    await params.processIncomingMessage({
-      type: "message",
-      connectionId: pending.connectionId,
-      agentId: pending.agentId,
-      conversationId: pending.conversationId,
-      messages: buildTeleportFailureMessages({
-        teleportId: params.command.teleport_id,
-        error: params.command.error,
-        approvals: pending.continuation?.approvals
-      })
-    }, params.socket, runtime, params.onStatusChange, pending.connectionId);
-  });
-}
-var TELEPORT_RECOVERY_TTL_MS;
-var init_teleport = __esm(() => {
-  init_backend_mode();
-  init_teleport_guard();
-  init_connection();
-  init_permission_mode();
-  init_protocol_outbound();
-  init_recoverable_notices();
-  init_runtime();
-  init_transport();
-  TELEPORT_RECOVERY_TTL_MS = 5 * 60000;
-});
-
 // node_modules/diff/libesm/diff/base.js
 class Diff2 {
   diff(oldStr, newStr, options = {}) {
@@ -418806,6 +418839,7 @@ function createListenerMessageHandler(params) {
             currentTeleportId: teleportId
           });
           const scopedRuntime2 = getOrCreateScopedRuntime2(runtime, parsed.runtime.agent_id, parsed.runtime.conversation_id);
+          clearExpectedInboundTeleport(scopedRuntime2);
           const acceptedKey = `teleport:${teleportId}`;
           const previousDisposition = scopedRuntime2.acceptedInputDispositions.get(acceptedKey);
           if (previousDisposition) {
@@ -419453,7 +419487,7 @@ async function replaySyncStateForRuntime(listenerRuntime, socket, scope, opts) {
       }
     }
   }
-  if (syncScopedRuntime.recoveredApprovalState && syncScopedRuntime.recoveredApprovalState.pendingRequestIds.size === 0 && (syncScopedRuntime.recoveredApprovalState.autoDecisions?.length ?? 0) > 0) {
+  if (!isInboundTeleportExpected(syncScopedRuntime) && syncScopedRuntime.recoveredApprovalState && syncScopedRuntime.recoveredApprovalState.pendingRequestIds.size === 0 && (syncScopedRuntime.recoveredApprovalState.autoDecisions?.length ?? 0) > 0) {
     startRecoveredApprovalContinuation(syncScopedRuntime, getOrCreateProcessTransport(listenerRuntime), opts?.processIncomingMessage ?? handleIncomingMessage, {
       onStatusChange: opts?.onStatusChange,
       connectionId: opts?.connectionId,
@@ -419478,6 +419512,7 @@ var init_sync_replay = __esm(async () => {
   init_connection();
   init_connection_state_sync();
   init_recovery_sync();
+  init_teleport();
   await __promiseAll([
     init_conversation_runtime(),
     init_recovery(),
@@ -440813,7 +440848,7 @@ var init_mcp_client = __esm(() => {
   init_streamableHttp();
   DEFAULT_CLIENT_INFO = {
     name: "letta-code",
-    version: "0.32.6"
+    version: "0.32.7"
   };
 });
 
@@ -455161,9 +455196,6 @@ function shouldEnqueueCloudSend(values4, cloud, isAgentLaunch) {
 function validateSendOptions(values4) {
   if (values4.resume)
     throw new Error("--resume is interactive-only; use --conversation <id> in headless mode.");
-  const computer = values4.computer ?? values4.environment ?? values4.env;
-  if (computer !== undefined && !computer.trim())
-    throw new Error("Computer selector must not be empty.");
   if (values4["input-format"])
     throw new Error("Cloud message delivery does not support --input-format stream-json.");
   if (values4.new && values4.conversation)
@@ -455221,6 +455253,7 @@ async function tryCloudHeadlessSend(values4, prompt, backend3, isAgentLaunch, de
     if (!["text", "json", "stream-json"].includes(format5))
       throw new Error(`Invalid output format: ${format5}`);
     validateSendOptions(values4);
+    const computer = normalizeAgentMessageComputer(values4.computer ?? values4.environment ?? values4.env);
     const explicitSender = values4["from-agent"];
     const ambientSender = env5.AGENT_ID || env5.LETTA_AGENT_ID;
     const sender = {
@@ -455253,7 +455286,7 @@ async function tryCloudHeadlessSend(values4, prompt, backend3, isAgentLaunch, de
       conversationId,
       clientMessageId,
       content: buildAgentSendContent(sender, noWait, prompt),
-      computer: isCloudEnvironmentSelector(values4.computer ?? values4.environment ?? values4.env) ? "cloud" : values4.computer ?? values4.environment ?? values4.env
+      computer
     }, AbortSignal.any([controller.signal, AbortSignal.timeout(30000)]));
     clearTimeout(submissionTimeout);
     if (noWait) {
@@ -522119,4 +522152,4 @@ function registerBunOAuthFlows() {
 registerBunOAuthFlows();
 await init_src5().then(() => exports_src2);
 
-//# debugId=4B57A44583E7B14564756E2164756E21
+//# debugId=84C68A57BFAD43D964756E2164756E21