@letta-ai/letta-code 0.31.8 → 0.31.10

package/letta.js

@@ -3757,29 +3757,6 @@ var init_oauth = __esm(() => {
   };
 });
 
-// src/auth/oauth-refresh.ts
-async function refreshAccessTokenSingleFlight(refreshToken2, deviceId, deviceName, refresh = refreshAccessToken2) {
-  const refreshKey = `${refreshToken2}\x00${deviceId}`;
-  const existing = inFlightRefreshes.get(refreshKey);
-  if (existing) {
-    return await existing;
-  }
-  const pending = refresh(refreshToken2, deviceId, deviceName);
-  inFlightRefreshes.set(refreshKey, pending);
-  try {
-    return await pending;
-  } finally {
-    if (inFlightRefreshes.get(refreshKey) === pending) {
-      inFlightRefreshes.delete(refreshKey);
-    }
-  }
-}
-var inFlightRefreshes;
-var init_oauth_refresh = __esm(() => {
-  init_oauth();
-  inFlightRefreshes = new Map;
-});
-
 // src/agent/agent-id.ts
 function isLocalAgentId(agentId) {
   return agentId.startsWith("agent-local-");
@@ -5418,98 +5395,12 @@ var init_settings_manager = __esm(() => {
   settingsManager = globalThis.__lettaSettingsManager;
 });
 
-// src/utils/timing.ts
-function isTimingsEnabled() {
-  const val = process.env.LETTA_DEBUG_TIMINGS;
-  return val === "1" || val === "true";
-}
-function formatDuration(ms) {
-  if (ms < 1000)
-    return `${Math.round(ms)}ms`;
-  return `${(ms / 1000).toFixed(2)}s`;
-}
-function formatTimestamp(date) {
-  return date.toISOString().slice(11, 23);
-}
-function logTiming(message) {
-  if (isTimingsEnabled()) {
-    console.error(`[timing] ${message}`);
-  }
-}
-function markMilestone(name) {
-  const now = performance.now();
-  milestones.set(name, now);
-  if (firstMilestoneTime === null) {
-    firstMilestoneTime = now;
-  }
-  if (isTimingsEnabled()) {
-    const relative = now - firstMilestoneTime;
-    console.error(`[timing] MILESTONE ${name} at +${formatDuration(relative)} (${formatTimestamp(new Date)})`);
-  }
-}
-function measureSinceMilestone(label, fromMilestone) {
-  if (!isTimingsEnabled())
-    return;
-  const startTime = milestones.get(fromMilestone);
-  if (startTime === undefined) {
-    console.error(`[timing] WARNING: milestone "${fromMilestone}" not found for measurement "${label}"`);
-    return;
-  }
-  const duration = performance.now() - startTime;
-  console.error(`[timing] ${label}: ${formatDuration(duration)}`);
-}
-function reportAllMilestones() {
-  if (!isTimingsEnabled() || milestones.size === 0)
-    return;
-  const first = firstMilestoneTime ?? 0;
-  console.error(`[timing] ======== MILESTONE SUMMARY ========`);
-  const sorted = [...milestones.entries()].sort((a, b) => a[1] - b[1]);
-  let prevTime = first;
-  for (const [name, time] of sorted) {
-    const relativeToStart = time - first;
-    const delta = time - prevTime;
-    const deltaStr = prevTime === first ? "" : ` (+${formatDuration(delta)})`;
-    console.error(`[timing]   +${formatDuration(relativeToStart).padStart(8)} ${name}${deltaStr}`);
-    prevTime = time;
-  }
-  console.error(`[timing] =====================================`);
-}
-function createTimingFetch(baseFetch) {
-  return async (input, init) => {
-    const start = performance.now();
-    const startTime = formatTimestamp(new Date);
-    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
-    const method = init?.method || "GET";
-    let path2;
-    try {
-      path2 = new URL(url).pathname;
-    } catch {
-      path2 = url;
-    }
-    logTiming(`${method} ${path2} started at ${startTime}`);
-    try {
-      const response = await baseFetch(input, init);
-      const duration = performance.now() - start;
-      logTiming(`${method} ${path2} -> ${formatDuration(duration)} (status: ${response.status})`);
-      return response;
-    } catch (error) {
-      const duration = performance.now() - start;
-      logTiming(`${method} ${path2} -> FAILED after ${formatDuration(duration)}`);
-      throw error;
-    }
-  };
-}
-var milestones, firstMilestoneTime = null;
-var init_timing = __esm(() => {
-  milestones = new Map;
-});
-
 // package.json
 var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.31.8",
+    version: "0.31.10",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     packageManager: "bun@1.3.10",
@@ -5753,266 +5644,6 @@ var init_package = __esm(() => {
   };
 });
 
-// src/backend/api/memfs-git-proxy.ts
-var exports_memfs_git_proxy = {};
-__export(exports_memfs_git_proxy, {
-  getMemfsServerUrl: () => getMemfsServerUrl,
-  getMemfsGitProxyRewriteConfig: () => getMemfsGitProxyRewriteConfig,
-  LETTA_MEMFS_GIT_PROXY_BASE_URL_ENV: () => LETTA_MEMFS_GIT_PROXY_BASE_URL_ENV
-});
-function isLocalhostUrl(value) {
-  if (!value)
-    return false;
-  try {
-    const parsed = new URL(value);
-    return ["localhost", "127.0.0.1", "::1", "[::1]"].includes(parsed.hostname);
-  } catch {
-    return false;
-  }
-}
-function trimBaseUrl(value) {
-  return value.trim().replace(/\/+$/, "");
-}
-function getMemfsServerUrl() {
-  let settings = null;
-  try {
-    settings = settingsManager.getSettings();
-  } catch {}
-  const configuredMemfsUrl = process.env.LETTA_MEMFS_BASE_URL || settings?.env?.LETTA_MEMFS_BASE_URL;
-  if (configuredMemfsUrl) {
-    return configuredMemfsUrl;
-  }
-  return LETTA_CLOUD_API_URL;
-}
-function getMemfsGitProxyRewriteConfig(env = process.env) {
-  const rawProxyBaseUrl = env[LETTA_MEMFS_GIT_PROXY_BASE_URL_ENV]?.trim();
-  if (!rawProxyBaseUrl || !isLocalhostUrl(rawProxyBaseUrl)) {
-    return null;
-  }
-  const memfsBaseUrl = trimBaseUrl(getMemfsServerUrl());
-  if (!memfsBaseUrl.includes("api.letta.com")) {
-    return null;
-  }
-  const proxyBaseUrl = trimBaseUrl(rawProxyBaseUrl);
-  const proxyPrefix = `${proxyBaseUrl}/v1/git/`;
-  const memfsPrefix = `${memfsBaseUrl}/v1/git/`;
-  return {
-    proxyBaseUrl,
-    memfsBaseUrl,
-    proxyPrefix,
-    memfsPrefix,
-    configKey: `url.${proxyPrefix}.insteadOf`,
-    configValue: memfsPrefix
-  };
-}
-var LETTA_MEMFS_GIT_PROXY_BASE_URL_ENV = "LETTA_MEMFS_GIT_PROXY_BASE_URL";
-var init_memfs_git_proxy = __esm(() => {
-  init_oauth();
-  init_settings_manager();
-});
-
-// src/backend/api/client.ts
-var exports_client = {};
-__export(exports_client, {
-  getServerUrl: () => getServerUrl,
-  getRuntimeEnvironmentDeviceId: () => getRuntimeEnvironmentDeviceId,
-  getMemfsServerUrl: () => getMemfsServerUrl,
-  getMemfsGitProxyRewriteConfig: () => getMemfsGitProxyRewriteConfig,
-  getClientDefaultHeaders: () => getClientDefaultHeaders,
-  getClient: () => getClient,
-  consumeLastSDKDiagnostic: () => consumeLastSDKDiagnostic,
-  clearLastSDKDiagnostic: () => clearLastSDKDiagnostic,
-  __testOverrideGetClient: () => __testOverrideGetClient,
-  LETTA_MEMFS_GIT_PROXY_BASE_URL_ENV: () => LETTA_MEMFS_GIT_PROXY_BASE_URL_ENV
-});
-import { hostname } from "node:os";
-function __testOverrideGetClient(factory) {
-  _testClientOverride = factory;
-}
-function safeDiagnosticString(value) {
-  if (value === null || value === undefined) {
-    return "";
-  }
-  if (typeof value === "string") {
-    return value;
-  }
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return String(value);
-  }
-}
-function truncateDiagnostic(value) {
-  const text = safeDiagnosticString(value);
-  if (text.length <= SDK_DIAGNOSTIC_MAX_LEN) {
-    return text;
-  }
-  return `${text.slice(0, SDK_DIAGNOSTIC_MAX_LEN)}...[truncated, was ${text.length}b]`;
-}
-function captureSDKErrorDiagnostic(args) {
-  const diagnosticLine = truncateDiagnostic(args.map((arg) => safeDiagnosticString(arg)).join(" "));
-  const previous = lastSDKDiagnostic ?? { lines: [] };
-  lastSDKDiagnostic = {
-    lines: [...previous.lines, diagnosticLine].slice(-SDK_DIAGNOSTIC_MAX_LINES)
-  };
-}
-function consumeLastSDKDiagnostic() {
-  const diag = lastSDKDiagnostic;
-  lastSDKDiagnostic = null;
-  if (!diag || diag.lines.length === 0) {
-    return null;
-  }
-  return `sdk_error=${diag.lines.join(" || ")}`;
-}
-function clearLastSDKDiagnostic() {
-  lastSDKDiagnostic = null;
-}
-function getServerUrl() {
-  const settings = settingsManager.getSettings();
-  return process.env.LETTA_BASE_URL || settings.env?.LETTA_BASE_URL || LETTA_CLOUD_API_URL;
-}
-function getNodeRoutingHeader() {
-  const raw = process.env.LETTA_NODE;
-  if (raw === undefined || raw.trim() === "") {
-    return {};
-  }
-  const enabled = NODE_HEADER_ENABLED_VALUES.has(raw.trim().toLowerCase());
-  return { "x-letta-node": enabled ? "1" : "0" };
-}
-function getRuntimeEnvironmentDeviceId() {
-  return process.env[RUNTIME_ENVIRONMENT_DEVICE_ID_ENV]?.trim() || settingsManager.getOrCreateDeviceId();
-}
-function getClientDefaultHeaders() {
-  return {
-    "X-Letta-Source": "letta-code",
-    "User-Agent": `letta-code/${package_default.version}`,
-    "X-Letta-Environment-Device-Id": getRuntimeEnvironmentDeviceId(),
-    ...getNodeRoutingHeader(),
-    ...process.env.LETTA_MEMFS_BACKEND === "hosted" ? { "x-letta-memfs-backend": "hosted" } : {}
-  };
-}
-async function getClient() {
-  if (_testClientOverride) {
-    return await _testClientOverride();
-  }
-  const baseSettings = settingsManager.getSettings();
-  const cachedTokens = settingsManager.getCachedSecureTokens();
-  const cachedSettings = {
-    ...baseSettings,
-    env: {
-      ...baseSettings.env,
-      ...cachedTokens.apiKey && { LETTA_API_KEY: cachedTokens.apiKey }
-    },
-    refreshToken: cachedTokens.refreshToken ?? baseSettings.refreshToken
-  };
-  const settings = process.env.LETTA_API_KEY || cachedSettings.env?.LETTA_API_KEY || cachedSettings.refreshToken ? cachedSettings : await settingsManager.getSettingsWithSecureTokens();
-  let apiKey = process.env.LETTA_API_KEY || settings.env?.LETTA_API_KEY;
-  if (!process.env.LETTA_API_KEY) {
-    if (apiKey) {
-      _cachedApiKey = apiKey;
-    } else if (_cachedApiKey) {
-      apiKey = _cachedApiKey;
-    }
-  }
-  if (!process.env.LETTA_API_KEY && settings.tokenExpiresAt && settings.refreshToken) {
-    const now = Date.now();
-    const expiresAt = settings.tokenExpiresAt;
-    if (!apiKey || expiresAt - now < 5 * 60 * 1000) {
-      try {
-        const deviceId = settingsManager.getOrCreateDeviceId();
-        const deviceName = hostname();
-        const tokens = await refreshAccessTokenSingleFlight(settings.refreshToken, deviceId, deviceName);
-        settingsManager.updateSettings({
-          env: { LETTA_API_KEY: tokens.access_token },
-          refreshToken: tokens.refresh_token || settings.refreshToken,
-          tokenExpiresAt: now + tokens.expires_in * 1000
-        });
-        apiKey = tokens.access_token;
-        _cachedApiKey = tokens.access_token;
-      } catch (error) {
-        trackBoundaryError({
-          errorType: "auth_token_refresh_failed",
-          error,
-          context: "auth_client_token_refresh"
-        });
-        console.error("Failed to refresh access token:", error);
-        console.error(`
-If you experience this issue multiple times, move ~/.letta to ~/.letta_backup, and re-run 'letta' to re-authenticate`);
-        throw new Error(`Failed to refresh access token: ${error instanceof Error ? error.message : String(error)}`);
-      }
-    }
-  }
-  const baseURL = process.env.LETTA_BASE_URL || settings.env?.LETTA_BASE_URL || LETTA_CLOUD_API_URL;
-  if (!apiKey && baseURL === LETTA_CLOUD_API_URL) {
-    console.error("Missing LETTA_API_KEY");
-    console.error("Run 'letta' to configure authentication, or set LETTA_API_KEY to your API key");
-    console.error(new Error("getClient() called without credentials").stack);
-    throw new Error("Missing LETTA_API_KEY. Run 'letta' to configure authentication, or set LETTA_API_KEY to your API key.");
-  }
-  const client = new Letta({
-    apiKey,
-    baseURL,
-    logger: sdkLogger,
-    timeout: Number(process.env.LETTA_REQUEST_TIMEOUT_MS) || 10 * 60 * 1000,
-    defaultHeaders: getClientDefaultHeaders(),
-    ...isTimingsEnabled() && { fetch: createTimingFetch(fetch) }
-  });
-  const MESSAGE_CACHE_MAX = 32;
-  const messageCache = new Map;
-  const origRetrieveMessage = client.messages.retrieve.bind(client.messages);
-  client.messages.retrieve = (...args) => {
-    const messageId = args[0];
-    const cached = messageCache.get(messageId);
-    if (cached) {
-      messageCache.delete(messageId);
-      messageCache.set(messageId, cached);
-      return cached;
-    }
-    const promise = origRetrieveMessage(...args);
-    messageCache.set(messageId, promise);
-    if (messageCache.size > MESSAGE_CACHE_MAX) {
-      const oldest = messageCache.keys().next().value;
-      if (oldest !== undefined)
-        messageCache.delete(oldest);
-    }
-    promise.catch(() => messageCache.delete(messageId));
-    return promise;
-  };
-  return client;
-}
-var SDK_DIAGNOSTIC_MAX_LEN = 400, SDK_DIAGNOSTIC_MAX_LINES = 4, lastSDKDiagnostic = null, _cachedApiKey, _testClientOverride = null, sdkLogger, NODE_HEADER_ENABLED_VALUES, RUNTIME_ENVIRONMENT_DEVICE_ID_ENV = "LETTA_RUNTIME_ENVIRONMENT_DEVICE_ID";
-var init_client2 = __esm(() => {
-  init_letta_client();
-  init_oauth();
-  init_oauth_refresh();
-  init_settings_manager();
-  init_error_reporting();
-  init_debug();
-  init_timing();
-  init_package();
-  init_memfs_git_proxy();
-  sdkLogger = {
-    error: (...args) => {
-      try {
-        captureSDKErrorDiagnostic(args);
-      } catch {}
-      if (isDebugEnabled()) {
-        console.error(...args);
-      }
-    },
-    warn: (...args) => {
-      console.warn(...args);
-    },
-    info: (...args) => {
-      console.info(...args);
-    },
-    debug: (...args) => {
-      console.debug(...args);
-    }
-  };
-  NODE_HEADER_ENABLED_VALUES = new Set(["1", "true", "yes"]);
-});
-
 // src/backend/api/http-headers.ts
 function getLettaCodeHeaders(apiKey) {
   return {
@@ -6140,8 +5771,8 @@ function parseUrl(value, options = {}) {
     return null;
   }
 }
-function isLoopbackHostname(hostname2) {
-  const normalized = hostname2.toLowerCase();
+function isLoopbackHostname(hostname) {
+  const normalized = hostname.toLowerCase();
   return normalized === "localhost" || normalized === "0.0.0.0" || normalized === "::1" || normalized === "[::1]" || normalized.startsWith("127.");
 }
 function isLoopbackUrl(value, options = {}) {
@@ -6198,6 +5829,38 @@ var init_metadata = __esm(() => {
   init_request();
 });
 
+// src/backend/api/server-url.ts
+var exports_server_url = {};
+__export(exports_server_url, {
+  isCloudServerUrl: () => isCloudServerUrl,
+  getServerUrl: () => getServerUrl
+});
+function getServerUrl() {
+  const settings = settingsManager.getSettings();
+  return process.env.LETTA_BASE_URL || settings.env?.LETTA_BASE_URL || LETTA_CLOUD_API_URL;
+}
+function isCloudServerUrl(serverUrl) {
+  let resolved = serverUrl;
+  if (resolved === undefined) {
+    try {
+      resolved = getServerUrl();
+    } catch {
+      resolved = process.env.LETTA_BASE_URL || LETTA_CLOUD_API_URL;
+    }
+  }
+  try {
+    const parsed = new URL(resolved);
+    const cloud = new URL(LETTA_CLOUD_API_URL);
+    return parsed.hostname === cloud.hostname;
+  } catch {
+    return false;
+  }
+}
+var init_server_url = __esm(() => {
+  init_oauth();
+  init_settings_manager();
+});
+
 // src/version.ts
 var exports_version = {};
 __export(exports_version, {
@@ -6725,9 +6388,9 @@ class TelemetryManager {
 var telemetry;
 var init_telemetry = __esm(() => {
   init_oauth();
-  init_client2();
   init_health();
   init_metadata();
+  init_server_url();
   init_paths();
   init_settings_manager();
   init_debug();
@@ -6776,6 +6439,370 @@ function buildCreatedAgentTags(options = {}) {
 }
 var LETTA_CODE_ORIGIN_TAG = "origin:letta-code", ONBOARDING_ORIGIN_TAG = "origin:onboarding", LETTA_CODE_SUBAGENT_TAG = "role:subagent", GIT_MEMORY_ENABLED_TAG = "git-memory-enabled";
 
+// src/auth/oauth-refresh.ts
+async function refreshAccessTokenSingleFlight(refreshToken2, deviceId, deviceName, refresh = refreshAccessToken2) {
+  const refreshKey = `${refreshToken2}\x00${deviceId}`;
+  const existing = inFlightRefreshes.get(refreshKey);
+  if (existing) {
+    return await existing;
+  }
+  const pending = refresh(refreshToken2, deviceId, deviceName);
+  inFlightRefreshes.set(refreshKey, pending);
+  try {
+    return await pending;
+  } finally {
+    if (inFlightRefreshes.get(refreshKey) === pending) {
+      inFlightRefreshes.delete(refreshKey);
+    }
+  }
+}
+var inFlightRefreshes;
+var init_oauth_refresh = __esm(() => {
+  init_oauth();
+  inFlightRefreshes = new Map;
+});
+
+// src/utils/timing.ts
+function isTimingsEnabled() {
+  const val = process.env.LETTA_DEBUG_TIMINGS;
+  return val === "1" || val === "true";
+}
+function formatDuration(ms) {
+  if (ms < 1000)
+    return `${Math.round(ms)}ms`;
+  return `${(ms / 1000).toFixed(2)}s`;
+}
+function formatTimestamp(date) {
+  return date.toISOString().slice(11, 23);
+}
+function logTiming(message) {
+  if (isTimingsEnabled()) {
+    console.error(`[timing] ${message}`);
+  }
+}
+function markMilestone(name) {
+  const now = performance.now();
+  milestones.set(name, now);
+  if (firstMilestoneTime === null) {
+    firstMilestoneTime = now;
+  }
+  if (isTimingsEnabled()) {
+    const relative = now - firstMilestoneTime;
+    console.error(`[timing] MILESTONE ${name} at +${formatDuration(relative)} (${formatTimestamp(new Date)})`);
+  }
+}
+function measureSinceMilestone(label, fromMilestone) {
+  if (!isTimingsEnabled())
+    return;
+  const startTime = milestones.get(fromMilestone);
+  if (startTime === undefined) {
+    console.error(`[timing] WARNING: milestone "${fromMilestone}" not found for measurement "${label}"`);
+    return;
+  }
+  const duration = performance.now() - startTime;
+  console.error(`[timing] ${label}: ${formatDuration(duration)}`);
+}
+function reportAllMilestones() {
+  if (!isTimingsEnabled() || milestones.size === 0)
+    return;
+  const first = firstMilestoneTime ?? 0;
+  console.error(`[timing] ======== MILESTONE SUMMARY ========`);
+  const sorted = [...milestones.entries()].sort((a, b) => a[1] - b[1]);
+  let prevTime = first;
+  for (const [name, time] of sorted) {
+    const relativeToStart = time - first;
+    const delta = time - prevTime;
+    const deltaStr = prevTime === first ? "" : ` (+${formatDuration(delta)})`;
+    console.error(`[timing]   +${formatDuration(relativeToStart).padStart(8)} ${name}${deltaStr}`);
+    prevTime = time;
+  }
+  console.error(`[timing] =====================================`);
+}
+function createTimingFetch(baseFetch) {
+  return async (input, init) => {
+    const start = performance.now();
+    const startTime = formatTimestamp(new Date);
+    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    const method = init?.method || "GET";
+    let path2;
+    try {
+      path2 = new URL(url).pathname;
+    } catch {
+      path2 = url;
+    }
+    logTiming(`${method} ${path2} started at ${startTime}`);
+    try {
+      const response = await baseFetch(input, init);
+      const duration = performance.now() - start;
+      logTiming(`${method} ${path2} -> ${formatDuration(duration)} (status: ${response.status})`);
+      return response;
+    } catch (error) {
+      const duration = performance.now() - start;
+      logTiming(`${method} ${path2} -> FAILED after ${formatDuration(duration)}`);
+      throw error;
+    }
+  };
+}
+var milestones, firstMilestoneTime = null;
+var init_timing = __esm(() => {
+  milestones = new Map;
+});
+
+// src/backend/api/memfs-git-proxy.ts
+var exports_memfs_git_proxy = {};
+__export(exports_memfs_git_proxy, {
+  getMemfsServerUrl: () => getMemfsServerUrl,
+  getMemfsGitProxyRewriteConfig: () => getMemfsGitProxyRewriteConfig,
+  LETTA_MEMFS_GIT_PROXY_BASE_URL_ENV: () => LETTA_MEMFS_GIT_PROXY_BASE_URL_ENV
+});
+function isLocalhostUrl(value) {
+  if (!value)
+    return false;
+  try {
+    const parsed = new URL(value);
+    return ["localhost", "127.0.0.1", "::1", "[::1]"].includes(parsed.hostname);
+  } catch {
+    return false;
+  }
+}
+function trimBaseUrl(value) {
+  return value.trim().replace(/\/+$/, "");
+}
+function getMemfsServerUrl() {
+  let settings = null;
+  try {
+    settings = settingsManager.getSettings();
+  } catch {}
+  const configuredMemfsUrl = process.env.LETTA_MEMFS_BASE_URL || settings?.env?.LETTA_MEMFS_BASE_URL;
+  if (configuredMemfsUrl) {
+    return configuredMemfsUrl;
+  }
+  return LETTA_CLOUD_API_URL;
+}
+function getMemfsGitProxyRewriteConfig(env = process.env) {
+  const rawProxyBaseUrl = env[LETTA_MEMFS_GIT_PROXY_BASE_URL_ENV]?.trim();
+  if (!rawProxyBaseUrl || !isLocalhostUrl(rawProxyBaseUrl)) {
+    return null;
+  }
+  const memfsBaseUrl = trimBaseUrl(getMemfsServerUrl());
+  if (!memfsBaseUrl.includes("api.letta.com")) {
+    return null;
+  }
+  const proxyBaseUrl = trimBaseUrl(rawProxyBaseUrl);
+  const proxyPrefix = `${proxyBaseUrl}/v1/git/`;
+  const memfsPrefix = `${memfsBaseUrl}/v1/git/`;
+  return {
+    proxyBaseUrl,
+    memfsBaseUrl,
+    proxyPrefix,
+    memfsPrefix,
+    configKey: `url.${proxyPrefix}.insteadOf`,
+    configValue: memfsPrefix
+  };
+}
+var LETTA_MEMFS_GIT_PROXY_BASE_URL_ENV = "LETTA_MEMFS_GIT_PROXY_BASE_URL";
+var init_memfs_git_proxy = __esm(() => {
+  init_oauth();
+  init_settings_manager();
+});
+
+// src/backend/api/client.ts
+var exports_client = {};
+__export(exports_client, {
+  getRuntimeEnvironmentDeviceId: () => getRuntimeEnvironmentDeviceId,
+  getMemfsServerUrl: () => getMemfsServerUrl,
+  getMemfsGitProxyRewriteConfig: () => getMemfsGitProxyRewriteConfig,
+  getClientDefaultHeaders: () => getClientDefaultHeaders,
+  getClient: () => getClient,
+  consumeLastSDKDiagnostic: () => consumeLastSDKDiagnostic,
+  clearLastSDKDiagnostic: () => clearLastSDKDiagnostic,
+  __testOverrideGetClient: () => __testOverrideGetClient,
+  LETTA_MEMFS_GIT_PROXY_BASE_URL_ENV: () => LETTA_MEMFS_GIT_PROXY_BASE_URL_ENV
+});
+import { hostname } from "node:os";
+function __testOverrideGetClient(factory) {
+  _testClientOverride = factory;
+}
+function safeDiagnosticString(value) {
+  if (value === null || value === undefined) {
+    return "";
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function truncateDiagnostic(value) {
+  const text = safeDiagnosticString(value);
+  if (text.length <= SDK_DIAGNOSTIC_MAX_LEN) {
+    return text;
+  }
+  return `${text.slice(0, SDK_DIAGNOSTIC_MAX_LEN)}...[truncated, was ${text.length}b]`;
+}
+function captureSDKErrorDiagnostic(args) {
+  const diagnosticLine = truncateDiagnostic(args.map((arg) => safeDiagnosticString(arg)).join(" "));
+  const previous = lastSDKDiagnostic ?? { lines: [] };
+  lastSDKDiagnostic = {
+    lines: [...previous.lines, diagnosticLine].slice(-SDK_DIAGNOSTIC_MAX_LINES)
+  };
+}
+function consumeLastSDKDiagnostic() {
+  const diag = lastSDKDiagnostic;
+  lastSDKDiagnostic = null;
+  if (!diag || diag.lines.length === 0) {
+    return null;
+  }
+  return `sdk_error=${diag.lines.join(" || ")}`;
+}
+function clearLastSDKDiagnostic() {
+  lastSDKDiagnostic = null;
+}
+function getNodeRoutingHeader() {
+  const raw = process.env.LETTA_NODE;
+  if (raw === undefined || raw.trim() === "") {
+    return {};
+  }
+  const enabled = NODE_HEADER_ENABLED_VALUES.has(raw.trim().toLowerCase());
+  return { "x-letta-node": enabled ? "1" : "0" };
+}
+function getRuntimeEnvironmentDeviceId() {
+  return process.env[RUNTIME_ENVIRONMENT_DEVICE_ID_ENV]?.trim() || settingsManager.getOrCreateDeviceId();
+}
+function getClientDefaultHeaders() {
+  return {
+    "X-Letta-Source": "letta-code",
+    "User-Agent": `letta-code/${package_default.version}`,
+    "X-Letta-Environment-Device-Id": getRuntimeEnvironmentDeviceId(),
+    ...getNodeRoutingHeader(),
+    ...process.env.LETTA_MEMFS_BACKEND === "hosted" ? { "x-letta-memfs-backend": "hosted" } : {}
+  };
+}
+async function getClient() {
+  if (_testClientOverride) {
+    return await _testClientOverride();
+  }
+  const baseSettings = settingsManager.getSettings();
+  const cachedTokens = settingsManager.getCachedSecureTokens();
+  const cachedSettings = {
+    ...baseSettings,
+    env: {
+      ...baseSettings.env,
+      ...cachedTokens.apiKey && { LETTA_API_KEY: cachedTokens.apiKey }
+    },
+    refreshToken: cachedTokens.refreshToken ?? baseSettings.refreshToken
+  };
+  const settings = process.env.LETTA_API_KEY || cachedSettings.env?.LETTA_API_KEY || cachedSettings.refreshToken ? cachedSettings : await settingsManager.getSettingsWithSecureTokens();
+  let apiKey = process.env.LETTA_API_KEY || settings.env?.LETTA_API_KEY;
+  if (!process.env.LETTA_API_KEY) {
+    if (apiKey) {
+      _cachedApiKey = apiKey;
+    } else if (_cachedApiKey) {
+      apiKey = _cachedApiKey;
+    }
+  }
+  if (!process.env.LETTA_API_KEY && settings.tokenExpiresAt && settings.refreshToken) {
+    const now = Date.now();
+    const expiresAt = settings.tokenExpiresAt;
+    if (!apiKey || expiresAt - now < 5 * 60 * 1000) {
+      try {
+        const deviceId = settingsManager.getOrCreateDeviceId();
+        const deviceName = hostname();
+        const tokens = await refreshAccessTokenSingleFlight(settings.refreshToken, deviceId, deviceName);
+        settingsManager.updateSettings({
+          env: { LETTA_API_KEY: tokens.access_token },
+          refreshToken: tokens.refresh_token || settings.refreshToken,
+          tokenExpiresAt: now + tokens.expires_in * 1000
+        });
+        apiKey = tokens.access_token;
+        _cachedApiKey = tokens.access_token;
+      } catch (error) {
+        trackBoundaryError({
+          errorType: "auth_token_refresh_failed",
+          error,
+          context: "auth_client_token_refresh"
+        });
+        console.error("Failed to refresh access token:", error);
+        console.error(`
+If you experience this issue multiple times, move ~/.letta to ~/.letta_backup, and re-run 'letta' to re-authenticate`);
+        throw new Error(`Failed to refresh access token: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  }
+  const baseURL = process.env.LETTA_BASE_URL || settings.env?.LETTA_BASE_URL || LETTA_CLOUD_API_URL;
+  if (!apiKey && baseURL === LETTA_CLOUD_API_URL) {
+    console.error("Missing LETTA_API_KEY");
+    console.error("Run 'letta' to configure authentication, or set LETTA_API_KEY to your API key");
+    console.error(new Error("getClient() called without credentials").stack);
+    throw new Error("Missing LETTA_API_KEY. Run 'letta' to configure authentication, or set LETTA_API_KEY to your API key.");
+  }
+  const client = new Letta({
+    apiKey,
+    baseURL,
+    logger: sdkLogger,
+    timeout: Number(process.env.LETTA_REQUEST_TIMEOUT_MS) || 10 * 60 * 1000,
+    defaultHeaders: getClientDefaultHeaders(),
+    ...isTimingsEnabled() && { fetch: createTimingFetch(fetch) }
+  });
+  const MESSAGE_CACHE_MAX = 32;
+  const messageCache = new Map;
+  const origRetrieveMessage = client.messages.retrieve.bind(client.messages);
+  client.messages.retrieve = (...args) => {
+    const messageId = args[0];
+    const cached = messageCache.get(messageId);
+    if (cached) {
+      messageCache.delete(messageId);
+      messageCache.set(messageId, cached);
+      return cached;
+    }
+    const promise = origRetrieveMessage(...args);
+    messageCache.set(messageId, promise);
+    if (messageCache.size > MESSAGE_CACHE_MAX) {
+      const oldest = messageCache.keys().next().value;
+      if (oldest !== undefined)
+        messageCache.delete(oldest);
+    }
+    promise.catch(() => messageCache.delete(messageId));
+    return promise;
+  };
+  return client;
+}
+var SDK_DIAGNOSTIC_MAX_LEN = 400, SDK_DIAGNOSTIC_MAX_LINES = 4, lastSDKDiagnostic = null, _cachedApiKey, _testClientOverride = null, sdkLogger, NODE_HEADER_ENABLED_VALUES, RUNTIME_ENVIRONMENT_DEVICE_ID_ENV = "LETTA_RUNTIME_ENVIRONMENT_DEVICE_ID";
+var init_client2 = __esm(() => {
+  init_letta_client();
+  init_oauth();
+  init_oauth_refresh();
+  init_settings_manager();
+  init_error_reporting();
+  init_debug();
+  init_timing();
+  init_package();
+  init_memfs_git_proxy();
+  sdkLogger = {
+    error: (...args) => {
+      try {
+        captureSDKErrorDiagnostic(args);
+      } catch {}
+      if (isDebugEnabled()) {
+        console.error(...args);
+      }
+    },
+    warn: (...args) => {
+      console.warn(...args);
+    },
+    info: (...args) => {
+      console.info(...args);
+    },
+    debug: (...args) => {
+      console.debug(...args);
+    }
+  };
+  NODE_HEADER_ENABLED_VALUES = new Set(["1", "true", "yes"]);
+});
+
 // src/utils/text-files.ts
 import { readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
 function getUtf16Bom(bytes) {
@@ -88170,6 +88197,30 @@ var init_tool_return_clamp = __esm(() => {
   init_truncation();
 });
 
+// src/tools/task-tool-assets.ts
+function stripComputerFromTaskSchema(schema5) {
+  const properties4 = schema5.properties;
+  if (!properties4 || !Object.hasOwn(properties4, "computer")) {
+    return schema5;
+  }
+  const { computer: _computer, ...rest3 } = properties4;
+  return { ...schema5, properties: rest3 };
+}
+function stripComputerFromTaskDescription(description) {
+  const start = description.indexOf(COMPUTER_SECTION_HEADING);
+  if (start === -1) {
+    return description;
+  }
+  const afterHeading = start + COMPUTER_SECTION_HEADING.length;
+  const next = description.indexOf(`
+## `, afterHeading);
+  const removed = next === -1 ? description.slice(0, start) : description.slice(0, start) + description.slice(next + 1);
+  return removed.replace(/\n{3,}/g, `
+
+`).trimEnd();
+}
+var COMPUTER_SECTION_HEADING = "## Running on Another Computer";
+
 // src/tools/define-tool.ts
 function defineTool(input) {
   return {
@@ -89144,6 +89195,37 @@ Agent({ subagent_type: "fork", description: "Implement component B", prompt: "..
 
 Note: \`fork\` cannot be combined with \`agent_id\` or \`conversation_id\`.
 
+## Running on Another Computer
+
+Pass \`computer\` to run the subagent's turn on another connected computer instead of this machine. Works with any subagent type. The call fails fast if the named device is offline, ambiguous, or too old to support routing.
+
+\`computer: "cloud"\` provisions a Cloud sandbox for the subagent's conversation and runs the turn there. Sandboxes are per-conversation: this is a separate machine from wherever you are running now, even if you are already in a Cloud sandbox.
+
+Omit \`computer\` to run the subagent on the current machine. That is the default and the right choice for almost all tasks — the subagent shares your working directory and files. Only set \`computer\` when the task specifically needs another machine (its files, its OS, or an isolated sandbox).
+
+\`\`\`typescript
+// Fork this conversation and run the work on a connected computer
+Agent({
+  subagent_type: "fork",
+  computer: "office-mac",
+  description: "Run integration tests",
+  prompt: "Run the integration suite in the checkout on this machine and report failures."
+})
+
+// Deploy an existing agent into a fresh Cloud sandbox
+Agent({
+  agent_id: "agent-abc123",
+  computer: "cloud",
+  description: "Build release artifacts",
+  prompt: "Build and upload the release artifacts."
+})
+\`\`\`
+
+Behavior notes:
+- The remote turn runs with the remote machine's working directory, tools, and skills. Subagent-type tool restrictions (e.g. recall's read-only toolset) travel with the turn on current servers; older servers ignore them.
+- The remote turn's final assistant message is returned as the task result. Token and step statistics are not available for remote runs.
+- The wait tracks turn liveness (new messages, run activity, device online) with an absolute one-hour ceiling rather than a fixed timeout.
+
 ## Concurrency and Safety:
 
 - **Safe**: Multiple read-only agents (e.g. recall, history-analyzer) running in parallel
@@ -93630,7 +93712,7 @@ var LETTA_BIN_ARGS_ENV = "LETTA_CODE_BIN_ARGS_JSON", SHELL_SHIM_DIR_NAME = "lett
 var init_shell_env = __esm(() => {
   init_context();
   init_memory_filesystem2();
-  init_client2();
+  init_server_url();
   init_paths();
   init_runtime_context();
   init_settings_manager();
@@ -114705,6 +114787,9 @@ function buildSubagentArgs(type3, config, model, userPrompt, existingAgentId, ex
   if (options.backendMode) {
     args.push("--backend", options.backendMode);
   }
+  if (options.environment) {
+    args.push("--environment", options.environment);
+  }
   if (isDeployingExisting) {
     if (existingConversationId) {
       args.push("--conv", existingConversationId);
@@ -114765,7 +114850,7 @@ function buildSubagentArgs(type3, config, model, userPrompt, existingAgentId, ex
   }
   return args;
 }
-async function executeSubagent(type3, config, model, userPrompt, subagentId, isRetry = false, signal, existingAgentId, existingConversationId, maxTurns, parentAgentIdOverride, transcriptPath, memoryScope, systemPromptOverride) {
+async function executeSubagent(type3, config, model, userPrompt, subagentId, isRetry = false, signal, existingAgentId, existingConversationId, maxTurns, parentAgentIdOverride, transcriptPath, memoryScope, systemPromptOverride, environment2) {
   const withModel = (result) => model ? { ...result, model } : result;
   if (signal?.aborted) {
     return withModel({
@@ -114792,7 +114877,8 @@ async function executeSubagent(type3, config, model, userPrompt, subagentId, isR
       backendMode,
       promptTransport: "stdin",
       parentAgentId,
-      systemPromptOverride
+      systemPromptOverride,
+      environment: environment2
     });
     const launcher = resolveSubagentLauncher(cliArgs);
     const settings3 = await settingsManager.getSettingsWithSecureTokens();
@@ -114913,12 +114999,12 @@ async function executeSubagent(type3, config, model, userPrompt, subagentId, isR
           agentId: parentAgentIdOverride
         });
         if (primaryModel) {
-          return executeSubagent(type3, config, primaryModel, userPrompt, subagentId, true, signal, undefined, undefined, maxTurns, parentAgentIdOverride, transcriptPath);
+          return executeSubagent(type3, config, primaryModel, userPrompt, subagentId, true, signal, undefined, undefined, maxTurns, parentAgentIdOverride, transcriptPath, undefined, undefined, environment2);
         }
       }
       if (!isRetry && isSubagentStdoutLostError(stderr)) {
         debugWarn("subagent", `Subagent ${subagentId} lost stdout before its result envelope; retrying once`);
-        return executeSubagent(type3, config, model, userPrompt, subagentId, true, signal, existingAgentId, existingConversationId, maxTurns, parentAgentIdOverride, transcriptPath, memoryScope, systemPromptOverride);
+        return executeSubagent(type3, config, model, userPrompt, subagentId, true, signal, existingAgentId, existingConversationId, maxTurns, parentAgentIdOverride, transcriptPath, memoryScope, systemPromptOverride, environment2);
       }
       const propagatedError = state.finalError?.trim();
       const fallbackError = stderr || `Subagent exited with code ${exitCode}`;
@@ -114963,7 +115049,7 @@ async function executeSubagent(type3, config, model, userPrompt, subagentId, isR
       debugWarn("subagent", `parseResultFromStdout failed for ${subagentId}: ${result.error}. ` + `stdout first 500 chars: ${stdout.slice(0, 500)}`);
       if (!isRetry && looksLikeTruncatedStreamJson(stdout)) {
         debugWarn("subagent", `Subagent ${subagentId} stdout ends mid-line with no result envelope; retrying once`);
-        return executeSubagent(type3, config, model, userPrompt, subagentId, true, signal, existingAgentId, existingConversationId, maxTurns, parentAgentIdOverride, transcriptPath, memoryScope, systemPromptOverride);
+        return executeSubagent(type3, config, model, userPrompt, subagentId, true, signal, existingAgentId, existingConversationId, maxTurns, parentAgentIdOverride, transcriptPath, memoryScope, systemPromptOverride, environment2);
       }
     }
     return withModel(result);
@@ -115022,7 +115108,7 @@ ${SYSTEM_REMINDER_CLOSE}
 
 `;
 }
-async function spawnSubagent(type3, prompt, userModel, subagentId, signal, existingAgentId, existingConversationId, maxTurns, forkedContext, parentAgentId, transcriptPath, parentConversationId, memoryScope, systemPromptOverride) {
+async function spawnSubagent(type3, prompt, userModel, subagentId, signal, existingAgentId, existingConversationId, maxTurns, forkedContext, parentAgentId, transcriptPath, parentConversationId, memoryScope, systemPromptOverride, environment2) {
   const allConfigs = await getAllSubagentConfigs();
   let config = allConfigs[type3];
   if (!config) {
@@ -115087,7 +115173,7 @@ async function spawnSubagent(type3, prompt, userModel, subagentId, signal, exist
       conversationId: existingConversationId
     });
   }
-  const result = await executeSubagent(type3, config, model, finalPrompt, subagentId, false, signal, existingAgentId, existingConversationId, maxTurns, resolvedParentAgentId, transcriptPath, memoryScope, effectiveSystemPromptOverride);
+  const result = await executeSubagent(type3, config, model, finalPrompt, subagentId, false, signal, existingAgentId, existingConversationId, maxTurns, resolvedParentAgentId, transcriptPath, memoryScope, effectiveSystemPromptOverride, environment2);
   return result;
 }
 var NO_BASE_TOOL_SUBAGENT_TYPES;
@@ -115260,6 +115346,7 @@ function spawnBackgroundSubagentTask(args) {
     onComplete,
     transcriptPath,
     memoryScope,
+    environment: environment2,
     deps
   } = args;
   const shouldEmitCompletionNotification = emitCompletionNotification ?? !silentCompletion;
@@ -115293,7 +115380,7 @@ function spawnBackgroundSubagentTask(args) {
   backgroundTasks.set(taskId, bgTask);
   writeTaskTranscriptStart(outputFile, description, subagentType);
   const parentAgentIdForSpawn = resolvedParentScope?.agentId;
-  spawnSubagentFn(subagentType, prompt, model, subagentId, abortController.signal, existingAgentId, existingConversationId, maxTurns, forkedContext, parentAgentIdForSpawn, transcriptPath, resolvedParentScope?.conversationId, memoryScope, systemPromptOverride).then(async (result) => {
+  spawnSubagentFn(subagentType, prompt, model, subagentId, abortController.signal, existingAgentId, existingConversationId, maxTurns, forkedContext, parentAgentIdForSpawn, transcriptPath, resolvedParentScope?.conversationId, memoryScope, systemPromptOverride, environment2).then(async (result) => {
     await copyGitHubPullRequestTagsFn(result.conversationId, resolvedParentScope?.conversationId);
     bgTask.status = result.success ? "completed" : "failed";
     if (result.error) {
@@ -115489,6 +115576,17 @@ async function task(args) {
   if (!config) {
     return `Error: Invalid subagent type "${subagent_type}"`;
   }
+  if (typeof args.computer === "string" && args.computer.trim()) {
+    let environmentRouting = false;
+    try {
+      environmentRouting = getBackend().capabilities.environmentRouting;
+    } catch {
+      environmentRouting = false;
+    }
+    if (!environmentRouting) {
+      return "Error: The computer option requires a Letta Cloud backend. This backend has no connected computers; omit the computer field to run the subagent on the current machine.";
+    }
+  }
   let effectiveAgentId = args.agent_id;
   let effectiveConversationId = args.conversation_id;
   if (config.fork) {
@@ -115525,7 +115623,8 @@ async function task(args) {
     existingConversationId: effectiveConversationId,
     maxTurns: args.max_turns,
     forkedContext: config.fork,
-    parentScope: resolvedParentScope
+    parentScope: resolvedParentScope,
+    environment: typeof args.computer === "string" && args.computer.trim() ? args.computer.trim() : undefined
   });
   await waitForBackgroundSubagentLink(subagentId, null, signal);
   const linkedAgent = getSnapshot().agents.find((a) => a.id === subagentId);
@@ -117167,6 +117266,10 @@ var init_Task2 = __esm(() => {
       conversation_id: {
         type: "string",
         description: "Resume from an existing conversation. Does NOT require agent_id (conversation IDs are unique and encode the agent)."
+      },
+      computer: {
+        type: "string",
+        description: `Run the subagent on another connected computer instead of this machine. Pass a computer name/connection ID, or "cloud" to provision a Cloud sandbox for the subagent's conversation. Fails fast if the device is offline or does not support routing. Omit this field to run on the current machine (the default) — only set it when the task specifically needs to run elsewhere.`
       }
     },
     required: ["description", "prompt", "subagent_type"],
@@ -118065,6 +118168,21 @@ ${WINDOWS_UNIFIED_EXEC_GUIDANCE}`;
 
 // src/tools/memory-tool-assets.ts
 async function resolveBackendSpecificToolAssets(name, description, inputSchema) {
+  if (name === "Task") {
+    let environmentRouting = false;
+    try {
+      environmentRouting = getBackend().capabilities.environmentRouting;
+    } catch {
+      environmentRouting = false;
+    }
+    if (!environmentRouting) {
+      return {
+        description: stripComputerFromTaskDescription(description),
+        inputSchema: stripComputerFromTaskSchema(inputSchema)
+      };
+    }
+    return { description, inputSchema };
+  }
   let isLocalMemfs = false;
   try {
     isLocalMemfs = getBackend().capabilities.localMemfs;
@@ -125738,7 +125856,7 @@ async function applyMemfsFlags(agentId, memfsFlag, options) {
   };
 }
 async function isLettaCloud() {
-  const { getServerUrl: getServerUrl2 } = await Promise.resolve().then(() => (init_client2(), exports_client));
+  const { getServerUrl: getServerUrl2 } = await Promise.resolve().then(() => (init_server_url(), exports_server_url));
   const serverUrl = getServerUrl2();
   return serverUrl.includes("api.letta.com") || process.env.LETTA_MEMFS_LOCAL === "1" || process.env.LETTA_API_KEY === "local-desktop";
 }
@@ -130943,6 +131061,7 @@ var init_local_provider_errors = __esm(() => {
 var exports_fake_headless_backend = {};
 __export(exports_fake_headless_backend, {
   HeadlessBackend: () => HeadlessBackend,
+  HEADLESS_BACKEND_CAPABILITIES: () => HEADLESS_BACKEND_CAPABILITIES,
   FakeHeadlessBackend: () => HeadlessBackend
 });
 function createPage(items3) {
@@ -131036,16 +131155,7 @@ function isTerminalRun(run) {
 }
 
 class HeadlessBackend {
-  capabilities = {
-    remoteMemfs: false,
-    serverSideToolManagement: false,
-    serverSecrets: false,
-    agentFileImportExport: false,
-    promptRecompile: false,
-    byokProviderRefresh: false,
-    localModelCatalog: true,
-    localMemfs: false
-  };
+  capabilities = HEADLESS_BACKEND_CAPABILITIES;
   store;
   executor;
   runs = new Map;
@@ -131421,13 +131531,24 @@ class HeadlessBackend {
     };
   }
 }
-var FAKE_HEADLESS_MODEL = "dev/fake-headless";
+var FAKE_HEADLESS_MODEL = "dev/fake-headless", HEADLESS_BACKEND_CAPABILITIES;
 var init_fake_headless_backend = __esm(() => {
   init_model_handles();
   init_local_store();
   init_local_stream_chunks();
   init_constants2();
   init_local_provider_errors();
+  HEADLESS_BACKEND_CAPABILITIES = {
+    remoteMemfs: false,
+    serverSideToolManagement: false,
+    serverSecrets: false,
+    agentFileImportExport: false,
+    promptRecompile: false,
+    byokProviderRefresh: false,
+    localModelCatalog: true,
+    localMemfs: false,
+    environmentRouting: false
+  };
 });
 
 // src/backend/dev/headless-backend.ts
@@ -135080,13 +135201,8 @@ var init_local_backend = __esm(() => {
   init_system_prompt_compilation();
   LocalBackend = class LocalBackend extends HeadlessBackend {
     capabilities = {
-      remoteMemfs: false,
-      serverSideToolManagement: false,
-      serverSecrets: false,
-      agentFileImportExport: false,
+      ...HEADLESS_BACKEND_CAPABILITIES,
       promptRecompile: true,
-      byokProviderRefresh: false,
-      localModelCatalog: true,
       localMemfs: true
     };
     memoryDir;
@@ -135513,16 +135629,19 @@ function toApiConversationMessageListBody(body) {
 }
 
 class APIBackend {
-  capabilities = {
-    remoteMemfs: true,
-    serverSideToolManagement: true,
-    serverSecrets: true,
-    agentFileImportExport: true,
-    promptRecompile: true,
-    byokProviderRefresh: true,
-    localModelCatalog: false,
-    localMemfs: false
-  };
+  get capabilities() {
+    return {
+      remoteMemfs: true,
+      serverSideToolManagement: true,
+      serverSecrets: true,
+      agentFileImportExport: true,
+      promptRecompile: true,
+      byokProviderRefresh: true,
+      localModelCatalog: false,
+      localMemfs: false,
+      environmentRouting: isCloudServerUrl()
+    };
+  }
   getApiClientOverride;
   forkConversationOverride;
   constructor(deps = {}) {
@@ -135744,6 +135863,7 @@ function __testSetBackend(nextBackend) {
 }
 var DEFAULT_CONVERSATION_MESSAGE_ORDER = "desc", backend = null;
 var init_backend = __esm(() => {
+  init_server_url();
   init_backend_mode();
   init_local_backend();
   init_paths();
@@ -394179,6 +394299,29 @@ function buildTeleportContinuationMessages(params) {
     }
   ];
 }
+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;
@@ -394357,11 +394500,43 @@ function takeFailedTeleport(params) {
   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)
+    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_connection();
   init_permission_mode();
   init_protocol_outbound();
+  init_recoverable_notices();
   init_runtime();
   init_transport();
   TELEPORT_RECOVERY_TTL_MS = 5 * 60000;
@@ -409763,31 +409938,15 @@ function createListenerMessageHandler(params) {
         return;
       }
       if (parsed.type === "teleport_failed") {
-        const pending = takeFailedTeleport({
+        handleTeleportFailure({
           listener: runtime,
-          teleportId: parsed.teleport_id,
-          agentId: parsed.runtime.agent_id,
-          conversationId: parsed.runtime.conversation_id
+          command: parsed,
+          socket,
+          onStatusChange: opts.onStatusChange,
+          getOrCreateScopedRuntime: getOrCreateScopedRuntime2,
+          runDetachedListenerTask,
+          processIncomingMessage
         });
-        const approvals = pending?.continuation?.approvals;
-        if (pending && approvals && approvals.length > 0) {
-          const scopedRuntime = getOrCreateScopedRuntime2(runtime, pending.agentId, pending.conversationId);
-          runDetachedListenerTask("teleport_failed", async () => {
-            await processIncomingMessage({
-              type: "message",
-              connectionId: pending.connectionId,
-              agentId: pending.agentId,
-              conversationId: pending.conversationId,
-              messages: [
-                {
-                  type: "approval",
-                  approvals,
-                  otid: parsed.teleport_id
-                }
-              ]
-            }, socket, scopedRuntime, opts.onStatusChange, pending.connectionId);
-          });
-        }
         return;
       }
       if (parsed.type === "external_tool_call_response") {
@@ -432006,7 +432165,7 @@ var init_mcp_client = __esm(() => {
   init_streamableHttp();
   DEFAULT_CLIENT_INFO = {
     name: "letta-code",
-    version: "0.31.8"
+    version: "0.31.10"
   };
 });
 
@@ -439183,7 +439342,7 @@ Notes:
   - Operates on the current agent/conversation from LETTA_AGENT_ID /
     LETTA_CONVERSATION_ID (or AGENT_ID / CONVERSATION_ID), falling back to the
     last active session.
-  - Requires a Letta Cloud agent and a non-virtual conversation.
+  - Requires a Letta Cloud agent and an active conversation.
   - list: prints accessible online remote environments as JSON.
   - cloud: teleports to the agent's Cloud sandbox.
   - local: teleports to the one online Desktop environment. Desktop Remote
@@ -439219,7 +439378,7 @@ function resolveTeleportSession(env4, fallback) {
   if (isLocalAgentId(session.agentId)) {
     throw new Error("Teleport requires a Letta Cloud agent");
   }
-  if (!session.conversationId || session.conversationId === "default" || session.conversationId === "new") {
+  if (!session.conversationId || session.conversationId === "new") {
     throw new Error("Teleport requires an active conversation");
   }
   return session;
@@ -445203,8 +445362,8 @@ async function startDockerVersionCheck() {
 }
 var MINIMUM_DOCKER_VERSION = "0.16.6";
 var init_startup_docker_check = __esm(() => {
-  init_client2();
   init_health();
+  init_server_url();
 });
 
 // src/agent/bootstrap-tools.ts
@@ -445579,7 +445738,43 @@ var init_local_backend_mod_events = __esm(() => {
   init_local_backend();
 });
 
+// src/backend/api/agents.ts
+async function getAgentContextOverview(agentId, options) {
+  return apiRequest("GET", `/v1/agents/${agentId}/context`, undefined, {
+    signal: options?.signal
+  });
+}
+async function createMinimalAgent(apiKey, name) {
+  return apiRequest("POST", "/v1/agents", { name }, {
+    baseUrl: "https://api.letta.com",
+    apiKey
+  });
+}
+async function getAgentRuntimeStatus(agentId, conversationIds) {
+  return apiRequest("GET", `/v1/agents/${encodeURIComponent(agentId)}/runtime-status`, undefined, { query: { conversation_ids: conversationIds.join(",") } });
+}
+var init_agents7 = __esm(() => {
+  init_request();
+});
+
 // src/headless-environment-response.ts
+import { randomUUID as randomUUID35 } from "node:crypto";
+function buildEnvironmentCreateMessageBody(params) {
+  const clientToolAllowlist = toolFilter.getEnabledTools();
+  return {
+    agentId: params.agentId,
+    conversationId: params.conversationId,
+    ...clientToolAllowlist !== null ? { client_tool_allowlist: clientToolAllowlist } : {},
+    messages: [
+      {
+        role: "user",
+        content: params.content,
+        client_message_id: randomUUID35(),
+        otid: params.otid
+      }
+    ]
+  };
+}
 function pageItems5(page) {
   if (Array.isArray(page))
     return page;
@@ -445628,12 +445823,42 @@ function messageSequenceId(message) {
   const sequenceId = message.seq_id;
   return typeof sequenceId === "number" ? sequenceId : null;
 }
+function resolveEnvironmentMaxWaitMs() {
+  const raw2 = process.env.LETTA_ENVIRONMENT_TIMEOUT_MS;
+  if (raw2) {
+    const parsed = Number(raw2);
+    if (Number.isFinite(parsed) && parsed > 0)
+      return parsed;
+  }
+  return DEFAULT_MAX_WAIT_MS;
+}
+function isTerminalRunStatus(status) {
+  return status === "completed" || status === "failed" || status === "cancelled";
+}
+function isRuntimeTurnOver(status) {
+  return status.state === "IDLE" || status.loop_state?.status === "WAITING_ON_INPUT";
+}
 async function waitForEnvironmentAssistantMessage(params) {
-  const timeoutMs = params.timeoutMs ?? 10 * 60000;
+  const now2 = params.deps?.now ?? Date.now;
+  const sleep10 = params.deps?.sleep ?? ((ms) => new Promise((resolve38) => setTimeout(resolve38, ms)));
+  const fetchEnvironment = params.deps?.getEnvironmentConnection ?? getEnvironmentConnection;
+  const fetchRuntimeStatus = params.deps?.getAgentRuntimeStatus ?? getAgentRuntimeStatus;
+  const maxWaitMs = params.maxWaitMs ?? resolveEnvironmentMaxWaitMs();
+  const inactivityTimeoutMs = params.inactivityTimeoutMs ?? DEFAULT_INACTIVITY_TIMEOUT_MS;
   const pollIntervalMs = params.pollIntervalMs ?? 1000;
-  const deadline = Date.now() + timeoutMs;
+  const onlineCheckIntervalMs = params.onlineCheckIntervalMs ?? DEFAULT_ONLINE_CHECK_INTERVAL_MS;
+  const runStatusIntervalMs = params.runStatusIntervalMs ?? DEFAULT_RUN_STATUS_INTERVAL_MS;
+  const startedAt = now2();
+  let lastProgressAt = startedAt;
+  let lastOnlineCheckAt = startedAt;
+  let lastRunStatusCheckAt = 0;
+  let lastRuntimeStatusCheckAt = 0;
+  let mode = "unknown";
+  let runtimeTurnOverAt = null;
+  let highestSequenceId = null;
+  let completedWithoutTextAt = null;
   let inputSequenceId = null;
-  while (Date.now() < deadline) {
+  while (true) {
     const page = params.conversationId === "default" ? await params.backend.listAgentMessages(params.agentId, {
       conversation_id: "default",
       limit: 50,
@@ -445643,10 +445868,19 @@ async function waitForEnvironmentAssistantMessage(params) {
       order: "desc"
     });
     const messages = pageItems5(page);
+    for (const message of messages) {
+      const sequenceId = messageSequenceId(message);
+      if (sequenceId !== null && (highestSequenceId === null || sequenceId > highestSequenceId)) {
+        highestSequenceId = sequenceId;
+        lastProgressAt = now2();
+      }
+    }
     if (inputSequenceId === null) {
       const inputMessage = messages.find((message) => isUserMessage(message) && message.otid === params.otid);
       inputSequenceId = inputMessage ? messageSequenceId(inputMessage) : null;
     }
+    let assistant;
+    let newestRunId = null;
     if (inputSequenceId !== null) {
       const anchorSequenceId = inputSequenceId;
       const newerMessages = messages.filter((message) => {
@@ -445662,25 +445896,104 @@ async function waitForEnvironmentAssistantMessage(params) {
           return closest;
         return closest === null || sequenceId < closest ? sequenceId : closest;
       }, null);
-      const assistant = newerMessages.filter((message) => {
+      const turnMessages = newerMessages.filter((message) => {
         const sequenceId = messageSequenceId(message);
-        return isAssistantMessage2(message) && sequenceId !== null && (nextUserSequenceId === null || sequenceId < nextUserSequenceId);
-      }).sort((a2, b3) => (messageSequenceId(b3) ?? 0) - (messageSequenceId(a2) ?? 0))[0];
-      const runId = messageRunId(assistant);
-      if (runId) {
-        const run = await params.backend.retrieveRun(runId);
-        if ((run.status === "completed" || run.status === "failed" || run.status === "cancelled") && run.stop_reason !== "requires_approval") {
+        return sequenceId !== null && (nextUserSequenceId === null || sequenceId < nextUserSequenceId);
+      });
+      assistant = turnMessages.filter((message) => isAssistantMessage2(message)).sort((a2, b3) => (messageSequenceId(b3) ?? 0) - (messageSequenceId(a2) ?? 0))[0];
+      newestRunId = messageRunId(assistant) ?? turnMessages.sort((a2, b3) => (messageSequenceId(b3) ?? 0) - (messageSequenceId(a2) ?? 0)).map((message) => messageRunId(message)).find((id2) => id2 !== null) ?? null;
+    }
+    if (mode !== "runs") {
+      const shouldCheckRuntimeStatus = assistant !== undefined || lastRuntimeStatusCheckAt === 0 || now2() - lastRuntimeStatusCheckAt >= runStatusIntervalMs;
+      if (shouldCheckRuntimeStatus) {
+        lastRuntimeStatusCheckAt = now2();
+        let snapshot = null;
+        try {
+          snapshot = await fetchRuntimeStatus(params.agentId, [
+            params.conversationId
+          ]);
+        } catch (error5) {
+          if (error5 instanceof ApiRequestError && error5.status === 404) {
+            mode = "runs";
+          }
+        }
+        if (snapshot) {
+          mode = "runtime-status";
+          const status = snapshot.statuses.find((entry) => entry.conversation_id === params.conversationId) ?? (snapshot.statuses.length === 1 ? snapshot.statuses[0] : null) ?? null;
+          if (status && !isRuntimeTurnOver(status)) {
+            lastProgressAt = now2();
+            runtimeTurnOverAt = null;
+          } else if (status && inputSequenceId !== null) {
+            const text2 = assistant ? extractMessageText(assistant).trim() : "";
+            if (text2.length > 0) {
+              let stopReason = null;
+              if (newestRunId) {
+                try {
+                  const run = await params.backend.retrieveRun(newestRunId);
+                  stopReason = run.stop_reason ?? null;
+                } catch {}
+              }
+              return { text: text2, stopReason };
+            }
+            runtimeTurnOverAt ??= now2();
+            if (now2() - runtimeTurnOverAt >= COMPLETED_WITHOUT_TEXT_GRACE_MS) {
+              throw new Error("Environment turn ended without an assistant reply " + `(runtime state ${status.state})`);
+            }
+          }
+        }
+      }
+    }
+    if (mode !== "runtime-status" && inputSequenceId !== null) {
+      const shouldCheckRun = newestRunId !== null && (assistant !== undefined || now2() - lastRunStatusCheckAt >= runStatusIntervalMs);
+      if (newestRunId && shouldCheckRun) {
+        lastRunStatusCheckAt = now2();
+        const run = await params.backend.retrieveRun(newestRunId);
+        if (!isTerminalRunStatus(run.status)) {
+          lastProgressAt = now2();
+        } else if (run.stop_reason !== "requires_approval") {
           const text2 = assistant ? extractMessageText(assistant).trim() : "";
           if (text2.length > 0) {
             return { text: text2, stopReason: run.stop_reason ?? null };
           }
+          if (run.status === "failed" || run.status === "cancelled") {
+            throw new Error(`Environment turn run ${newestRunId} ${run.status} without an assistant reply` + (run.stop_reason ? ` (stop reason: ${run.stop_reason})` : ""));
+          }
+          completedWithoutTextAt ??= now2();
+          if (now2() - completedWithoutTextAt >= COMPLETED_WITHOUT_TEXT_GRACE_MS) {
+            throw new Error(`Environment turn run ${newestRunId} completed without an assistant reply`);
+          }
         }
       }
     }
-    await new Promise((resolve38) => setTimeout(resolve38, pollIntervalMs));
+    if (params.deviceId && now2() - lastOnlineCheckAt >= onlineCheckIntervalMs) {
+      lastOnlineCheckAt = now2();
+      let offline = false;
+      try {
+        const connection = await fetchEnvironment(params.deviceId);
+        offline = !isEnvironmentOnline(connection);
+      } catch {}
+      if (offline) {
+        throw new Error(`Environment device ${params.deviceId} went offline before the turn completed`);
+      }
+    }
+    if (now2() - lastProgressAt >= inactivityTimeoutMs) {
+      throw new Error(`No activity from the environment turn for ${inactivityTimeoutMs}ms (no new messages and no running run); giving up`);
+    }
+    if (now2() - startedAt >= maxWaitMs) {
+      throw new Error(`Environment turn did not complete within ${maxWaitMs}ms (set LETTA_ENVIRONMENT_TIMEOUT_MS to raise the ceiling)`);
+    }
+    await sleep10(pollIntervalMs);
   }
-  throw new Error("Timed out waiting for environment turn completion");
 }
+var DEFAULT_MAX_WAIT_MS, DEFAULT_INACTIVITY_TIMEOUT_MS, DEFAULT_ONLINE_CHECK_INTERVAL_MS = 30000, DEFAULT_RUN_STATUS_INTERVAL_MS = 1e4, COMPLETED_WITHOUT_TEXT_GRACE_MS = 15000;
+var init_headless_environment_response = __esm(() => {
+  init_agents7();
+  init_environments2();
+  init_request();
+  init_filter();
+  DEFAULT_MAX_WAIT_MS = 60 * 60000;
+  DEFAULT_INACTIVITY_TIMEOUT_MS = 10 * 60000;
+});
 
 // src/agent/ephemeral-conversation.ts
 async function buildEphemeralConversationCreateBody(options) {
@@ -446683,7 +446996,7 @@ async function ensureDefaultAgents(backend3, options) {
 }
 var MEMO_TAG = "default:memo", TUTOR_TAG = "default:tutorial", MEMO_PERSONA, MEMO_HUMAN, MEMO_DESCRIPTION = "The default Letta Code agent with persistent memory", DEFAULT_AGENT_CONFIGS;
 var init_defaults = __esm(() => {
-  init_client2();
+  init_server_url();
   init_settings_manager();
   init_create5();
   init_memory();
@@ -446712,7 +447025,7 @@ __export(exports_headless, {
   decideInterruptAction: () => decideInterruptAction,
   __headlessTestUtils: () => __headlessTestUtils
 });
-import { randomUUID as randomUUID35 } from "node:crypto";
+import { randomUUID as randomUUID36 } from "node:crypto";
 function trackHeadlessBoundaryError(errorType, error5, context3) {
   trackBoundaryError({
     errorType,
@@ -446734,7 +447047,7 @@ async function reportStartupErrorAndExit(errorType, error5, context3, outputForm
       message,
       stop_reason: "error",
       session_id: "startup",
-      uuid: `startup-error-${randomUUID35()}`
+      uuid: `startup-error-${randomUUID36()}`
     };
     await writeWireMessageAsync(errorMsg);
   } else {
@@ -446833,7 +447146,7 @@ async function emitHeadlessTurnStartCancellationOutput(options) {
       message: options.reason,
       stop_reason: "cancelled",
       session_id: options.sessionId,
-      uuid: `error-turn-start-cancel-${randomUUID35()}`
+      uuid: `error-turn-start-cancel-${randomUUID36()}`
     };
     await writeWireMessageAsync(errorMsg);
     const resultMsg = {
@@ -446848,7 +447161,7 @@ async function emitHeadlessTurnStartCancellationOutput(options) {
       conversation_id: options.conversationId,
       run_ids: [],
       usage: null,
-      uuid: `result-turn-start-cancel-${randomUUID35()}`,
+      uuid: `result-turn-start-cancel-${randomUUID36()}`,
       stop_reason: "cancelled"
     };
     await writeWireMessageAsync(resultMsg);
@@ -446877,7 +447190,7 @@ function writeBidirectionalTurnStartCancellation(options) {
     message: options.reason,
     stop_reason: "cancelled",
     session_id: options.sessionId,
-    uuid: `error-turn-start-cancel-${randomUUID35()}`
+    uuid: `error-turn-start-cancel-${randomUUID36()}`
   };
   writeWireMessage(errorMsg);
   const resultMsg = {
@@ -446892,7 +447205,7 @@ function writeBidirectionalTurnStartCancellation(options) {
     conversation_id: options.conversationId,
     run_ids: [],
     usage: null,
-    uuid: `result-turn-start-cancel-${randomUUID35()}`,
+    uuid: `result-turn-start-cancel-${randomUUID36()}`,
     stop_reason: "cancelled"
   };
   writeWireMessage(resultMsg);
@@ -447771,7 +448084,7 @@ Current session AGENT_ID=${process.env.AGENT_ID}; --backend local switches to a
       const approvalInput = {
         type: "approval",
         approvals: denialResults,
-        otid: randomUUID35()
+        otid: randomUUID36()
       };
       const approvalMessages = [approvalInput];
       {
@@ -447784,7 +448097,7 @@ Current session AGENT_ID=${process.env.AGENT_ID}; --backend local switches to a
               type: "text",
               text: sc.content
             })),
-            otid: randomUUID35()
+            otid: randomUUID36()
           });
         }
       }
@@ -447817,7 +448130,7 @@ Current session AGENT_ID=${process.env.AGENT_ID}; --backend local switches to a
           message: `Failed to resolve pending approvals on resume: ${approvalError instanceof Error ? approvalError.message : String(approvalError)}`,
           stop_reason: "error",
           session_id: sessionId,
-          uuid: `error-pre-loop-approval-${randomUUID35()}`
+          uuid: `error-pre-loop-approval-${randomUUID36()}`
         };
         writeWireMessage(errorMsg);
       } else {
@@ -447956,26 +448269,20 @@ ${loadedContents.join(`
       }
       await exitHeadless(1, "headless_environment_unsupported");
     }
-    const otid = randomUUID35();
-    await sendEnvironmentMessage(connectionId, {
+    const otid = randomUUID36();
+    await sendEnvironmentMessage(connectionId, buildEnvironmentCreateMessageBody({
       agentId: agent.id,
       conversationId,
-      messages: [
-        {
-          role: "user",
-          content: contentParts,
-          client_message_id: randomUUID35(),
-          otid
-        }
-      ]
-    });
+      content: contentParts,
+      otid
+    }));
     const environmentResult = await waitForEnvironmentAssistantMessage({
       backend: backend3,
       agentId: agent.id,
       conversationId,
-      otid
+      otid,
+      deviceId: environment2.deviceId
     });
-    const resultText2 = environmentResult.text;
     const stats2 = sessionStats.getSnapshot();
     if (outputFormat === "json") {
       await writeFinalHeadlessStdout(`${JSON.stringify({
@@ -447985,7 +448292,7 @@ ${loadedContents.join(`
         duration_ms: Math.round(stats2.totalWallMs),
         duration_api_ms: Math.round(stats2.totalApiMs),
         num_turns: 1,
-        result: resultText2,
+        result: environmentResult.text,
         agent_id: publicAgentId,
         conversation_id: conversationId,
         environment: responseEnvironment,
@@ -448001,7 +448308,7 @@ ${loadedContents.join(`
         duration_ms: Math.round(stats2.totalWallMs),
         duration_api_ms: Math.round(stats2.totalApiMs),
         num_turns: 1,
-        result: resultText2,
+        result: environmentResult.text,
         agent_id: publicAgentId,
         conversation_id: conversationId,
         environment: responseEnvironment,
@@ -448012,7 +448319,7 @@ ${loadedContents.join(`
       };
       writeWireMessage(resultEvent);
     } else {
-      await writeFinalHeadlessStdout(`${resultText2}
+      await writeFinalHeadlessStdout(`${environmentResult.text}
 `);
     }
     await exitHeadless(0, "headless_environment_message_complete");
@@ -448021,7 +448328,7 @@ ${loadedContents.join(`
     {
       role: "user",
       content: contentParts,
-      otid: randomUUID35()
+      otid: randomUUID36()
     }
   ];
   const recoveredApprovalResults = queuedRecoveredApprovalResults ?? [];
@@ -448030,7 +448337,7 @@ ${loadedContents.join(`
       {
         type: "approval",
         approvals: recoveredApprovalResults,
-        otid: randomUUID35()
+        otid: randomUUID36()
       },
       ...currentInput
     ];
@@ -448076,7 +448383,7 @@ ${loadedContents.join(`
           message: `Maximum turns limit reached (${buffers.usage.stepCount}/${maxTurns} steps)`,
           stop_reason: "max_steps",
           session_id: sessionId,
-          uuid: `error-max-turns-${randomUUID35()}`
+          uuid: `error-max-turns-${randomUUID36()}`
         };
         await writeWireMessageAsync(errorMsg);
       } else {
@@ -448093,7 +448400,7 @@ ${loadedContents.join(`
         message: "Interrupted by SIGINT",
         stop_reason: "cancelled",
         session_id: sessionId,
-        uuid: `error-interrupted-${randomUUID35()}`
+        uuid: `error-interrupted-${randomUUID36()}`
       };
       await writeWireMessageAsync(errorMsg);
     } else {
@@ -448122,7 +448429,7 @@ ${loadedContents.join(`
                 type: "text",
                 text: sc.content
               })),
-              otid: randomUUID35()
+              otid: randomUUID36()
             }
           ];
         }
@@ -448167,7 +448474,7 @@ ${loadedContents.join(`
               recovery_type: "approval_pending",
               message: "Detected pending approval conflict on send; resolving before retry",
               session_id: sessionId,
-              uuid: `recovery-pre-stream-${randomUUID35()}`
+              uuid: `recovery-pre-stream-${randomUUID36()}`
             };
             writeWireMessage(recoveryMsg);
           } else {
@@ -448200,7 +448507,7 @@ ${loadedContents.join(`
                 max_attempts: CONVERSATION_BUSY_MAX_RETRIES,
                 delay_ms: retryDelayMs,
                 session_id: sessionId,
-                uuid: `retry-conversation-busy-${randomUUID35()}`
+                uuid: `retry-conversation-busy-${randomUUID36()}`
               };
               writeWireMessage(retryMsg);
             } else {
@@ -448228,7 +448535,7 @@ ${loadedContents.join(`
               max_attempts: LLM_API_ERROR_MAX_RETRIES2,
               delay_ms: delayMs,
               session_id: sessionId,
-              uuid: `retry-pre-stream-${randomUUID35()}`
+              uuid: `retry-pre-stream-${randomUUID36()}`
             };
             writeWireMessage(retryMsg);
           } else {
@@ -448254,7 +448561,7 @@ ${loadedContents.join(`
               stop_reason: "error",
               run_id: errorInfo.run_id,
               session_id: sessionId,
-              uuid: randomUUID35(),
+              uuid: randomUUID36(),
               ...errorInfo.error_type && errorInfo.run_id && {
                 api_error: {
                   message_type: "error_message",
@@ -448276,7 +448583,7 @@ ${loadedContents.join(`
               message: "Detected pending approval conflict; auto-denying stale approval and retrying",
               run_id: recoveryRunId ?? undefined,
               session_id: sessionId,
-              uuid: `recovery-${recoveryRunId || randomUUID35()}`
+              uuid: `recovery-${recoveryRunId || randomUUID36()}`
             };
             writeWireMessage(recoveryMsg);
             approvalPendingRecovery = true;
@@ -448294,7 +448601,7 @@ ${loadedContents.join(`
                 type: "stream_event",
                 event: chunk2,
                 session_id: sessionId,
-                uuid: uuid3 || randomUUID35()
+                uuid: uuid3 || randomUUID36()
               };
               writeWireMessage(streamEvent);
             } else {
@@ -448302,7 +448609,7 @@ ${loadedContents.join(`
                 type: "message",
                 ...chunk2,
                 session_id: sessionId,
-                uuid: uuid3 || randomUUID35()
+                uuid: uuid3 || randomUUID36()
               };
               writeWireMessage(msg);
             }
@@ -448346,7 +448653,7 @@ ${loadedContents.join(`
             {
               role: "user",
               content: continueMessage,
-              otid: randomUUID35()
+              otid: randomUUID36()
             }
           ];
           const continueTurnStartEmission = await emitHeadlessTurnStart({
@@ -448418,7 +448725,7 @@ ${loadedContents.join(`
         const approvalInputWithOtid = {
           type: "approval",
           approvals: executedResults,
-          otid: randomUUID35()
+          otid: randomUUID36()
         };
         currentInput = [approvalInputWithOtid];
         continue;
@@ -448451,7 +448758,7 @@ ${loadedContents.join(`
               delay_ms: 0,
               run_id: lastRunId ?? undefined,
               session_id: sessionId,
-              uuid: `retry-${lastRunId || randomUUID35()}`
+              uuid: `retry-${lastRunId || randomUUID36()}`
             };
             writeWireMessage(retryMsg);
           } else {
@@ -448479,7 +448786,7 @@ ${loadedContents.join(`
               delay_ms: delayMs,
               run_id: lastRunId ?? undefined,
               session_id: sessionId,
-              uuid: `retry-${lastRunId || randomUUID35()}`
+              uuid: `retry-${lastRunId || randomUUID36()}`
             };
             writeWireMessage(retryMsg);
           } else {
@@ -448500,7 +448807,7 @@ ${loadedContents.join(`
             message: "Tool call ID mismatch; fetching actual pending approvals and resyncing",
             run_id: lastRunId ?? undefined,
             session_id: sessionId,
-            uuid: `recovery-${lastRunId || randomUUID35()}`
+            uuid: `recovery-${lastRunId || randomUUID36()}`
           };
           writeWireMessage(recoveryMsg);
         } else {
@@ -448517,7 +448824,7 @@ ${loadedContents.join(`
               stop_reason: stopReason,
               run_id: lastRunId ?? undefined,
               session_id: sessionId,
-              uuid: `error-${lastRunId || randomUUID35()}`
+              uuid: `error-${lastRunId || randomUUID36()}`
             };
             await writeWireMessageAsync(errorMsg);
           } else {
@@ -448559,7 +448866,7 @@ ${loadedContents.join(`
               const nudgeMessage = {
                 role: "system",
                 content: `<system-reminder>The previous response was empty. Please provide a response with either text content or a tool call.</system-reminder>`,
-                otid: randomUUID35()
+                otid: randomUUID36()
               };
               currentInput = [...currentInput, nudgeMessage];
             }
@@ -448572,7 +448879,7 @@ ${loadedContents.join(`
                 delay_ms: delayMs,
                 run_id: lastRunId ?? undefined,
                 session_id: sessionId,
-                uuid: `retry-empty-${lastRunId || randomUUID35()}`
+                uuid: `retry-empty-${lastRunId || randomUUID36()}`
               };
               writeWireMessage(retryMsg);
             } else {
@@ -448599,7 +448906,7 @@ ${loadedContents.join(`
                 delay_ms: delayMs,
                 run_id: lastRunId ?? undefined,
                 session_id: sessionId,
-                uuid: `retry-${lastRunId || randomUUID35()}`
+                uuid: `retry-${lastRunId || randomUUID36()}`
               };
               writeWireMessage(retryMsg);
             } else {
@@ -448629,7 +448936,7 @@ ${loadedContents.join(`
                 delay_ms: delayMs,
                 run_id: lastRunId ?? undefined,
                 session_id: sessionId,
-                uuid: `retry-${lastRunId || randomUUID35()}`
+                uuid: `retry-${lastRunId || randomUUID36()}`
               };
               writeWireMessage(retryMsg);
             } else {
@@ -448678,7 +448985,7 @@ ${loadedContents.join(`
           stop_reason: stopReason,
           run_id: lastRunId ?? undefined,
           session_id: sessionId,
-          uuid: `error-${lastRunId || randomUUID35()}`
+          uuid: `error-${lastRunId || randomUUID36()}`
         };
         await writeWireMessageAsync(errorMsg);
       } else {
@@ -448697,7 +449004,7 @@ ${loadedContents.join(`
         stop_reason: "error",
         run_id: lastKnownRunId ?? undefined,
         session_id: sessionId,
-        uuid: `error-${lastKnownRunId || randomUUID35()}`
+        uuid: `error-${lastKnownRunId || randomUUID36()}`
       };
       await writeWireMessageAsync(errorMsg);
     } else {
@@ -448894,7 +449201,7 @@ async function runBidirectionalMode(agent, conversationId, _outputFormat, includ
       const approvalInput = {
         type: "approval",
         approvals: denialResults,
-        otid: randomUUID35()
+        otid: randomUUID36()
       };
       const approvalMessages = [approvalInput];
       {
@@ -448907,7 +449214,7 @@ async function runBidirectionalMode(agent, conversationId, _outputFormat, includ
               type: "text",
               text: sc.content
             })),
-            otid: randomUUID35()
+            otid: randomUUID36()
           });
         }
       }
@@ -448965,7 +449272,7 @@ async function runBidirectionalMode(agent, conversationId, _outputFormat, includ
         reason,
         cleared_count: clearedCount,
         session_id: sessionId,
-        uuid: `q-clr-${randomUUID35()}`
+        uuid: `q-clr-${randomUUID36()}`
       })
     }
   });
@@ -448995,7 +449302,7 @@ async function runBidirectionalMode(agent, conversationId, _outputFormat, includ
       reason: "runtime_busy",
       queue_len: Math.max(1, queueLen),
       session_id: sessionId,
-      uuid: `q-blk-${randomUUID35()}`
+      uuid: `q-blk-${randomUUID36()}`
     });
   }
   function enqueueForTracking(input) {
@@ -449067,7 +449374,7 @@ async function runBidirectionalMode(agent, conversationId, _outputFormat, includ
           request_id: interruptRequestId
         },
         session_id: sessionId,
-        uuid: randomUUID35()
+        uuid: randomUUID36()
       };
       writeWireMessage(interruptResponse);
       return;
@@ -449170,7 +449477,7 @@ async function runBidirectionalMode(agent, conversationId, _outputFormat, includ
       const approvalInput = {
         type: "approval",
         approvals: denialResults,
-        otid: randomUUID35()
+        otid: randomUUID36()
       };
       const approvalStream = await sendScopedApprovalMessages({
         agentId: agent.id,
@@ -449209,7 +449516,7 @@ async function runBidirectionalMode(agent, conversationId, _outputFormat, includ
         message: "Invalid JSON input",
         stop_reason: "error",
         session_id: sessionId,
-        uuid: randomUUID35()
+        uuid: randomUUID36()
       };
       writeWireMessage(errorMsg2);
       continue;
@@ -449235,7 +449542,7 @@ async function runBidirectionalMode(agent, conversationId, _outputFormat, includ
             }
           },
           session_id: sessionId,
-          uuid: randomUUID35()
+          uuid: randomUUID36()
         };
         writeWireMessage(initResponse);
       } else if (subtype === "interrupt") {
@@ -449252,7 +449559,7 @@ async function runBidirectionalMode(agent, conversationId, _outputFormat, includ
             request_id: requestId ?? ""
           },
           session_id: sessionId,
-          uuid: randomUUID35()
+          uuid: randomUUID36()
         };
         writeWireMessage(interruptResponse);
       } else if (subtype === "register_external_tools") {
@@ -449300,7 +449607,7 @@ async function runBidirectionalMode(agent, conversationId, _outputFormat, includ
             response: { registered: tools.length }
           },
           session_id: sessionId,
-          uuid: randomUUID35()
+          uuid: randomUUID36()
         };
         writeWireMessage(registerResponse);
       } else if (subtype === "bootstrap_session_state") {
@@ -449356,7 +449663,7 @@ async function runBidirectionalMode(agent, conversationId, _outputFormat, includ
               response: recovery
             },
             session_id: sessionId,
-            uuid: randomUUID35()
+            uuid: randomUUID36()
           };
           writeWireMessage(recoveryResponse);
         } catch (error5) {
@@ -449368,7 +449675,7 @@ async function runBidirectionalMode(agent, conversationId, _outputFormat, includ
               error: error5 instanceof Error ? error5.message : String(error5)
             },
             session_id: sessionId,
-            uuid: randomUUID35()
+            uuid: randomUUID36()
           };
           writeWireMessage(recoveryError);
         }
@@ -449381,7 +449688,7 @@ async function runBidirectionalMode(agent, conversationId, _outputFormat, includ
             error: `Unknown control request subtype: ${subtype}`
           },
           session_id: sessionId,
-          uuid: randomUUID35()
+          uuid: randomUUID36()
         };
         writeWireMessage(errorResponse);
       }
@@ -449436,7 +449743,7 @@ async function runBidirectionalMode(agent, conversationId, _outputFormat, includ
       try {
         const buffers = createBuffers(agent.id);
         const startTime = performance.now();
-        const userOtid = randomUUID35();
+        const userOtid = randomUUID36();
         const userTranscriptText = extractTelemetryInputText(userContent);
         if (userTranscriptText.length > 0) {
           const userLineId = `user-${userOtid}`;
@@ -449558,7 +449865,7 @@ async function runBidirectionalMode(agent, conversationId, _outputFormat, includ
                   recovery_type: "approval_pending",
                   message: "Detected pending approval conflict on send; resolving before retry",
                   session_id: sessionId,
-                  uuid: `recovery-bidir-${randomUUID35()}`
+                  uuid: `recovery-bidir-${randomUUID36()}`
                 };
                 writeWireMessage(recoveryMsg);
                 await resolveAllPendingApprovals();
@@ -449581,7 +449888,7 @@ async function runBidirectionalMode(agent, conversationId, _outputFormat, includ
                   max_attempts: LLM_API_ERROR_MAX_RETRIES2,
                   delay_ms: delayMs,
                   session_id: sessionId,
-                  uuid: `retry-bidir-${randomUUID35()}`
+                  uuid: `retry-bidir-${randomUUID36()}`
                 };
                 writeWireMessage(retryMsg);
                 await new Promise((resolve40) => setTimeout(resolve40, delayMs));
@@ -449603,7 +449910,7 @@ async function runBidirectionalMode(agent, conversationId, _outputFormat, includ
                   stop_reason: "error",
                   run_id: errorInfo.run_id,
                   session_id: sessionId,
-                  uuid: randomUUID35(),
+                  uuid: randomUUID36(),
                   ...errorInfo.error_type && errorInfo.run_id && {
                     api_error: {
                       message_type: "error_message",
@@ -449631,7 +449938,7 @@ async function runBidirectionalMode(agent, conversationId, _outputFormat, includ
                   type: "stream_event",
                   event: chunk2,
                   session_id: sessionId,
-                  uuid: uuid3 || randomUUID35()
+                  uuid: uuid3 || randomUUID36()
                 };
                 writeWireMessage(streamEvent);
               } else {
@@ -449639,7 +449946,7 @@ async function runBidirectionalMode(agent, conversationId, _outputFormat, includ
                   type: "message",
                   ...chunk2,
                   session_id: sessionId,
-                  uuid: uuid3 || randomUUID35()
+                  uuid: uuid3 || randomUUID36()
                 };
                 writeWireMessage(msg);
               }
@@ -449708,7 +450015,7 @@ async function runBidirectionalMode(agent, conversationId, _outputFormat, includ
               const approvalInputWithOtid = {
                 type: "approval",
                 approvals: executedResults,
-                otid: randomUUID35()
+                otid: randomUUID36()
               };
               currentInput = [approvalInputWithOtid];
               continue;
@@ -449771,7 +450078,7 @@ async function runBidirectionalMode(agent, conversationId, _outputFormat, includ
           message: errorDetails,
           stop_reason: "error",
           session_id: sessionId,
-          uuid: randomUUID35()
+          uuid: randomUUID36()
         };
         writeWireMessage(errorMsg2);
         const errorResultMsg = {
@@ -449814,7 +450121,7 @@ async function runBidirectionalMode(agent, conversationId, _outputFormat, includ
       message: `Unknown message type: ${message.type}`,
       stop_reason: "error",
       session_id: sessionId,
-      uuid: randomUUID35()
+      uuid: randomUUID36()
     };
     writeWireMessage(errorMsg);
   }
@@ -449850,6 +450157,7 @@ var init_headless = __esm(async () => {
   init_reflection_transcript();
   init_local_backend_mod_events();
   init_constants2();
+  init_headless_environment_response();
   init_headless_reflection_settings();
   init_diff_preview();
   init_format_denial();
@@ -451312,7 +451620,7 @@ var init_reflection_arena_hf_upload = __esm(() => {
 
 // src/cli/helpers/reflection-arena.ts
 import { execFile as execFileCb6 } from "node:child_process";
-import { randomInt as randomInt2, randomUUID as randomUUID36 } from "node:crypto";
+import { randomInt as randomInt2, randomUUID as randomUUID37 } from "node:crypto";
 import { appendFile as appendFile3, mkdir as mkdir18, readFile as readFile30, writeFile as writeFile21 } from "node:fs/promises";
 import { homedir as homedir47 } from "node:os";
 import { join as join85 } from "node:path";
@@ -451674,7 +451982,7 @@ async function startReflectionArenaRun(options) {
   }
   let releaseReservation = true;
   try {
-    const runId = randomUUID36().slice(0, 8);
+    const runId = randomUUID37().slice(0, 8);
     const labels = shuffledLabels();
     const prepared = await Promise.all([
       prepareReflectionMemoryWorktreeLaunch({
@@ -464303,22 +464611,6 @@ var init_InputRich = __esm(async () => {
   EventEmitter5.defaultMaxListeners = 20;
 });
 
-// src/backend/api/agents.ts
-async function getAgentContextOverview(agentId, options) {
-  return apiRequest("GET", `/v1/agents/${agentId}/context`, undefined, {
-    signal: options?.signal
-  });
-}
-async function createMinimalAgent(apiKey, name) {
-  return apiRequest("POST", "/v1/agents", { name }, {
-    baseUrl: "https://api.letta.com",
-    apiKey
-  });
-}
-var init_agents7 = __esm(() => {
-  init_request();
-});
-
 // src/cli/commands/install-github-app.ts
 import { execFileSync as execFileSync7 } from "node:child_process";
 import {
@@ -468704,6 +468996,7 @@ var init_generate_memory_viewer = __esm(() => {
   init_agents7();
   init_client2();
   init_request();
+  init_server_url();
   init_context_usage();
   init_local_memory_context();
   init_memory_viewer_template();
@@ -476777,12 +477070,12 @@ var init_ExitStats = __esm(async () => {
 });
 
 // src/cli/app/ids.ts
-import { randomUUID as randomUUID37 } from "node:crypto";
+import { randomUUID as randomUUID38 } from "node:crypto";
 function uid(prefix) {
   return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
 }
 function createClientOtid() {
-  return randomUUID37();
+  return randomUUID38();
 }
 function appendOptimisticUserLine(buffers, text2, otid) {
   if (!text2) {
@@ -493670,7 +493963,7 @@ var init_notifications = __esm(() => {
 });
 
 // src/cli/app/use-approval-flow.ts
-import { randomUUID as randomUUID38 } from "node:crypto";
+import { randomUUID as randomUUID39 } from "node:crypto";
 function useApprovalFlow(ctx) {
   const {
     abortControllerRef,
@@ -494182,7 +494475,7 @@ function useApprovalFlow(ctx) {
             {
               type: "approval",
               approvals: allResults,
-              otid: randomUUID38()
+              otid: randomUUID39()
             }
           ]);
         } catch (error5) {
@@ -495581,7 +495874,7 @@ var init_system_reminders = __esm(() => {
 });
 
 // src/cli/app/use-conversation-loop.ts
-import { randomUUID as randomUUID39 } from "node:crypto";
+import { randomUUID as randomUUID40 } from "node:crypto";
 function sleep10(ms) {
   return new Promise((resolve43) => setTimeout(resolve43, ms));
 }
@@ -495885,16 +496178,16 @@ function useConversationLoop(ctx) {
         currentInput = [
           ...lastSentInputRef.current.map((m4) => ({
             ...m4,
-            otid: randomUUID39()
+            otid: randomUUID40()
           })),
           ...currentInput.map((m4) => m4.type === "message" && m4.role === "user" ? {
             ...m4,
-            otid: randomUUID39(),
+            otid: randomUUID40(),
             content: [
               { type: "text", text: INTERRUPT_RECOVERY_ALERT },
               ...typeof m4.content === "string" ? [{ type: "text", text: m4.content }] : Array.isArray(m4.content) ? m4.content : []
             ]
-          } : { ...m4, otid: randomUUID39() })
+          } : { ...m4, otid: randomUUID40() })
         ];
         pendingInterruptRecoveryConversationIdRef.current = null;
         lastSentInputRef.current = [
@@ -495933,7 +496226,7 @@ function useConversationLoop(ctx) {
                 type: "text",
                 text: sc.content
               })),
-              otid: randomUUID39()
+              otid: randomUUID40()
             }
           ];
         }
@@ -496292,7 +496585,7 @@ ${feedback}
             });
             buffersRef.current.order.push(statusId);
             refreshDerived();
-            const hookMessageOtid = randomUUID39();
+            const hookMessageOtid = randomUUID40();
             setTimeout(() => {
               processConversation([
                 {
@@ -496319,7 +496612,7 @@ ${feedback}
             turnEndContinue = undefined;
           }
           if (turnEndContinue) {
-            const continueOtid = randomUUID39();
+            const continueOtid = randomUUID40();
             setTimeout(() => {
               processConversation([
                 {
@@ -496673,7 +496966,7 @@ ${feedback}
                 {
                   type: "approval",
                   approvals: allResults,
-                  otid: randomUUID39()
+                  otid: randomUUID40()
                 }
               ], {
                 allowReentry: true,
@@ -496878,7 +497171,7 @@ ${feedback}
                 type: "message",
                 role: "system",
                 content: `<system-reminder>The previous response was empty. Please provide a response with either text content or a tool call.</system-reminder>`,
-                otid: randomUUID39()
+                otid: randomUUID40()
               }
             ];
           }
@@ -497153,7 +497446,7 @@ var init_use_conversation_loop = __esm(async () => {
 });
 
 // src/cli/app/use-conversation-switching.ts
-import { randomUUID as randomUUID40 } from "node:crypto";
+import { randomUUID as randomUUID41 } from "node:crypto";
 function useConversationSwitching(ctx) {
   const {
     abortControllerRef,
@@ -497228,7 +497521,7 @@ function useConversationSwitching(ctx) {
         {
           role: "user",
           content: question,
-          otid: randomUUID40()
+          otid: randomUUID41()
         }
       ];
       let approvalRecoveryRetries = 0;
@@ -497680,7 +497973,7 @@ var init_use_conversation_switching = __esm(async () => {
   init_create5();
   init_defaults();
   init_backend2();
-  init_client2();
+  init_server_url();
   init_app_urls();
   init_backfill();
   init_error_formatter();
@@ -502733,7 +503026,7 @@ var init_conversation_switch_alert = __esm(() => {
 });
 
 // src/cli/app/use-submit-handler.ts
-import { randomUUID as randomUUID41 } from "node:crypto";
+import { randomUUID as randomUUID42 } from "node:crypto";
 import { existsSync as existsSync74, readFileSync as readFileSync46, renameSync as renameSync8, writeFileSync as writeFileSync39 } from "node:fs";
 import { tmpdir as tmpdir13 } from "node:os";
 import { join as join94 } from "node:path";
@@ -503154,7 +503447,7 @@ ${SYSTEM_REMINDER_CLOSE}` : "";
               content: buildTextParts(`${SYSTEM_REMINDER_OPEN}
 ${prompt}
 ${SYSTEM_REMINDER_CLOSE}`),
-              otid: randomUUID41()
+              otid: randomUUID42()
             }
           ]);
         } catch (error5) {
@@ -503218,7 +503511,7 @@ ${SYSTEM_REMINDER_CLOSE}`),
                 type: "message",
                 role: "user",
                 content: buildTextParts(buildModCommandPrompt(result3)),
-                otid: randomUUID41()
+                otid: randomUUID42()
               }
             ]);
           } else if (result3.type === "output") {
@@ -503263,7 +503556,7 @@ ${SYSTEM_REMINDER_CLOSE}`),
 ${SYSTEM_REMINDER_OPEN}
 ${request2}
 ${SYSTEM_REMINDER_CLOSE}`),
-              otid: randomUUID41()
+              otid: randomUUID42()
             }
           ]);
         } catch (error5) {
@@ -503532,7 +503825,7 @@ ${SYSTEM_REMINDER_CLOSE}`),
 ${SYSTEM_REMINDER_OPEN}
 ${request2}
 ${SYSTEM_REMINDER_CLOSE}`),
-              otid: randomUUID41()
+              otid: randomUUID42()
             }
           ]);
         } catch (error5) {
@@ -504377,7 +504670,7 @@ ${SYSTEM_REMINDER_CLOSE}`;
               type: "message",
               role: "user",
               content: buildTextParts(skillMessage),
-              otid: randomUUID41()
+              otid: randomUUID42()
             }
           ]);
         } catch (error5) {
@@ -504415,7 +504708,7 @@ ${SYSTEM_REMINDER_CLOSE}`;
               type: "message",
               role: "user",
               content: rememberParts,
-              otid: randomUUID41()
+              otid: randomUUID42()
             }
           ]);
         } catch (error5) {
@@ -504831,7 +505124,7 @@ Resumed reflection arena choice prompt for run ${run2.runId}.`, true);
               type: "message",
               role: "user",
               content: buildTextParts(initMessage),
-              otid: randomUUID41()
+              otid: randomUUID42()
             }
           ]);
         } catch (error5) {
@@ -504998,7 +505291,7 @@ Resumed reflection arena choice prompt for run ${run2.runId}.`, true);
                 type: "message",
                 role: "user",
                 content: buildTextParts(wrapSkillPrompt2(matchedSkill.id, skillContent, userRequest)),
-                otid: randomUUID41()
+                otid: randomUUID42()
               }
             ]);
           } catch (error5) {
@@ -505149,7 +505442,7 @@ ${SYSTEM_REMINDER_CLOSE}
       initialInput.push({
         type: "approval",
         approvals: eagerRecoveryDenials,
-        otid: randomUUID41()
+        otid: randomUUID42()
       });
     }
     const queuedApprovalInput = consumeQueuedApprovalInputForCurrentConversation();
@@ -512702,4 +512995,4 @@ function registerBunOAuthFlows() {
 registerBunOAuthFlows();
 await init_src5().then(() => exports_src2);
 
-//# debugId=5B21ECF59F212A2E64756E2164756E21
+//# debugId=39DF2EA197BB152964756E2164756E21