@letta-ai/letta-code 0.31.9 → 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.9",
+    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 {
@@ -93661,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();
@@ -115525,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) {
@@ -118106,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;
@@ -125779,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";
 }
@@ -130984,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) {
@@ -131077,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;
@@ -131462,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
@@ -135121,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;
@@ -135554,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 = {}) {
@@ -135785,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();
@@ -432086,7 +432165,7 @@ var init_mcp_client = __esm(() => {
   init_streamableHttp();
   DEFAULT_CLIENT_INFO = {
     name: "letta-code",
-    version: "0.31.9"
+    version: "0.31.10"
   };
 });
 
@@ -445283,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
@@ -446917,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();
@@ -468917,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();
@@ -497893,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();
@@ -512915,4 +512995,4 @@ function registerBunOAuthFlows() {
 registerBunOAuthFlows();
 await init_src5().then(() => exports_src2);
 
-//# debugId=201C7804F30F08EC64756E2164756E21
+//# debugId=39DF2EA197BB152964756E2164756E21