@letta-ai/letta-code 0.31.10 → 0.31.12

package/letta.js

@@ -5400,7 +5400,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.31.10",
+    version: "0.31.12",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     packageManager: "bun@1.3.10",
@@ -5781,6 +5781,15 @@ function isLoopbackUrl(value, options = {}) {
 }
 
 // src/backend/api/metadata.ts
+function getFeedbackClientType(env = process.env) {
+  if (env.LETTA_DESKTOP_MODE === "1") {
+    return "desktop";
+  }
+  if (env.LETTA_RUNTIME_ENVIRONMENT_DEVICE_ID) {
+    return "chat.letta.com";
+  }
+  return "cli";
+}
 async function getBalanceMetadata() {
   return apiRequest("GET", "/v1/metadata/balance");
 }
@@ -7959,7 +7968,7 @@ Other
 - [ ] Make a permissions edit: let the user know that you can modify permissions (what commands are automatically approved/denied). Ask them if there are certain actions they would like you to avoid.
 - [ ] Create a local mod: let the user know you can customize Letta Code with trusted local mods for new tools, slash commands, provider integrations, UI panels/status, events, or permission overlays. Explain that mods are for executable harness behavior, while memory and skills are for retained knowledge and reusable procedures.
 - [ ] Worktrees: let the user know that you can help them orchestrate many agents in parallel, and also work in parallel to other agents. Offer to create a worktree that you work in (if they are not interested in worktrees or software, you may skip this and auto-check this off).
-- [ ] Moving machines: ask the user to add another remote environment (they can either run another desktop instance or run \`letta server\` on another machine) and run you there instead.
+- [ ] Moving machines: ask the user to connect another computer (they can either run another desktop instance or run \`letta server\` on another machine) and run you there instead.
 `;
 var init_onboarding = () => {};
 
@@ -8012,7 +8021,7 @@ Other
 - [ ] Make a permissions edit: let the user know that you can modify permissions (what commands are automatically approved/denied). Ask them if there are certain actions they would like you to avoid.
 - [ ] Create a local mod: let the user know you can customize Letta Code with trusted local mods for new tools, slash commands, provider integrations, UI panels/status, events, or permission overlays. Explain that mods are for executable harness behavior, while memory and skills are for retained knowledge and reusable procedures.
 - [ ] Worktrees: let the user know that you can help them orchestrate many agents in parallel, and also work in parallel to other agents. Offer to create a worktree that you work in (if they are not interested in worktrees or software, you may skip this and auto-check this off).
-- [ ] Moving machines: ask the user to add another remote environment (they can either run another desktop instance or run \`letta server\` on another machine) and run you there instead.
+- [ ] Moving machines: ask the user to connect another computer (they can either run another desktop instance or run \`letta server\` on another machine) and run you there instead.
 `;
 var init_onboarding_local = () => {};
 
@@ -90861,6 +90870,9 @@ function createSharedReminderState() {
     hasSentSecretsInfo: false,
     pendingSecretsInfoRefresh: false,
     lastSentSecretNamesKey: null,
+    hasSentMcpServersInfo: false,
+    lastSentMcpServerNamesKey: null,
+    lastMcpServersFetchedAtMs: null,
     lastNotifiedPermissionMode: null,
     turnCount: 0,
     pendingReflectionTrigger: false,
@@ -90877,6 +90889,8 @@ function markPostCompactionContextRemindersPending(state) {
   state.hasSentSessionContext = false;
   state.pendingSessionContextReason ??= "post_compaction";
   state.hasSentSecretsInfo = false;
+  state.hasSentMcpServersInfo = false;
+  state.lastMcpServersFetchedAtMs = null;
   state.lastNotifiedPermissionMode = null;
 }
 function syncReminderStateFromContextTracker(state, contextTracker) {
@@ -113434,8 +113448,7 @@ var init_skills3 = __esm(() => {
   init_skill_sources();
   LOCAL_AGENT_EXCLUDED_BUNDLED_SKILLS = new Set([
     "image-generation",
-    "managing-shared-memory",
-    "using-cloud-mcp"
+    "managing-shared-memory"
   ]);
   PROJECT_SKILLS_DIR = join24(".agents", "skills");
   GLOBAL_SKILLS_DIR = join24(process.env.HOME || process.env.USERPROFILE || "~", ".letta/skills");
@@ -114788,7 +114801,7 @@ function buildSubagentArgs(type3, config, model, userPrompt, existingAgentId, ex
     args.push("--backend", options.backendMode);
   }
   if (options.environment) {
-    args.push("--environment", options.environment);
+    args.push("--computer", options.environment);
   }
   if (isDeployingExisting) {
     if (existingConversationId) {
@@ -137011,14 +137024,15 @@ var init_args = __esm(() => {
         description: "Inject agent-to-agent system reminder (headless mode)"
       }
     },
-    environment: {
+    computer: {
       parser: { type: "string" },
       mode: "headless",
       help: {
         argLabel: "<selector>",
-        description: "Route headless message through 'cloud' sandbox or an environment by name, device ID, or connection ID"
+        description: "Route headless message through 'cloud' or a computer by name, device ID, or connection ID"
       }
     },
+    environment: { parser: { type: "string" }, mode: "headless" },
     env: { parser: { type: "string" }, mode: "headless" },
     skills: {
       parser: { type: "string" },
@@ -185677,6 +185691,8 @@ function buildChannelFeedbackPayload(submission) {
   return withDefinedValues2({
     message: submission.message,
     feature: CHANNEL_FEEDBACK_FEATURE,
+    submission_source: "slash_command",
+    client_type: process.env.LETTA_DESKTOP_MODE === "1" ? "desktop" : "cli",
     version: getVersion(),
     platform: process.platform,
     channel: submission.channel,
@@ -199431,330 +199447,6 @@ var init_channels = __esm(() => {
   };
 });
 
-// src/backend/api/mcp-servers.ts
-function getString(record3, key2) {
-  const value = record3[key2];
-  return typeof value === "string" ? value : null;
-}
-function parseAgentConnectedMcpServer(value) {
-  if (!isRecord(value)) {
-    return null;
-  }
-  const id2 = getString(value, "id");
-  const serverName = getString(value, "server_name");
-  const serverType = getString(value, "mcp_server_type");
-  if (!id2 || !serverName || !serverType) {
-    return null;
-  }
-  const target2 = getString(value, "server_url") ?? [
-    getString(value, "command"),
-    ...Array.isArray(value.args) ? value.args : []
-  ].filter((item) => typeof item === "string").join(" ");
-  return { id: id2, serverName, serverType, target: target2 };
-}
-function parseAgentConnectedMcpTool(value) {
-  if (!isRecord(value)) {
-    return null;
-  }
-  const id2 = getString(value, "id");
-  const name = getString(value, "name");
-  if (!id2 || !name) {
-    return null;
-  }
-  const description = getString(value, "description");
-  return { id: id2, name, description };
-}
-function parseAgentMcpToolRunResult(value) {
-  if (!isRecord(value)) {
-    throw new Error("MCP tool run returned an invalid response");
-  }
-  const status = getString(value, "status") ?? "unknown";
-  return {
-    status,
-    funcReturn: value.func_return,
-    stdout: value.stdout,
-    stderr: value.stderr
-  };
-}
-function withTimeout(promise, timeoutMs, label) {
-  let timer;
-  const timeout = new Promise((_4, reject2) => {
-    timer = setTimeout(() => reject2(new Error(`${label} timed out after ${timeoutMs}ms`)), timeoutMs);
-  });
-  return Promise.race([promise, timeout]).finally(() => {
-    if (timer !== undefined)
-      clearTimeout(timer);
-  });
-}
-function listServerMcpServers(client, timeoutMs = 1e4) {
-  return withTimeout(client.mcpServers.list(), timeoutMs, "Listing server-side MCP servers");
-}
-async function listAgentConnectedMcpServers(client, agentId, timeoutMs = 1e4) {
-  const result2 = await withTimeout(client.get(`/v1/agents/${encodeURIComponent(agentId)}/mcp-servers`), timeoutMs, "Listing agent-connected MCP servers");
-  if (!Array.isArray(result2)) {
-    return [];
-  }
-  return result2.map(parseAgentConnectedMcpServer).filter((server2) => server2 !== null);
-}
-async function listAgentConnectedMcpTools(client, agentId, mcpServerId, timeoutMs = 1e4) {
-  const result2 = await withTimeout(client.get(`/v1/agents/${encodeURIComponent(agentId)}/mcp-servers/${encodeURIComponent(mcpServerId)}/tools`), timeoutMs, "Listing agent-connected MCP server tools");
-  if (!Array.isArray(result2)) {
-    return [];
-  }
-  return result2.map(parseAgentConnectedMcpTool).filter((tool) => tool !== null);
-}
-async function runAgentConnectedMcpTool(params) {
-  const result2 = await withTimeout(params.client.post(`/v1/agents/${encodeURIComponent(params.agentId)}/mcp-servers/${encodeURIComponent(params.mcpServerId)}/tools/${encodeURIComponent(params.toolId)}/run`, { args: params.args }), params.timeoutMs ?? 60000, "Running agent-connected MCP tool");
-  return parseAgentMcpToolRunResult(result2);
-}
-async function listLiveServerMcpTools(client, serverName, timeoutMs = 15000) {
-  const result2 = await withTimeout(client.get(`/v1/tools/mcp/servers/${encodeURIComponent(serverName)}/tools`), timeoutMs, `Listing tools for MCP server "${serverName}"`);
-  if (!Array.isArray(result2))
-    return [];
-  return result2.filter((tool) => typeof tool === "object" && tool !== null && typeof tool.name === "string");
-}
-async function loadServerMcpEntries(client, timeoutMs = 15000) {
-  const servers = await listServerMcpServers(client, timeoutMs);
-  return Promise.all(servers.map(async (server2) => {
-    try {
-      const tools = await listLiveServerMcpTools(client, server2.server_name, timeoutMs);
-      return { server: server2, tools };
-    } catch (cause) {
-      return {
-        server: server2,
-        tools: [],
-        toolsError: cause instanceof Error ? cause.message : String(cause)
-      };
-    }
-  }));
-}
-function parseMcpMetadata(tool) {
-  const metadata = tool.metadata_;
-  const mcp = metadata?.mcp;
-  if (typeof mcp !== "object" || mcp === null)
-    return null;
-  const { server_id, server_name } = mcp;
-  return {
-    ...typeof server_id === "string" && { serverId: server_id },
-    ...typeof server_name === "string" && { serverName: server_name }
-  };
-}
-async function listAgentMcpAttachments(client, agentId) {
-  const attachments = [];
-  for await (const tool of client.agents.tools.list(agentId, { limit: 100 })) {
-    if (tool.tool_type !== "external_mcp" || !tool.id || !tool.name)
-      continue;
-    attachments.push({
-      toolId: tool.id,
-      toolName: tool.name,
-      ...parseMcpMetadata(tool)
-    });
-  }
-  return attachments;
-}
-function attachmentsForEntry(entry, attachments) {
-  return attachments.filter((attachment) => attachment.serverId && entry.server.id ? attachment.serverId === entry.server.id : attachment.serverName === entry.server.server_name);
-}
-function attachedToolNamesForEntry(entry, attachments) {
-  return new Set(attachmentsForEntry(entry, attachments).map((attachment) => attachment.toolName));
-}
-async function registerServerMcpTool(client, serverName, toolName) {
-  const result2 = await client.post(`/v1/tools/mcp/servers/${encodeURIComponent(serverName)}/${encodeURIComponent(toolName)}`);
-  if (typeof result2?.id !== "string") {
-    throw new Error(`Registering MCP tool "${toolName}" on server "${serverName}" returned no tool id`);
-  }
-  return { id: result2.id };
-}
-async function attachServerMcpTools(client, agentId, serverName, toolNames) {
-  await Promise.all(toolNames.map(async (toolName) => {
-    const { id: id2 } = await registerServerMcpTool(client, serverName, toolName);
-    await client.agents.tools.attach(id2, { agent_id: agentId });
-  }));
-}
-async function detachServerMcpTools(client, agentId, toolIds) {
-  await Promise.all(toolIds.map((toolId) => client.agents.tools.detach(toolId, { agent_id: agentId })));
-}
-function refreshServerMcpServer(client, mcpServerId, agentId) {
-  return client.mcpServers.refresh(mcpServerId, { agent_id: agentId });
-}
-function planServerMcpToggle(entry, attachments) {
-  const attached = attachmentsForEntry(entry, attachments);
-  if (attached.length > 0) {
-    return {
-      action: "detach",
-      toolIds: attached.map((attachment) => attachment.toolId)
-    };
-  }
-  return { action: "attach", toolNames: entry.tools.map((tool) => tool.name) };
-}
-function describeServerMcpTarget(server2) {
-  if ("server_url" in server2 && server2.server_url) {
-    return server2.server_url;
-  }
-  if ("command" in server2 && server2.command) {
-    return [server2.command, ...server2.args ?? []].join(" ");
-  }
-  return "";
-}
-var init_mcp_servers2 = () => {};
-
-// src/cli/subcommands/cloud-mcp.ts
-import { parseArgs as parseArgs4 } from "node:util";
-function printUsage4(stdout = console.log) {
-  stdout(`
-Usage:
-  letta cloud-mcp list [--agent <id>]
-  letta cloud-mcp tools <mcp-server-id> [--agent <id>]
-  letta cloud-mcp run <mcp-server-id> <tool-id> [--args '<json>'] [--agent <id>]
-
-Actions:
-  list      List MCP servers connected to the agent
-  tools     List registered tools for one connected MCP server
-  run       Run one registered MCP tool through the agent-scoped server route
-
-Aliases:
-  list-servers, list_servers  Alias for list
-  list-tools, list_tools      Alias for tools
-  call, run-tool, run_tool     Alias for run
-
-Options:
-  --agent <id>      Agent ID. Defaults to LETTA_AGENT_ID or AGENT_ID
-  --agent-id <id>   Alias for --agent
-  --args '<json>'   JSON object passed as MCP tool arguments for run
-  -h, --help        Show this help
-
-Notes:
-  - Output is JSON only.
-  - Requires a signed-in Letta Cloud agent with server-side MCP support.
-  - Uses CLI auth; override with LETTA_API_KEY/LETTA_BASE_URL if needed.
-`.trim());
-}
-function parseCloudMcpArgs(argv) {
-  return parseArgs4({
-    args: argv,
-    options: {
-      help: { type: "boolean", short: "h" },
-      agent: { type: "string" },
-      "agent-id": { type: "string" },
-      args: { type: "string" }
-    },
-    strict: true,
-    allowPositionals: true
-  });
-}
-function stringValue3(value) {
-  return typeof value === "string" ? value : undefined;
-}
-function resolveCloudMcpAgentId(agent, agentId, env4 = process.env) {
-  return (agent || agentId || env4.LETTA_AGENT_ID || env4.AGENT_ID || "").trim();
-}
-function parseToolArgs(value) {
-  const raw2 = stringValue3(value);
-  if (!raw2) {
-    return {};
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw2);
-  } catch (error4) {
-    const message = error4 instanceof Error ? error4.message : String(error4);
-    throw new Error(`Invalid --args JSON: ${message}`);
-  }
-  if (!isRecord(parsed)) {
-    throw new Error("Invalid --args JSON: expected a JSON object");
-  }
-  return parsed;
-}
-function printJson(stdout, result2) {
-  stdout(JSON.stringify(result2, null, 2));
-}
-async function defaultGetClient() {
-  const client = await getClient();
-  return client;
-}
-async function runCloudMcpSubcommand(argv, deps = {}) {
-  const stdout = deps.stdout ?? console.log;
-  const stderr = deps.stderr ?? console.error;
-  let parsed;
-  try {
-    parsed = parseCloudMcpArgs(argv);
-  } catch (error4) {
-    const message = error4 instanceof Error ? error4.message : String(error4);
-    stderr(`Error: ${message}`);
-    printUsage4(stdout);
-    return 1;
-  }
-  const [action3, mcpServerId, toolId] = parsed.positionals;
-  if (parsed.values.help || !action3 || action3 === "help") {
-    printUsage4(stdout);
-    return 0;
-  }
-  const isAvailable = deps.isServerSideMcpAvailable ?? (() => getBackend().capabilities.serverSideToolManagement);
-  if (!isAvailable()) {
-    stderr("Server-side MCP requires a signed-in Letta Cloud agent; the local backend does not support it.");
-    return 1;
-  }
-  const agentId = resolveCloudMcpAgentId(stringValue3(parsed.values.agent), stringValue3(parsed.values["agent-id"]));
-  if (!agentId) {
-    stderr("Agent id required: pass --agent <id> or set LETTA_AGENT_ID/AGENT_ID.");
-    return 1;
-  }
-  await (deps.initializeSettings ?? (() => settingsManager.initialize()))();
-  const client = await (deps.getClient ?? defaultGetClient)();
-  try {
-    if (action3 === "list" || action3 === "list-servers" || action3 === "list_servers") {
-      printJson(stdout, {
-        agent_id: agentId,
-        servers: await listAgentConnectedMcpServers(client, agentId)
-      });
-      return 0;
-    }
-    if (action3 === "tools" || action3 === "list-tools" || action3 === "list_tools") {
-      if (!mcpServerId) {
-        stderr("Usage: letta cloud-mcp tools <mcp-server-id> [--agent <id>]");
-        return 1;
-      }
-      printJson(stdout, {
-        agent_id: agentId,
-        mcp_server_id: mcpServerId,
-        tools: await listAgentConnectedMcpTools(client, agentId, mcpServerId)
-      });
-      return 0;
-    }
-    if (action3 === "run" || action3 === "call" || action3 === "run-tool" || action3 === "run_tool") {
-      if (!mcpServerId || !toolId) {
-        stderr("Usage: letta cloud-mcp run <mcp-server-id> <tool-id> [--args '<json>'] [--agent <id>]");
-        return 1;
-      }
-      printJson(stdout, {
-        agent_id: agentId,
-        mcp_server_id: mcpServerId,
-        tool_id: toolId,
-        result: await runAgentConnectedMcpTool({
-          client,
-          agentId,
-          mcpServerId,
-          toolId,
-          args: parseToolArgs(parsed.values.args)
-        })
-      });
-      return 0;
-    }
-    stderr(`Unknown cloud-mcp action: ${action3}`);
-    printUsage4(stdout);
-    return 1;
-  } catch (error4) {
-    stderr(error4 instanceof Error ? error4.message : String(error4));
-    return 1;
-  }
-}
-var init_cloud_mcp = __esm(() => {
-  init_backend2();
-  init_client2();
-  init_mcp_servers2();
-  init_settings_manager();
-});
-
 // src/auth/openai-oauth.ts
 import http3 from "node:http";
 function renderOAuthPage(options) {
@@ -200878,7 +200570,7 @@ var init_connect_normalize = __esm(() => {
 // src/cli/subcommands/connect.ts
 import { createInterface as createInterface6 } from "node:readline/promises";
 import { Writable } from "node:stream";
-import { parseArgs as parseArgs5 } from "node:util";
+import { parseArgs as parseArgs4 } from "node:util";
 function readStringOption(value) {
   if (typeof value === "string") {
     return value;
@@ -200970,7 +200662,7 @@ async function runConnectSubcommand(argv, deps = {}) {
   const io = { ...DEFAULT_DEPS2, ...deps };
   let parsed;
   try {
-    parsed = parseArgs5({
+    parsed = parseArgs4({
       args: argv,
       options: CONNECT_OPTIONS,
       strict: true,
@@ -209911,10 +209603,10 @@ async function resolveDesktopEnvironmentConnectionId(list = listEnvironments) {
   const response = await list({ limit: 100, onlineOnly: true });
   const matches3 = response.connections.filter((environment3) => environment3.listenerInstanceId?.startsWith("desktop-direct-cloud:") === true && isEnvironmentOnline(environment3));
   if (matches3.length === 0) {
-    throw new Error("Desktop Local is unavailable. Open Letta Desktop, enable Remote Access, and wait for its environment to come online.");
+    throw new Error("Desktop Local is unavailable. Open Letta Desktop, enable Remote Access, and wait for its computer connection to come online.");
   }
   if (matches3.length > 1) {
-    throw new Error(`Multiple Desktop environments are online. Run \`letta teleport list\` and choose one by name, device ID, or connection ID. Matched: ${matches3.map(describeEnvironment).join(", ")}`);
+    throw new Error(`Multiple Desktop computers are online. Run \`letta teleport list\` and choose one by name, device ID, or connection ID. Matched: ${matches3.map(describeEnvironment).join(", ")}`);
   }
   const environment2 = matches3[0];
   if (!environment2?.connectionId) {
@@ -209925,28 +209617,28 @@ async function resolveDesktopEnvironmentConnectionId(list = listEnvironments) {
 async function resolveEnvironmentConnectionId(selector) {
   const trimmed = selector.trim();
   if (!trimmed) {
-    throw new Error("Environment selector must not be empty");
+    throw new Error("Computer selector must not be empty");
   }
   const response = await listEnvironments({ limit: 100 });
   const matches3 = response.connections.filter((environment3) => {
     return environment3.connectionId === trimmed || environment3.id === trimmed || environment3.deviceId === trimmed || environment3.connectionName === trimmed;
   });
   if (matches3.length === 0) {
-    throw new Error(`Environment "${trimmed}" not found. Run \`letta environments list\` to discover available environments.`);
+    throw new Error(`Computer "${trimmed}" not found. Run \`letta computers list\` to discover available computers.`);
   }
   const onlineMatches = matches3.filter(isEnvironmentOnline);
   if (onlineMatches.length === 0) {
-    throw new Error(`Environment "${trimmed}" is offline. Matched: ${matches3.map(describeEnvironment).join(", ")}`);
+    throw new Error(`Computer "${trimmed}" is offline. Matched: ${matches3.map(describeEnvironment).join(", ")}`);
   }
   if (onlineMatches.length > 1) {
-    throw new Error(`Environment "${trimmed}" is ambiguous. Matched: ${onlineMatches.map(describeEnvironment).join(", ")}`);
+    throw new Error(`Computer "${trimmed}" is ambiguous. Matched: ${onlineMatches.map(describeEnvironment).join(", ")}`);
   }
   const environment2 = onlineMatches[0];
   if (!environment2) {
-    throw new Error(`Environment "${trimmed}" is offline`);
+    throw new Error(`Computer "${trimmed}" is offline`);
   }
   if (!environment2.connectionId) {
-    throw new Error(`Environment "${trimmed}" has no active connection id`);
+    throw new Error(`Computer "${trimmed}" has no active connection id`);
   }
   return { connectionId: environment2.connectionId, environment: environment2 };
 }
@@ -210180,8 +209872,8 @@ var init_cron_task_ref = __esm(async () => {
 });
 
 // src/cli/subcommands/cron.ts
-import { parseArgs as parseArgs6 } from "node:util";
-function printUsage5() {
+import { parseArgs as parseArgs5 } from "node:util";
+function printUsage4() {
   console.log(`
 Usage:
   letta cron add --prompt <text> --every <interval> [options]
@@ -210217,8 +209909,8 @@ Add options:
                                    the fallback when Cloud scheduling cannot
                                    reach this computer)
   --computer <id>        (cloud runner only) Override execution with a
-                         connected external environment (deviceId from
-                         \`letta environments list\`). Falls back to the Cloud
+                         connected external computer (deviceId from
+                         \`letta computers list\`). Falls back to the Cloud
                          sandbox if the computer is offline at fire time.
                          Managed sandboxes and Desktop-local connections are
                          not currently valid Cloud schedule targets.
@@ -210235,7 +209927,7 @@ Output is JSON.
 `.trim());
 }
 function parseCronArgs(argv) {
-  return parseArgs6({
+  return parseArgs5({
     args: argv,
     options: CRON_OPTIONS,
     strict: true,
@@ -210405,7 +210097,7 @@ async function handleAdd(values3) {
       targetDeviceId = inferredDeviceId;
     } else if (resolution.kind === "local-fallback") {
       runner = "local";
-      localFallbackNote = `This schedule is local to this computer (${resolution.reason}): it only fires while a Letta session is running here. For a schedule that fires regardless, pass --runner cloud (runs in the agent's cloud sandbox) or --computer <deviceId> (runs on a connected computer, from \`letta environments list\`).`;
+      localFallbackNote = `This schedule is local to this computer (${resolution.reason}): it only fires while a Letta session is running here. For a schedule that fires regardless, pass --runner cloud (runs in the agent's cloud sandbox) or --computer <deviceId> (runs on a connected computer, from \`letta computers list\`).`;
     }
   }
   if (runner === "cloud") {
@@ -210791,12 +210483,12 @@ async function runCronSubcommand(argv) {
     parsed = parseCronArgs(argv);
   } catch (err) {
     console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
-    printUsage5();
+    printUsage4();
     return 1;
   }
   const [action3] = parsed.positionals;
   if (parsed.values.help || !action3 || action3 === "help") {
-    printUsage5();
+    printUsage4();
     return 0;
   }
   switch (action3) {
@@ -210813,7 +210505,7 @@ async function runCronSubcommand(argv) {
       return handleDelete(parsed.values, parsed.positionals);
     default:
       console.error(`Unknown action: ${action3}`);
-      printUsage5();
+      printUsage4();
       return 1;
   }
 }
@@ -210849,29 +210541,31 @@ var init_cron2 = __esm(async () => {
 });
 
 // src/cli/subcommands/environments.ts
-import { parseArgs as parseArgs7 } from "node:util";
-function printUsage6() {
+import { parseArgs as parseArgs6 } from "node:util";
+function printUsage5() {
   console.log(`
 Usage:
-  letta environments list [options]
-  letta environments current
+  letta computers list [options]
+  letta computers current
 
-Aliases:
+Legacy aliases:
+  letta environments list
+  letta environments current
   letta envs list
   letta envs current
 
 List options:
   --limit <n>       Max results (default: 50)
-  --after <id>      Pagination cursor from a previous environment id
-  --online-only     Only include environments with a fresh active connection
+  --after <id>      Pagination cursor from a previous computer id
+  --online-only     Only include computers with a fresh active connection
 
 Notes:
   - Output is JSON only.
   - Uses CLI auth; override with LETTA_API_KEY/LETTA_BASE_URL if needed.
-  - Use letta environments current to get this machine's connectionId.
-  - Use --environment cloud to route through the target agent's cloud sandbox.
-  - Use --environment <name|device-id|connection-id> with headless messaging
-    to route a message through a specific registered environment.
+  - Use letta computers current to get this computer's connectionId.
+  - Use --computer cloud to route through the target agent's cloud sandbox.
+  - Use --computer <name|device-id|connection-id> with headless messaging
+    to route a message through a specific registered computer.
 `.trim());
 }
 function parseLimit2(value, fallback) {
@@ -210918,7 +210612,7 @@ function scoreCurrentEnvironment(environment2, options) {
   return score;
 }
 function parseEnvironmentsArgs(argv) {
-  return parseArgs7({
+  return parseArgs6({
     args: argv,
     options: ENVIRONMENTS_OPTIONS,
     strict: true,
@@ -210932,17 +210626,17 @@ async function runEnvironmentsSubcommand(argv, deps = {}) {
   } catch (error4) {
     const message = error4 instanceof Error ? error4.message : String(error4);
     console.error(`Error: ${message}`);
-    printUsage6();
+    printUsage5();
     return 1;
   }
   const [action3] = parsed.positionals;
   if (parsed.values.help || !action3 || action3 === "help") {
-    printUsage6();
+    printUsage5();
     return 0;
   }
   if (action3 !== "list" && action3 !== "current") {
     console.error(`Unknown action: ${action3}`);
-    printUsage6();
+    printUsage5();
     return 1;
   }
   await (deps.initializeSettings ?? (() => settingsManager.initialize()))();
@@ -210958,7 +210652,7 @@ async function runEnvironmentsSubcommand(argv, deps = {}) {
       currentVersion
     });
     if (!current2) {
-      console.error("No online environment found for this device. Start one with `letta server` and try again.");
+      console.error("No online computer found for this device. Start one with `letta server` and try again.");
       return 1;
     }
     console.log(JSON.stringify(formatEnvironmentForCli(current2, {
@@ -211004,8 +210698,8 @@ var init_environments3 = __esm(() => {
 });
 
 // src/cli/subcommands/feedback.ts
-import { parseArgs as parseArgs8 } from "node:util";
-function printUsage7(stdout = console.log) {
+import { parseArgs as parseArgs7 } from "node:util";
+function printUsage6(stdout = console.log) {
   stdout(`
 Usage:
   letta feedback --message <text>
@@ -211023,7 +210717,7 @@ async function runFeedbackSubcommand(argv, deps = {}) {
   const stderr = deps.stderr ?? console.error;
   let parsed;
   try {
-    parsed = parseArgs8({
+    parsed = parseArgs7({
       args: argv,
       options: {
         help: { type: "boolean", short: "h" },
@@ -211034,11 +210728,11 @@ async function runFeedbackSubcommand(argv, deps = {}) {
     });
   } catch (error4) {
     stderr(error4 instanceof Error ? error4.message : String(error4));
-    printUsage7(stdout);
+    printUsage6(stdout);
     return 1;
   }
   if (parsed.values.help) {
-    printUsage7(stdout);
+    printUsage6(stdout);
     return 0;
   }
   const message = typeof parsed.values.message === "string" ? parsed.values.message.trim() : "";
@@ -211061,6 +210755,8 @@ async function runFeedbackSubcommand(argv, deps = {}) {
     await (deps.submitFeedback ?? submitFeedbackMetadata)(apiKey, (deps.getDeviceId ?? (() => settingsManager.getOrCreateDeviceId()))(), {
       message,
       feature: "letta-code-agent-feedback",
+      submission_source: "agent_skill",
+      client_type: (deps.getClientType ?? getFeedbackClientType)(),
       version: getVersion(),
       platform: process.platform,
       agent_id: agentId || undefined,
@@ -212778,7 +212474,7 @@ function ListenerStatusUI(props) {
           bold: true,
           color: "green",
           children: [
-            "The name of your environment is: ",
+            "The name of your computer is: ",
             envName
           ]
         }, undefined, true, undefined, this)
@@ -212811,7 +212507,7 @@ function ListenerStatusUI(props) {
         children: /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(Text, {
           dimColor: true,
           children: [
-            'Connect to this environment by visiting any agent and clicking the "cloud" button at the bottom left of the messenger input and swapping your environment to ',
+            'Connect to this computer by visiting any agent and clicking the "cloud" button at the bottom left of the messenger input and swapping your computer to ',
             envName
           ]
         }, undefined, true, undefined, this)
@@ -238784,9 +238480,9 @@ ${lanes.join(`
     function isJsonEqual(a2, b3) {
       return a2 === b3 || typeof a2 === "object" && a2 !== null && typeof b3 === "object" && b3 !== null && equalOwnProperties(a2, b3, isJsonEqual);
     }
-    function parsePseudoBigInt(stringValue4) {
+    function parsePseudoBigInt(stringValue3) {
       let log2Base;
-      switch (stringValue4.charCodeAt(1)) {
+      switch (stringValue3.charCodeAt(1)) {
         case 98:
         case 66:
           log2Base = 1;
@@ -238800,19 +238496,19 @@ ${lanes.join(`
           log2Base = 4;
           break;
         default:
-          const nIndex = stringValue4.length - 1;
+          const nIndex = stringValue3.length - 1;
           let nonZeroStart = 0;
-          while (stringValue4.charCodeAt(nonZeroStart) === 48) {
+          while (stringValue3.charCodeAt(nonZeroStart) === 48) {
             nonZeroStart++;
           }
-          return stringValue4.slice(nonZeroStart, nIndex) || "0";
+          return stringValue3.slice(nonZeroStart, nIndex) || "0";
       }
-      const startIndex = 2, endIndex = stringValue4.length - 1;
+      const startIndex = 2, endIndex = stringValue3.length - 1;
       const bitsNeeded = (endIndex - startIndex) * log2Base;
       const segments = new Uint16Array((bitsNeeded >>> 4) + (bitsNeeded & 15 ? 1 : 0));
       for (let i4 = endIndex - 1, bitOffset = 0;i4 >= startIndex; i4--, bitOffset += log2Base) {
         const segment = bitOffset >>> 4;
-        const digitChar = stringValue4.charCodeAt(i4);
+        const digitChar = stringValue3.charCodeAt(i4);
         const digit = digitChar <= 57 ? digitChar - 48 : 10 + digitChar - (digitChar <= 70 ? 65 : 97);
         const shiftedDigit = digit << (bitOffset & 15);
         segments[segment] |= shiftedDigit;
@@ -391876,7 +391572,7 @@ function toRunsArray(listResponse) {
   }
   return [];
 }
-function withTimeout2(promise, timeoutMs, timeoutMessage) {
+function withTimeout(promise, timeoutMs, timeoutMessage) {
   return new Promise((resolve34, reject2) => {
     const timer = setTimeout(() => reject2(new Error(timeoutMessage)), timeoutMs);
     promise.then((value) => {
@@ -391890,7 +391586,7 @@ function withTimeout2(promise, timeoutMs, timeoutMessage) {
 }
 async function discoverFallbackRunIdWithTimeout(ctx) {
   const client = await getClient();
-  return withTimeout2(discoverFallbackRunIdForResume(client, ctx), FALLBACK_RUN_DISCOVERY_TIMEOUT_MS, `Fallback run discovery timed out after ${FALLBACK_RUN_DISCOVERY_TIMEOUT_MS}ms`);
+  return withTimeout(discoverFallbackRunIdForResume(client, ctx), FALLBACK_RUN_DISCOVERY_TIMEOUT_MS, `Fallback run discovery timed out after ${FALLBACK_RUN_DISCOVERY_TIMEOUT_MS}ms`);
 }
 async function discoverFallbackRunIdForResume(client, ctx) {
   const statuses = ["running"];
@@ -392627,7 +392323,7 @@ function formatMissingRequiredArgsReason(toolName, parsedArgs, missingRequiredAr
   }
   return base2;
 }
-function parseToolArgs2(rawArgs) {
+function parseToolArgs(rawArgs) {
   const raw2 = rawArgs ?? "";
   const trimmed = raw2.trim();
   if (!trimmed) {
@@ -392672,7 +392368,7 @@ async function classifyApprovals(approvals, opts = {}) {
       });
       continue;
     }
-    const argsParse = parseToolArgs2(approval.toolArgs);
+    const argsParse = parseToolArgs(approval.toolArgs);
     const parsedArgs = argsParse.parsedArgs;
     if (argsParse.parseFailed) {
       debugWarn("approval-classification", `Tool call ${approval.toolCallId} (${toolName}) had unparseable arguments ` + `(${argsParse.rawLength} chars); treating as empty`);
@@ -393592,8 +393288,15 @@ function isChatGPTByokHandleInModels(handle2, models3) {
   const entry = models3.find((m4) => m4.handle === handle2);
   return entry?.providerType === "chatgpt_oauth" && entry?.providerCategory === "byok";
 }
-async function resolveAgentModelHandle2(agentId) {
+async function resolveScopedModelHandle(agentId, conversationId) {
   try {
+    if (conversationId !== "default") {
+      const conversation = await getBackend().retrieveConversation(conversationId);
+      const conversationRecord = conversation;
+      if (typeof conversationRecord.model === "string" && conversationRecord.model.length > 0) {
+        return conversationRecord.model;
+      }
+    }
     const agent = await getBackend().retrieveAgent(agentId);
     const record3 = agent;
     if (typeof record3.model === "string" && record3.model.length > 0) {
@@ -393605,7 +393308,7 @@ async function resolveAgentModelHandle2(agentId) {
   }
 }
 async function rotateChatGPTPlanOnQuotaLimit(params) {
-  const { agentId, error: error4 } = params;
+  const { agentId, conversationId, error: error4, exhaustedProviders } = params;
   const parsedDetail = parseChatGPTUsageLimitDetail(error4);
   if (!parsedDetail)
     return null;
@@ -393620,9 +393323,9 @@ async function rotateChatGPTPlanOnQuotaLimit(params) {
   }
   if (!models3)
     return null;
-  let currentHandle = params.currentHandle;
+  let currentHandle = await resolveScopedModelHandle(agentId, conversationId);
   if (!currentHandle || !isChatGPTByokHandleInModels(currentHandle, models3)) {
-    currentHandle = await resolveAgentModelHandle2(agentId);
+    currentHandle = params.currentHandle;
   }
   if (!currentHandle || !isChatGPTByokHandleInModels(currentHandle, models3)) {
     return null;
@@ -393642,9 +393345,15 @@ async function rotateChatGPTPlanOnQuotaLimit(params) {
   if (!toProvider)
     return null;
   try {
-    await updateAgentLLMConfig(agentId, toHandle, {
-      provider_type: "chatgpt_oauth"
-    });
+    if (conversationId === "default") {
+      await updateAgentLLMConfig(agentId, toHandle, {
+        provider_type: "chatgpt_oauth"
+      });
+    } else {
+      await updateConversationLLMConfig(conversationId, toHandle, {
+        provider_type: "chatgpt_oauth"
+      });
+    }
   } catch {
     return null;
   }
@@ -393663,14 +393372,13 @@ function formatPlanRotationNotice(params) {
   })})` : "";
   return `${fromProvider} hit its usage limit${resetSuffix} — switched to ${toProvider}`;
 }
-var CHATGPT_PLAN_ROTATION_MAX_SWAPS_PER_TURN = 3, exhaustedProviders;
+var CHATGPT_PLAN_ROTATION_MAX_SWAPS_PER_TURN = 3;
 var init_chatgpt_plan_rotation = __esm(() => {
   init_available_models();
   init_model_handles();
   init_modify();
   init_turn_recovery_policy();
   init_backend2();
-  exhaustedProviders = new Set;
 });
 
 // src/websocket/listener/skill-injection.ts
@@ -403564,6 +403272,16 @@ var init_catalog = __esm(() => {
         "listen"
       ]
     },
+    {
+      id: "mcp-servers-info",
+      description: "MCP servers with tools available through letta mcp",
+      modes: [
+        "interactive",
+        "headless-one-shot",
+        "headless-bidirectional",
+        "listen"
+      ]
+    },
     {
       id: "permission-mode",
       description: "Permission mode reminder",
@@ -403599,6 +403317,167 @@ var init_catalog = __esm(() => {
   SHARED_REMINDER_BY_ID = new Map(SHARED_REMINDER_CATALOG.map((entry) => [entry.id, entry]));
 });
 
+// src/backend/api/unified-mcp.ts
+var exports_unified_mcp = {};
+__export(exports_unified_mcp, {
+  searchUnifiedMcpTools: () => searchUnifiedMcpTools,
+  runUnifiedMcpTool: () => runUnifiedMcpTool,
+  listUnifiedMcpTools: () => listUnifiedMcpTools,
+  listUnifiedMcpServers: () => listUnifiedMcpServers
+});
+function stringField2(value, key2) {
+  return typeof value[key2] === "string" ? value[key2] : null;
+}
+function recordField(value, ...names2) {
+  for (const name of names2) {
+    const field = value[name];
+    if (isRecord(field))
+      return field;
+  }
+  return;
+}
+function parseServer(value, registered) {
+  if (!isRecord(value))
+    return null;
+  const id2 = stringField2(value, "id");
+  const serverName = stringField2(value, "server_name") ?? (registered ? stringField2(registered, "server_name") : null);
+  const serverType = stringField2(value, "mcp_server_type") ?? (registered ? stringField2(registered, "mcp_server_type") : null) ?? "unknown";
+  if (!id2 || !serverName)
+    return null;
+  const serverUrl = stringField2(value, "server_url") ?? (registered ? stringField2(registered, "server_url") : null) ?? undefined;
+  const command = stringField2(value, "command") ?? (registered ? stringField2(registered, "command") : null) ?? undefined;
+  const argsValue = value.args ?? registered?.args;
+  const args = Array.isArray(argsValue) ? argsValue.filter((item) => typeof item === "string") : [];
+  const target2 = serverUrl ?? [command, ...args].filter(Boolean).join(" ");
+  return {
+    id: id2,
+    serverName,
+    serverType,
+    target: target2,
+    ...serverUrl ? { serverUrl } : {},
+    ...command ? { command, args } : {}
+  };
+}
+function parseTool(value) {
+  if (!isRecord(value))
+    return null;
+  const id2 = stringField2(value, "id");
+  const name = stringField2(value, "name");
+  if (!id2 || !name)
+    return null;
+  const description = stringField2(value, "description");
+  const jsonSchema = isRecord(value.json_schema) ? value.json_schema : {};
+  const inputSchema = isRecord(jsonSchema.parameters) ? jsonSchema.parameters : isRecord(value.args_json_schema) ? value.args_json_schema : { type: "object", properties: {} };
+  const title = stringField2(value, "title") ?? stringField2(jsonSchema, "title");
+  const outputSchema = recordField(value, "outputSchema", "output_schema") ?? recordField(jsonSchema, "outputSchema", "output_schema");
+  const annotations = recordField(value, "annotations") ?? recordField(jsonSchema, "annotations");
+  const execution = recordField(value, "execution") ?? recordField(jsonSchema, "execution");
+  const meta = recordField(value, "_meta") ?? recordField(jsonSchema, "_meta");
+  const iconsValue = value.icons ?? jsonSchema.icons;
+  const icons = Array.isArray(iconsValue) ? iconsValue.filter(isRecord) : undefined;
+  return {
+    id: id2,
+    name,
+    ...title ? { title } : {},
+    description,
+    inputSchema,
+    ...outputSchema ? { outputSchema } : {},
+    ...annotations ? { annotations } : {},
+    ...execution ? { execution } : {},
+    ...meta ? { _meta: meta } : {},
+    ...icons ? { icons } : {}
+  };
+}
+function parseRunResult(value) {
+  if (!isRecord(value))
+    throw new Error("Invalid MCP tool run response");
+  return {
+    status: stringField2(value, "status") ?? "unknown",
+    funcReturn: value.func_return,
+    stdout: value.stdout,
+    stderr: value.stderr
+  };
+}
+function parseSearchResult(value) {
+  if (!isRecord(value) || !isRecord(value.tool))
+    return null;
+  const toolId = stringField2(value.tool, "id");
+  const jsonSchema = value.tool.json_schema;
+  const score = value.combined_score;
+  if (!toolId || jsonSchema !== null && !isRecord(jsonSchema) || typeof score !== "number") {
+    return null;
+  }
+  return { toolId, jsonSchema, score };
+}
+async function withTimeout2(promise, timeoutMs, operation) {
+  let timer;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((_resolve, reject2) => {
+        timer = setTimeout(() => reject2(new Error(`${operation} timed out after ${timeoutMs}ms`)), timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timer)
+      clearTimeout(timer);
+  }
+}
+async function listUnifiedMcpServers(client, agentId, timeoutMs = 1e4) {
+  const value = await withTimeout2(client.get(`/v1/agents/${encodeURIComponent(agentId)}/mcp-servers`), timeoutMs, "Listing agent MCP servers");
+  if (!Array.isArray(value))
+    return [];
+  const needsEnrichment = value.some((item) => isRecord(item) && !stringField2(item, "mcp_server_type"));
+  const registeredById = new Map;
+  if (needsEnrichment && client.mcpServers) {
+    try {
+      const registered = await withTimeout2(client.mcpServers.list(), timeoutMs, "Listing registered MCP servers");
+      for (const item of registered) {
+        if (!isRecord(item))
+          continue;
+        const id2 = stringField2(item, "id");
+        if (id2)
+          registeredById.set(id2, item);
+      }
+    } catch {}
+  }
+  return value.map((item) => {
+    const registered = isRecord(item) ? registeredById.get(stringField2(item, "id") ?? "") : undefined;
+    return parseServer(item, registered);
+  }).filter((server2) => server2 !== null);
+}
+async function listUnifiedMcpTools(client, agentId, mcpServerId, timeoutMs = 1e4) {
+  const value = await withTimeout2(client.get(`/v1/agents/${encodeURIComponent(agentId)}/mcp-servers/${encodeURIComponent(mcpServerId)}/tools`), timeoutMs, "Listing agent MCP server tools");
+  if (!Array.isArray(value))
+    return [];
+  return value.map(parseTool).filter((tool) => tool !== null);
+}
+async function searchUnifiedMcpTools(params) {
+  const value = await withTimeout2(params.client.post(`/v1/agents/${encodeURIComponent(params.agentId)}/mcp-servers/tools/search`, {
+    body: {
+      query: params.query,
+      search_mode: params.searchMode,
+      limit: params.limit
+    }
+  }), params.timeoutMs ?? 60000, "Searching agent MCP tools");
+  if (!Array.isArray(value)) {
+    throw new Error("Invalid MCP tool search response");
+  }
+  const results = [];
+  for (const item of value) {
+    const result2 = parseSearchResult(item);
+    if (!result2)
+      throw new Error("Invalid MCP tool search result");
+    results.push(result2);
+  }
+  return results;
+}
+async function runUnifiedMcpTool(params) {
+  const value = await withTimeout2(params.client.post(`/v1/agents/${encodeURIComponent(params.agentId)}/mcp-servers/${encodeURIComponent(params.mcpServerId)}/tools/${encodeURIComponent(params.toolId)}/run`, { body: { args: params.args } }), params.timeoutMs ?? 60000, "Running agent MCP tool");
+  return parseRunResult(value);
+}
+var init_unified_mcp = () => {};
+
 // src/reminders/engine.ts
 async function buildAgentInfoReminder(context3) {
   if (!context3.systemInfoReminderEnabled || context3.state.hasSentAgentInfo) {
@@ -403658,6 +403537,80 @@ ${SYSTEM_REMINDER_CLOSE}`;
     return null;
   }
 }
+async function defaultListServerSideServers(agentId) {
+  let serverSideAvailable = false;
+  try {
+    const { getBackend: getBackend2 } = await Promise.resolve().then(() => (init_backend2(), exports_backend));
+    serverSideAvailable = getBackend2().capabilities.serverSideToolManagement;
+  } catch {
+    return null;
+  }
+  if (!serverSideAvailable) {
+    return null;
+  }
+  const { getClient: getClient2 } = await Promise.resolve().then(() => (init_client2(), exports_client));
+  const { getServerUrl: getServerUrl2 } = await Promise.resolve().then(() => (init_server_url(), exports_server_url));
+  const { LETTA_CLOUD_API_URL: LETTA_CLOUD_API_URL2 } = await Promise.resolve().then(() => (init_oauth(), exports_oauth));
+  const { listUnifiedMcpServers: listUnifiedMcpServers2, listUnifiedMcpTools: listUnifiedMcpTools2 } = await Promise.resolve().then(() => (init_unified_mcp(), exports_unified_mcp));
+  const client = await getClient2();
+  const allServers = await listUnifiedMcpServers2(client, agentId, 3000);
+  const servers = getServerUrl2() === LETTA_CLOUD_API_URL2 ? allServers.filter((server2) => server2.serverType !== "stdio") : allServers;
+  return Promise.all(servers.map(async (server2) => ({
+    name: server2.serverName,
+    toolCount: await listUnifiedMcpTools2(client, agentId, server2.id, 3000).then((tools) => tools.length).catch(() => null)
+  })));
+}
+function formatMcpServerEntry(entry) {
+  if (entry.toolCount === null) {
+    return entry.name;
+  }
+  return `${entry.name} (${entry.toolCount} ${entry.toolCount === 1 ? "tool" : "tools"})`;
+}
+async function buildMcpServersInfoReminderText(context3, deps = {}) {
+  try {
+    const now2 = Date.now();
+    const lastFetched = context3.state.lastMcpServersFetchedAtMs;
+    const due = !context3.state.hasSentMcpServersInfo || lastFetched === null || now2 - lastFetched > MCP_SERVERS_REFRESH_MS;
+    if (!due) {
+      return null;
+    }
+    context3.state.lastMcpServersFetchedAtMs = now2;
+    const localNames = (deps.getLocalServerNames ?? ((agentId) => settingsManager.getMcpServers(agentId).map((server2) => server2.name)))(context3.agent.id);
+    const entries = localNames.map((name) => ({
+      name,
+      toolCount: null
+    }));
+    const serverSideEntries = await (deps.listServerSideServers ?? defaultListServerSideServers)(context3.agent.id);
+    if (serverSideEntries) {
+      entries.push(...serverSideEntries);
+    }
+    const uniqueEntries = [
+      ...new Map(entries.map((entry) => [entry.name, entry])).values()
+    ];
+    const namesKey = uniqueEntries.map((entry) => `${entry.name}\x01${entry.toolCount ?? ""}`).join("\x00");
+    if (context3.state.hasSentMcpServersInfo && context3.state.lastSentMcpServerNamesKey === namesKey) {
+      return null;
+    }
+    context3.state.hasSentMcpServersInfo = true;
+    context3.state.lastSentMcpServerNamesKey = namesKey;
+    if (uniqueEntries.length === 0) {
+      return `${SYSTEM_REMINDER_OPEN}
+MCP servers with available tools: None
+${SYSTEM_REMINDER_CLOSE}`;
+    }
+    const rendered = uniqueEntries.map(formatMcpServerEntry).join(", ");
+    return `${SYSTEM_REMINDER_OPEN}
+MCP servers with available tools: ${rendered}
+Find tools (with schemas) with \`letta mcp search "<what you want to do>"\`, list one server's tools with \`letta mcp tools <server>\` (\`--full\` includes schemas, \`letta mcp schema <tool-name>\` fetches one), and invoke one with \`letta mcp call <tool-name> --args '{"key":"value"}'\`.
+${SYSTEM_REMINDER_CLOSE}`;
+  } catch (error4) {
+    debugLog("mcp", `Failed to build MCP servers reminder: ${error4 instanceof Error ? error4.message : String(error4)}`);
+    return null;
+  }
+}
+async function buildMcpServersInfoReminder(context3) {
+  return buildMcpServersInfoReminderText(context3);
+}
 async function buildSessionContextReminder(context3) {
   if (!context3.systemInfoReminderEnabled || context3.state.hasSentSessionContext) {
     return null;
@@ -403853,7 +403806,7 @@ function prependReminderPartsToContent(content, reminderParts) {
   }
   return [...reminderParts, { type: "text", text: text2 }];
 }
-var PERMISSION_MODE_DESCRIPTIONS, MAX_COMMAND_REMINDERS_PER_TURN = 10, MAX_TOOLSET_REMINDERS_PER_TURN = 5, MAX_COMMAND_INPUT_CHARS = 2000, MAX_COMMAND_OUTPUT_CHARS = 4000, MAX_TOOL_LIST_CHARS = 3000, sharedReminderProviders;
+var MCP_SERVERS_REFRESH_MS = 300000, PERMISSION_MODE_DESCRIPTIONS, MAX_COMMAND_REMINDERS_PER_TURN = 10, MAX_TOOLSET_REMINDERS_PER_TURN = 5, MAX_COMMAND_INPUT_CHARS = 2000, MAX_COMMAND_OUTPUT_CHARS = 4000, MAX_TOOL_LIST_CHARS = 3000, sharedReminderProviders;
 var init_engine3 = __esm(() => {
   init_agent_info();
   init_conversation_bootstrap();
@@ -403874,6 +403827,7 @@ var init_engine3 = __esm(() => {
     "agent-info": buildAgentInfoReminder,
     "conversation-bootstrap": buildConversationBootstrapReminderPart,
     "secrets-info": buildSecretsInfoReminder,
+    "mcp-servers-info": buildMcpServersInfoReminder,
     "session-context": buildSessionContextReminder,
     "permission-mode": buildPermissionModeReminder,
     "memory-git-sync": buildMemoryGitSyncReminder,
@@ -404322,6 +404276,7 @@ async function handleIncomingMessageInner(msg, socket, runtime, onStatusChange,
   const turnWorkingDirectory = getConversationWorkingDirectory(runtime.listener, agentId, conversationId);
   const turnPermissionModeState = getOrCreateConversationPermissionModeStateRef(runtime.listener, agentId, conversationId);
   let postStopApprovalRecoveryRetries = 0, llmApiErrorRetries = 0, emptyResponseRetries = 0, chatgptPlanSwaps = 0, lastApprovalContinuationAccepted = false, activeDequeuedBatchId = dequeuedBatchId;
+  const chatgptExhaustedProviders = new Set;
   const turnCorrelation = existingTurnCorrelation ?? createTurnCorrelation(runtime, msg, activeDequeuedBatchId);
   const msgRunIds = [];
   let lastExecutionResults = null;
@@ -404688,8 +404643,10 @@ async function handleIncomingMessageInner(msg, socket, runtime, onStatusChange,
         if (agentId && chatgptPlanSwaps < CHATGPT_PLAN_ROTATION_MAX_SWAPS_PER_TURN) {
           const rotation = await rotateChatGPTPlanOnQuotaLimit({
             agentId,
+            conversationId,
             currentHandle: null,
-            error: quotaError
+            error: quotaError,
+            exhaustedProviders: chatgptExhaustedProviders
           });
           if (rotation) {
             chatgptPlanSwaps += 1;
@@ -407712,11 +407669,11 @@ function scheduleRemoteRestart(connectionName, log2) {
     log2(`restart skipped (entrypoint=${entrypoint ?? "missing"}, connectionName=${connectionName ?? "missing"})`);
     return;
   }
-  log2(`scheduling remote listener restart for env ${connectionName}`);
+  log2(`scheduling remote listener restart for computer ${connectionName}`);
   setTimeout(async () => {
     await flushRemoteSettingsWrites();
-    log2(`spawning replacement listener: ${process.execPath} ${entrypoint} remote --env-name ${connectionName}`);
-    const child = spawn9(process.execPath, [entrypoint, "remote", "--env-name", connectionName], {
+    log2(`spawning replacement listener: ${process.execPath} ${entrypoint} remote --computer-name ${connectionName}`);
+    const child = spawn9(process.execPath, [entrypoint, "remote", "--computer-name", connectionName], {
       cwd: process.cwd(),
       detached: true,
       env: process.env,
@@ -408217,7 +408174,7 @@ function getNumber(record3, keys3) {
   }
   return null;
 }
-function getString2(record3, keys3) {
+function getString(record3, keys3) {
   const value = getValue(record3, keys3);
   if (typeof value === "string" && value.trim())
     return value.trim();
@@ -408303,7 +408260,7 @@ function normalizeCredits(raw2, rateLimit) {
   const resetCredits = getRecord(raw2, ["rate_limit_reset_credits", "rateLimitResetCredits"]) ?? getRecord(rateLimit, ["rate_limit_reset_credits", "rateLimitResetCredits"]);
   if (!credits && !resetCredits)
     return null;
-  const balance = getString2(credits, ["balance", "credit_balance", "amount"]);
+  const balance = getString(credits, ["balance", "credit_balance", "amount"]);
   const availableCount = getNumber(credits, ["available_count", "availableCount", "count"]) ?? getNumber(resetCredits, ["available_count", "availableCount", "count"]);
   const hasCredits = getBoolean(credits, ["has_credits", "hasCredits"]);
   const unlimited = getBoolean(credits, ["unlimited", "is_unlimited"]);
@@ -408322,8 +408279,8 @@ function normalizeIndividualLimit(raw2, nowMs) {
   const record3 = getRecord(raw2, ["individual_limit", "individualLimit"]) ?? getRecord(spendControl, ["individual_limit", "individualLimit"]);
   if (!record3)
     return null;
-  const limit3 = getString2(record3, ["limit"]);
-  const used = getString2(record3, ["used"]);
+  const limit3 = getString(record3, ["limit"]);
+  const used = getString(record3, ["used"]);
   const remainingPercent = getNumber(record3, [
     "remaining_percent",
     "remainingPercent"
@@ -408352,10 +408309,10 @@ function normalizeCloudUsageWindow(value, fallbackLabel, nowMs) {
   const record3 = asRecord8(value);
   if (!record3)
     return null;
-  return normalizeUsageWindow(record3, getString2(record3, ["label", "name"]) ?? fallbackLabel, nowMs);
+  return normalizeUsageWindow(record3, getString(record3, ["label", "name"]) ?? fallbackLabel, nowMs);
 }
 function normalizeAdditionalRateLimit(details, index, nowMs) {
-  const label = getString2(details, [
+  const label = getString(details, [
     "limit_name",
     "limitName",
     "metered_feature",
@@ -408381,7 +408338,7 @@ function getRateLimitReachedType(raw2) {
   if (typeof value === "string" && value.trim())
     return value.trim();
   const record3 = asRecord8(value);
-  return getString2(record3, ["type", "kind"]);
+  return getString(record3, ["type", "kind"]);
 }
 function formatPercent(value) {
   const rounded = Math.round(value);
@@ -408496,7 +408453,7 @@ function normalizeWhamUsageResponse(input) {
   const snapshotWithoutSummary = {
     providerName: input.providerName,
     fetchedAt,
-    planType: getString2(raw2, ["plan_type", "planType"]),
+    planType: getString(raw2, ["plan_type", "planType"]),
     limitReached: getBoolean(rateLimit, ["limit_reached", "limitReached"]) ?? getBoolean(spendControl, ["reached"]),
     rateLimitReachedType: getRateLimitReachedType(raw2),
     primary,
@@ -408515,18 +408472,18 @@ function normalizeCloudChatGPTUsageResponse(input) {
   if (!raw2)
     return null;
   const nowMs = input.nowMs ?? Date.now();
-  const fetchedAt = getString2(raw2, ["fetchedAt", "fetched_at"]) ?? new Date(nowMs).toISOString();
+  const fetchedAt = getString(raw2, ["fetchedAt", "fetched_at"]) ?? new Date(nowMs).toISOString();
   const additional = getRecordArray(raw2, [
     "additional",
     "additional_rate_limits",
     "additionalRateLimits"
   ]).map((window2, index) => normalizeCloudUsageWindow(window2, `limit ${index + 1}`, nowMs)).filter((window2) => !!window2);
   const snapshotWithoutSummary = {
-    providerName: getString2(raw2, ["providerName", "provider_name"]) ?? input.providerName,
+    providerName: getString(raw2, ["providerName", "provider_name"]) ?? input.providerName,
     fetchedAt,
-    planType: getString2(raw2, ["planType", "plan_type"]),
+    planType: getString(raw2, ["planType", "plan_type"]),
     limitReached: getBoolean(raw2, ["limitReached", "limit_reached"]),
-    rateLimitReachedType: getString2(raw2, [
+    rateLimitReachedType: getString(raw2, [
       "rateLimitReachedType",
       "rate_limit_reached_type"
     ]),
@@ -408538,7 +408495,7 @@ function normalizeCloudChatGPTUsageResponse(input) {
   };
   return {
     ...snapshotWithoutSummary,
-    summary: getString2(raw2, ["summary"]) ?? formatChatGPTUsageSnapshot(snapshotWithoutSummary, new Date(nowMs))
+    summary: getString(raw2, ["summary"]) ?? formatChatGPTUsageSnapshot(snapshotWithoutSummary, new Date(nowMs))
   };
 }
 function retryAfterMs(response) {
@@ -408563,7 +408520,7 @@ async function readJsonRecord(response) {
   }
 }
 function responseMessage(raw2, fallback) {
-  return getString2(raw2 ?? undefined, ["message", "error", "detail"]) ?? fallback;
+  return getString(raw2 ?? undefined, ["message", "error", "detail"]) ?? fallback;
 }
 function chatGPTUsageError(code2, message, retryAfter) {
   return {
@@ -412332,7 +412289,7 @@ var init_app_server_openai_common = __esm(() => {
 function asRecord9(value) {
   return value !== null && typeof value === "object" ? value : null;
 }
-function stringValue4(value) {
+function stringValue3(value) {
   return typeof value === "string" ? value : undefined;
 }
 function extractToolCallFragments(record3) {
@@ -412346,12 +412303,12 @@ function extractToolCallFragments(record3) {
     if (!toolCall) {
       continue;
     }
-    const toolCallId = stringValue4(toolCall.tool_call_id);
+    const toolCallId = stringValue3(toolCall.tool_call_id);
     if (!toolCallId) {
       continue;
     }
-    const name = stringValue4(toolCall.name) ?? null;
-    const argumentsDelta = stringValue4(toolCall.arguments) ?? null;
+    const name = stringValue3(toolCall.name) ?? null;
+    const argumentsDelta = stringValue3(toolCall.arguments) ?? null;
     fragments.push({ toolCallId, name, argumentsDelta });
   }
   return fragments;
@@ -412391,7 +412348,7 @@ function extractToolReturns(record3) {
       if (!rec) {
         continue;
       }
-      const toolCallId = stringValue4(rec.tool_call_id);
+      const toolCallId = stringValue3(rec.tool_call_id);
       const status = asToolReturnStatus2(rec.status);
       if (!toolCallId || !status) {
         continue;
@@ -412406,7 +412363,7 @@ function extractToolReturns(record3) {
       return results;
     }
   }
-  const topLevelToolCallId = stringValue4(record3.tool_call_id);
+  const topLevelToolCallId = stringValue3(record3.tool_call_id);
   const topLevelStatus = asToolReturnStatus2(record3.status);
   if (!topLevelToolCallId || !topLevelStatus) {
     return [];
@@ -412494,13 +412451,13 @@ function createToolLifecycleTracker(onEvent) {
       return;
     }
     const record3 = delta2;
-    const messageType = stringValue4(record3.message_type);
-    const toolCallId = stringValue4(record3.tool_call_id);
+    const messageType = stringValue3(record3.message_type);
+    const toolCallId = stringValue3(record3.tool_call_id);
     if (messageType === "client_tool_start" && toolCallId) {
       const state = getOrCreate(toolCallId);
       state.clientManaged = true;
       if (!state.name)
-        state.name = stringValue4(record3.tool_name) ?? null;
+        state.name = stringValue3(record3.tool_name) ?? null;
       return;
     }
     if (messageType === "client_tool_end" && toolCallId) {
@@ -414087,7 +414044,7 @@ var init_gateway_supervisor = __esm(() => {
 
 // src/cli/subcommands/listen.tsx
 import { hostname as hostname4 } from "node:os";
-import { parseArgs as parseArgs9 } from "node:util";
+import { parseArgs as parseArgs8 } from "node:util";
 import { MessageChannel as MessageChannel2 } from "node:worker_threads";
 function PromptEnvName(props) {
   const [value, setValue] = import_react33.useState("");
@@ -414095,7 +414052,7 @@ function PromptEnvName(props) {
     flexDirection: "column",
     children: [
       /* @__PURE__ */ jsx_dev_runtime13.jsxDEV(Text, {
-        children: "Enter environment name (or press Enter for hostname): "
+        children: "Enter computer name (or press Enter for hostname): "
       }, undefined, false, undefined, this),
       /* @__PURE__ */ jsx_dev_runtime13.jsxDEV(build_default, {
         value,
@@ -414172,14 +414129,14 @@ function shouldAcquireStandaloneListenerLock() {
   return shouldAcquireManualListenerLock(getSpawnerListenerInstanceId(), process.env.LETTA_DESKTOP_MODE === "1");
 }
 function printListenUsage() {
-  console.log(`Usage: letta server [--env-name <name>] [--channels <list>] [--skills <path>] [--debug]
+  console.log(`Usage: letta server [--computer-name <name>] [--channels <list>] [--skills <path>] [--debug]
 `);
-  console.log(`Register this letta-code instance to receive messages from Letta Cloud.
+  console.log(`Register this computer to receive messages from Letta Cloud.
 `);
   console.log("Options:");
-  console.log("  --env-name <name>  Friendly name for this environment (uses hostname if not provided)");
+  console.log("  --computer-name <name>  Friendly name for this computer (uses hostname if not provided)");
   console.log("  --channels <list>  Comma-separated channel names to enable (e.g. telegram)");
-  console.log("  --skills <path>     Use this directory for environment-provided skills");
+  console.log("  --skills <path>     Use this directory for computer-provided skills");
   console.log("  --install-channel-runtimes  Install missing runtime deps for the selected channels before startup");
   console.log("  --debug            Plain-text mode: log all WebSocket events instead of interactive UI");
   console.log(`  -h, --help         Show this help message
@@ -414187,20 +414144,20 @@ function printListenUsage() {
   console.log("Examples:");
   console.log("  letta channels configure telegram          # Configure Telegram first");
   console.log("  letta server                              # Uses hostname as default");
-  console.log('  letta server --env-name "work-laptop"');
+  console.log('  letta server --computer-name "work-laptop"');
   console.log("  letta server --channels telegram           # Enable Telegram channel");
   console.log("  letta server --channels telegram --install-channel-runtimes");
   console.log(`  letta server --debug                       # Log all WS events
 `);
   console.log("Once connected, this instance will listen for incoming messages from cloud agents.");
-  console.log("Messages will be executed locally using your letta-code environment.");
+  console.log("Messages will be executed locally on this computer.");
   console.log("Telegram flow: configure the bot, start the listener with --channels telegram,");
   console.log("then message the bot from Telegram and run /channels telegram pair <code> in the target conversation.");
 }
 async function runListenSubcommand(argv) {
   let values3;
   try {
-    ({ values: values3 } = parseArgs9({
+    ({ values: values3 } = parseArgs8({
       args: argv,
       options: LISTEN_OPTIONS,
       strict: true,
@@ -414282,8 +414239,9 @@ async function runListenSubcommand(argv) {
   const restoreAgentScope = restoreEnabledChannels ? resolveChannelRestoreAgentScope(scopedRestoreAgentScope) : null;
   const channelNames = values3.channels ? values3.channels.split(",").map((s3) => s3.trim()).filter(Boolean) : [];
   let connectionName;
-  if (values3["env-name"]) {
-    connectionName = values3["env-name"];
+  const explicitComputerName = values3["computer-name"] ?? values3["env-name"];
+  if (explicitComputerName) {
+    connectionName = explicitComputerName;
     settingsManager.setListenerEnvName(connectionName);
   } else {
     const savedName = settingsManager.getListenerEnvName();
@@ -414312,7 +414270,7 @@ async function runListenSubcommand(argv) {
     const startupMode = await resolveListenerStartupMode(channelNames, channelNames.length > 0 || restoreEnabledChannels);
     if (startupMode.kind === "unsupported-self-hosted") {
       console.error(`Self-hosted listener registration is not available for ${startupMode.serverUrl}.`);
-      console.error("Start with --channels to run local channel adapters, or unset LETTA_BASE_URL to use Letta API remote environments.");
+      console.error("Start with --channels to run local channel adapters, or unset LETTA_BASE_URL to use Letta API remote computers.");
       await flushListenerTelemetryEnd("listener_self_hosted_no_channels");
       return 1;
     }
@@ -414344,8 +414302,8 @@ async function runListenSubcommand(argv) {
           });
         } catch (lockError) {
           if (lockError instanceof ManualListenerAlreadyRunningError) {
-            console.error(`A letta server for environment "${connectionName}" is already running on this machine (pid ${lockError.holderPid}).`);
-            console.error("Stop that process, or choose a different logical listener with --env-name.");
+            console.error(`A letta server for computer "${connectionName}" is already running on this machine (pid ${lockError.holderPid}).`);
+            console.error("Stop that process, or choose a different logical listener with --computer-name.");
             console.error(`Lock: ${lockError.lockPath}`);
             await flushListenerTelemetryEnd("listener_already_running");
             return 1;
@@ -414434,9 +414392,9 @@ async function runListenSubcommand(argv) {
       const connectionId2 = `local-${deviceId}`;
       const startupLabel = startupMode.backend === "local" ? "local backend" : `self-hosted server ${startupMode.serverUrl}`;
       sessionLog.log(`Starting local channel listener for ${startupLabel}`);
-      sessionLog.log("Skipping environment registration");
+      sessionLog.log("Skipping computer registration");
       console.log(`Starting local channel listener for ${startupLabel}`);
-      console.log(`Skipping environment registration. Press Ctrl+C to stop.
+      console.log(`Skipping computer registration. Press Ctrl+C to stop.
 `);
       const { startLocalChannelListener: startLocalChannelListener2 } = await init_listen_client().then(() => exports_listen_client);
       await startLocalChannelListener2({
@@ -414558,7 +414516,7 @@ async function runListenSubcommand(argv) {
             console.log(`[${formatTimestamp3()}] Reconnecting (attempt ${attempt2}, retry in ${Math.round(nextRetryIn / 1000)}s)`);
           },
           onNeedsReregister: async () => {
-            console.log(`[${formatTimestamp3()}] Environment expired, re-registering...`);
+            console.log(`[${formatTimestamp3()}] Computer connection expired, re-registering...`);
             try {
               const result2 = await reregister();
               await startDebugClient(result2.connectionId, result2.wsUrl, result2.supportsSplitStatusChannels, result2.supportsPairedListenerGenerations);
@@ -414626,7 +414584,7 @@ async function runListenSubcommand(argv) {
             updateRetryStatusCallback?.(attempt2, nextRetryIn);
           },
           onNeedsReregister: async () => {
-            sessionLog.log("Environment expired, re-registering...");
+            sessionLog.log("Computer connection expired, re-registering...");
             try {
               const result2 = await reregister();
               await startNormalClient(result2.connectionId, result2.wsUrl, result2.supportsSplitStatusChannels, result2.supportsPairedListenerGenerations);
@@ -414695,6 +414653,7 @@ var init_listen = __esm(async () => {
   jsx_dev_runtime13 = __toESM(require_jsx_dev_runtime(), 1);
   activeListenerProcessAnchors = new Set;
   LISTEN_OPTIONS = {
+    "computer-name": { type: "string" },
     "env-name": { type: "string" },
     channels: { type: "string" },
     skills: { type: "string" },
@@ -415108,15 +415067,15 @@ var init_transcript_migration = __esm(() => {
 });
 
 // src/cli/subcommands/local-backend.ts
-import { parseArgs as parseArgs10 } from "node:util";
+import { parseArgs as parseArgs9 } from "node:util";
 function parseLocalBackendArgs(argv) {
-  return parseArgs10({
+  return parseArgs9({
     args: argv,
     options: LOCAL_BACKEND_OPTIONS,
     strict: true
   });
 }
-function printUsage8() {
+function printUsage7() {
   console.log(`
 Usage:
   letta local-backend migrate-transcripts [--storage-dir <path>] [--dry-run]
@@ -415129,12 +415088,12 @@ before it is replaced.
 async function runLocalBackendSubcommand(argv) {
   const [command, ...rest4] = argv;
   if (!command || command === "help" || command === "--help" || command === "-h") {
-    printUsage8();
+    printUsage7();
     return command ? 0 : 1;
   }
   if (command !== "migrate-transcripts") {
     console.error(`Unknown local-backend command: ${command}`);
-    printUsage8();
+    printUsage7();
     return 1;
   }
   let parsed;
@@ -415143,11 +415102,11 @@ async function runLocalBackendSubcommand(argv) {
   } catch (error4) {
     const message = error4 instanceof Error ? error4.message : String(error4);
     console.error(`Error: ${message}`);
-    printUsage8();
+    printUsage7();
     return 1;
   }
   if (parsed.values.help) {
-    printUsage8();
+    printUsage7();
     return 0;
   }
   const storageDir = parsed.values["storage-dir"] ?? getLocalBackendStorageDir();
@@ -415169,160 +415128,6 @@ var init_local_backend2 = __esm(() => {
   };
 });
 
-// src/backend/api/unified-mcp.ts
-function stringField2(value, key2) {
-  return typeof value[key2] === "string" ? value[key2] : null;
-}
-function recordField(value, ...names2) {
-  for (const name of names2) {
-    const field = value[name];
-    if (isRecord(field))
-      return field;
-  }
-  return;
-}
-function parseServer(value, registered) {
-  if (!isRecord(value))
-    return null;
-  const id2 = stringField2(value, "id");
-  const serverName = stringField2(value, "server_name") ?? (registered ? stringField2(registered, "server_name") : null);
-  const serverType = stringField2(value, "mcp_server_type") ?? (registered ? stringField2(registered, "mcp_server_type") : null) ?? "unknown";
-  if (!id2 || !serverName)
-    return null;
-  const serverUrl = stringField2(value, "server_url") ?? (registered ? stringField2(registered, "server_url") : null) ?? undefined;
-  const command = stringField2(value, "command") ?? (registered ? stringField2(registered, "command") : null) ?? undefined;
-  const argsValue = value.args ?? registered?.args;
-  const args = Array.isArray(argsValue) ? argsValue.filter((item) => typeof item === "string") : [];
-  const target2 = serverUrl ?? [command, ...args].filter(Boolean).join(" ");
-  return {
-    id: id2,
-    serverName,
-    serverType,
-    target: target2,
-    ...serverUrl ? { serverUrl } : {},
-    ...command ? { command, args } : {}
-  };
-}
-function parseTool(value) {
-  if (!isRecord(value))
-    return null;
-  const id2 = stringField2(value, "id");
-  const name = stringField2(value, "name");
-  if (!id2 || !name)
-    return null;
-  const description = stringField2(value, "description");
-  const jsonSchema = isRecord(value.json_schema) ? value.json_schema : {};
-  const inputSchema = isRecord(jsonSchema.parameters) ? jsonSchema.parameters : isRecord(value.args_json_schema) ? value.args_json_schema : { type: "object", properties: {} };
-  const title = stringField2(value, "title") ?? stringField2(jsonSchema, "title");
-  const outputSchema = recordField(value, "outputSchema", "output_schema") ?? recordField(jsonSchema, "outputSchema", "output_schema");
-  const annotations = recordField(value, "annotations") ?? recordField(jsonSchema, "annotations");
-  const execution = recordField(value, "execution") ?? recordField(jsonSchema, "execution");
-  const meta = recordField(value, "_meta") ?? recordField(jsonSchema, "_meta");
-  const iconsValue = value.icons ?? jsonSchema.icons;
-  const icons = Array.isArray(iconsValue) ? iconsValue.filter(isRecord) : undefined;
-  return {
-    id: id2,
-    name,
-    ...title ? { title } : {},
-    description,
-    inputSchema,
-    ...outputSchema ? { outputSchema } : {},
-    ...annotations ? { annotations } : {},
-    ...execution ? { execution } : {},
-    ...meta ? { _meta: meta } : {},
-    ...icons ? { icons } : {}
-  };
-}
-function parseRunResult(value) {
-  if (!isRecord(value))
-    throw new Error("Invalid MCP tool run response");
-  return {
-    status: stringField2(value, "status") ?? "unknown",
-    funcReturn: value.func_return,
-    stdout: value.stdout,
-    stderr: value.stderr
-  };
-}
-function parseSearchResult(value) {
-  if (!isRecord(value) || !isRecord(value.tool))
-    return null;
-  const toolId = stringField2(value.tool, "id");
-  const jsonSchema = value.tool.json_schema;
-  const score = value.combined_score;
-  if (!toolId || jsonSchema !== null && !isRecord(jsonSchema) || typeof score !== "number") {
-    return null;
-  }
-  return { toolId, jsonSchema, score };
-}
-async function withTimeout3(promise, timeoutMs, operation) {
-  let timer;
-  try {
-    return await Promise.race([
-      promise,
-      new Promise((_resolve, reject2) => {
-        timer = setTimeout(() => reject2(new Error(`${operation} timed out after ${timeoutMs}ms`)), timeoutMs);
-      })
-    ]);
-  } finally {
-    if (timer)
-      clearTimeout(timer);
-  }
-}
-async function listUnifiedMcpServers(client, agentId, timeoutMs = 1e4) {
-  const value = await withTimeout3(client.get(`/v1/agents/${encodeURIComponent(agentId)}/mcp-servers`), timeoutMs, "Listing agent MCP servers");
-  if (!Array.isArray(value))
-    return [];
-  const needsEnrichment = value.some((item) => isRecord(item) && !stringField2(item, "mcp_server_type"));
-  const registeredById = new Map;
-  if (needsEnrichment && client.mcpServers) {
-    try {
-      const registered = await withTimeout3(client.mcpServers.list(), timeoutMs, "Listing registered MCP servers");
-      for (const item of registered) {
-        if (!isRecord(item))
-          continue;
-        const id2 = stringField2(item, "id");
-        if (id2)
-          registeredById.set(id2, item);
-      }
-    } catch {}
-  }
-  return value.map((item) => {
-    const registered = isRecord(item) ? registeredById.get(stringField2(item, "id") ?? "") : undefined;
-    return parseServer(item, registered);
-  }).filter((server2) => server2 !== null);
-}
-async function listUnifiedMcpTools(client, agentId, mcpServerId, timeoutMs = 1e4) {
-  const value = await withTimeout3(client.get(`/v1/agents/${encodeURIComponent(agentId)}/mcp-servers/${encodeURIComponent(mcpServerId)}/tools`), timeoutMs, "Listing agent MCP server tools");
-  if (!Array.isArray(value))
-    return [];
-  return value.map(parseTool).filter((tool) => tool !== null);
-}
-async function searchUnifiedMcpTools(params) {
-  const value = await withTimeout3(params.client.post(`/v1/agents/${encodeURIComponent(params.agentId)}/mcp-servers/tools/search`, {
-    body: {
-      query: params.query,
-      search_mode: params.searchMode,
-      limit: params.limit
-    }
-  }), params.timeoutMs ?? 60000, "Searching agent MCP tools");
-  if (!Array.isArray(value)) {
-    throw new Error("Invalid MCP tool search response");
-  }
-  const results = [];
-  for (const item of value) {
-    const result2 = parseSearchResult(item);
-    if (!result2)
-      throw new Error("Invalid MCP tool search result");
-    results.push(result2);
-  }
-  return results;
-}
-async function runUnifiedMcpTool(params) {
-  const value = await withTimeout3(params.client.post(`/v1/agents/${encodeURIComponent(params.agentId)}/mcp-servers/${encodeURIComponent(params.mcpServerId)}/tools/${encodeURIComponent(params.toolId)}/run`, { body: { args: params.args } }), params.timeoutMs ?? 60000, "Running agent MCP tool");
-  return parseRunResult(value);
-}
-var init_unified_mcp = () => {};
-
 // node_modules/pkce-challenge/dist/index.node.js
 async function getRandomValues(size2) {
   return (await crypto2).getRandomValues(new Uint8Array(size2));
@@ -432165,7 +431970,7 @@ var init_mcp_client = __esm(() => {
   init_streamableHttp();
   DEFAULT_CLIENT_INFO = {
     name: "letta-code",
-    version: "0.31.10"
+    version: "0.31.12"
   };
 });
 
@@ -432453,7 +432258,6 @@ async function replaceClientMcpServers(agentId, configs, options = {}) {
   const generation2 = ++runtime.generation;
   await closeActiveServers(runtime);
   runtime.agentId = agentId;
-  const usedToolNames = new Set;
   const states2 = await Promise.all(configs.map(async (config2) => {
     let oauth;
     try {
@@ -432472,20 +432276,8 @@ async function replaceClientMcpServers(agentId, configs, options = {}) {
         await connection.close();
         return { config: config2, status: "failed", tools: [], error: "Superseded" };
       }
-      const tools = connection.tools.map((tool) => {
-        const name = uniqueToolName(formatClientMcpToolName(config2.name, tool.name), usedToolNames);
-        const definition = {
-          name,
-          label: tool.title ?? tool.name,
-          description: tool.description ?? `Tool ${tool.name} from MCP server ${config2.name}`,
-          parameters: tool.inputSchema,
-          executor: async (_toolCallId, _toolName, input) => toExternalToolResult(await connection.callTool(tool.name, input))
-        };
-        return definition;
-      });
-      registerExternalTools(tools);
-      runtime.active.set(config2.name, { connection, tools });
-      return { config: config2, status: "connected", tools };
+      runtime.active.set(config2.name, { connection });
+      return { config: config2, status: "connected", tools: connection.tools };
     } catch (error5) {
       return {
         config: config2,
@@ -432533,23 +432325,11 @@ async function closeActiveServers(runtime) {
   runtime.pendingOAuth.clear();
   runtime.active.clear();
   runtime.states = [];
-  for (const server2 of active)
-    unregisterExternalTools(server2.tools);
   await Promise.allSettled([
     ...pendingOAuth.map((oauth) => oauth.close()),
     ...active.map((server2) => server2.connection.close())
   ]);
 }
-function uniqueToolName(base2, used) {
-  let name = base2;
-  let suffix = 2;
-  while (used.has(name)) {
-    name = `${base2}_${suffix}`;
-    suffix++;
-  }
-  used.add(name);
-  return name;
-}
 function formatClientMcpToolName(serverName, toolName) {
   return `mcp__${normalizeMcpName(serverName)}__${normalizeMcpName(toolName)}`;
 }
@@ -432557,35 +432337,10 @@ function normalizeMcpName(value) {
   const normalized = value.replace(/[^a-zA-Z0-9_-]/g, "_");
   return normalized || "tool";
 }
-function toExternalToolResult(result2) {
-  return {
-    content: result2.content.map((item) => normalizeContent2(item)),
-    isError: result2.isError === true
-  };
-}
-function normalizeContent2(item) {
-  if (isRecord17(item)) {
-    if (item.type === "text" && typeof item.text === "string") {
-      return { type: "text", text: item.text };
-    }
-    if ((item.type === "image" || item.type === "audio") && typeof item.data === "string") {
-      return {
-        type: item.type,
-        data: item.data,
-        ...typeof item.mimeType === "string" ? { mimeType: item.mimeType } : {}
-      };
-    }
-  }
-  return { type: "text", text: JSON.stringify(item) };
-}
-function isRecord17(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 var CLIENT_MCP_RUNTIME_KEY;
-var init_mcp_runtime = __esm(async () => {
+var init_mcp_runtime = __esm(() => {
   init_mcp_client();
   init_mcp_oauth();
-  await init_manager4();
   CLIENT_MCP_RUNTIME_KEY = Symbol.for("@letta/clientMcpRuntime");
 });
 
@@ -432606,20 +432361,23 @@ function printMcpUsage(stdout) {
 Usage:
   letta mcp list [--agent <id>]
   letta mcp get <server> [--agent <id>]
-  letta mcp tools [server] [--agent <id>]
+  letta mcp tools [server] [--full] [--agent <id>]
+  letta mcp schema <tool-name> [--agent <id>]
   letta mcp search <query> [--mode <hybrid|vector|fts>] [--limit <n>] [--agent <id>]
   letta mcp call <tool-name> [--args '<json>' | --args-file <path|->] [--agent <id>]
 
 Commands:
   list      List MCP servers available to the agent
   get       Print one server's redacted connection configuration
-  tools     Print complete MCP tool schemas; names are accepted by call
+  tools     List tool names and descriptions; names are accepted by call
+  schema    Print one tool's complete schema
   search    Search tools available to the agent
   call      Call one exact tool name and print an MCP CallToolResult
 
 Options:
   --agent <id>       Agent ID. Defaults to LETTA_AGENT_ID or AGENT_ID
   --agent-id <id>    Alias for --agent
+  --full             Include complete schemas in tools output
   --mode <mode>      Search mode: hybrid (default), vector, or fts
   --limit <n>        Search result limit from 1 to 100 (default: 5)
   --args <json>      JSON object passed to a tool
@@ -432823,14 +432581,21 @@ function formatServerMcpToolName(serverName, alias, toolName) {
   const rawName = toolName.startsWith(sourcePrefix) ? toolName.slice(sourcePrefix.length) : toolName;
   return formatClientMcpToolName(alias, rawName);
 }
-var init_mcp_tool_names = __esm(async () => {
-  await init_mcp_runtime();
+var init_mcp_tool_names = __esm(() => {
+  init_mcp_runtime();
 });
 
 // src/cli/subcommands/mcp.ts
-import { parseArgs as parseArgs11 } from "node:util";
+import { parseArgs as parseArgs10 } from "node:util";
+function defaultIsHostedLettaCloud() {
+  try {
+    return getServerUrl() === LETTA_CLOUD_API_URL;
+  } catch {
+    return !process.env.LETTA_BASE_URL;
+  }
+}
 function parseMcpArgs(argv) {
-  return parseArgs11({
+  return parseArgs10({
     args: argv,
     options: {
       help: { type: "boolean", short: "h" },
@@ -432838,6 +432603,7 @@ function parseMcpArgs(argv) {
       "agent-id": { type: "string" },
       mode: { type: "string" },
       limit: { type: "string" },
+      full: { type: "boolean" },
       args: { type: "string" },
       "args-file": { type: "string" }
     },
@@ -432853,7 +432619,7 @@ function parseCommandLine(argv) {
   }
   return { action: action3, target: target2, values: parsed.values };
 }
-function stringValue5(value) {
+function stringValue4(value) {
   return typeof value === "string" ? value : undefined;
 }
 function getLocalServers(deps, agentId) {
@@ -432892,9 +432658,8 @@ function redactUrl(value) {
     const url2 = new URL(value);
     url2.username = "";
     url2.password = "";
-    const sensitive = /token|key|secret|password|signature|credential/i;
     for (const key2 of url2.searchParams.keys()) {
-      if (sensitive.test(key2))
+      if (SENSITIVE_NAME.test(key2))
         url2.searchParams.set(key2, "[REDACTED]");
     }
     return url2.toString();
@@ -432902,6 +432667,32 @@ function redactUrl(value) {
     return value;
   }
 }
+function redactArgs(args) {
+  const redacted = [];
+  let redactNext = false;
+  for (const arg of args) {
+    if (redactNext) {
+      redacted.push("[REDACTED]");
+      redactNext = false;
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      const equalsIndex = arg.indexOf("=");
+      const flagName = equalsIndex === -1 ? arg : arg.slice(0, equalsIndex);
+      if (SENSITIVE_NAME.test(flagName)) {
+        if (equalsIndex === -1) {
+          redactNext = true;
+          redacted.push(arg);
+        } else {
+          redacted.push(`${flagName}=[REDACTED]`);
+        }
+        continue;
+      }
+    }
+    redacted.push(arg);
+  }
+  return redacted;
+}
 function serverDetails(target2) {
   if (target2.kind === "client") {
     const config2 = target2.config;
@@ -432917,7 +432708,7 @@ function serverDetails(target2) {
       name: config2.name,
       transport: "stdio",
       command: config2.command,
-      args: config2.args ?? [],
+      args: redactArgs(config2.args ?? []),
       ...config2.cwd ? { cwd: config2.cwd } : {},
       env: redactValues(config2.env)
     };
@@ -432931,7 +432722,7 @@ function serverDetails(target2) {
       name: server2.serverName,
       transport: "stdio",
       command: server2.command ?? server2.target.split(" ")[0] ?? "",
-      args: server2.args ?? [],
+      args: redactArgs(server2.args ?? []),
       env: {}
     };
   }
@@ -433021,7 +432812,10 @@ async function buildToolCatalog(deps, agentId, options = {}) {
   const connections = [];
   const usedNames = new Set;
   try {
-    const serverTargets = activeServers.filter((target2) => target2.kind === "server");
+    const hostedLettaCloud = (deps.isHostedLettaCloud ?? defaultIsHostedLettaCloud)();
+    const allServerTargets = activeServers.filter((target2) => target2.kind === "server");
+    const serverTargets = hostedLettaCloud ? allServerTargets.filter(({ server: server2 }) => server2.serverType !== "stdio") : allServerTargets;
+    const excludedHostedStdioServers = serverTargets.length !== allServerTargets.length;
     if (serverTargets.length > 0) {
       const client = await getServerClient(deps);
       const toolLists = await Promise.all(serverTargets.map(async ({ server: server2 }) => ({
@@ -433084,6 +432878,7 @@ async function buildToolCatalog(deps, agentId, options = {}) {
     }
     return {
       tools: catalog,
+      excludedHostedStdioServers,
       close: async () => {
         await Promise.allSettled(connections.map((connection) => connection.close()));
       }
@@ -433126,12 +432921,12 @@ function mcpToolResultFromServer(result2) {
     isError: !success || normalized.isError === true
   };
 }
-function printJson2(stdout, value) {
+function printJson(stdout, value) {
   stdout(JSON.stringify(value, null, 2));
 }
 async function runList(deps, agentId, stdout) {
   const servers = await listUnifiedServers(deps, agentId);
-  printJson2(stdout, servers.map(serverSummary));
+  printJson(stdout, servers.map(serverSummary));
   return 0;
 }
 async function runGet(deps, agentId, selector, stdout) {
@@ -433139,25 +432934,45 @@ async function runGet(deps, agentId, selector, stdout) {
     throw new McpCliError("invalid_arguments", "Usage: letta mcp get <server>");
   }
   const server2 = resolveServer(await listUnifiedServers(deps, agentId), selector);
-  printJson2(stdout, serverDetails(server2));
+  printJson(stdout, serverDetails(server2));
   return 0;
 }
-async function runTools(deps, agentId, serverSelector, stdout) {
+async function runTools(deps, agentId, serverSelector, full, stdout) {
   const catalog = await buildToolCatalog(deps, agentId, { serverSelector });
   try {
-    printJson2(stdout, catalog.tools.map((tool) => tool.schema));
+    printJson(stdout, catalog.tools.map((tool) => full ? tool.schema : {
+      name: tool.schema.name,
+      ...tool.schema.title ? { title: tool.schema.title } : {},
+      ...tool.schema.description ? { description: tool.schema.description } : {}
+    }));
   } finally {
     await catalog.close();
   }
   return 0;
 }
+async function runSchema(deps, agentId, toolName, stdout) {
+  if (!toolName) {
+    throw new McpCliError("invalid_arguments", "Usage: letta mcp schema <tool-name>");
+  }
+  const catalog = await buildToolCatalog(deps, agentId, { toolName });
+  try {
+    const tool = catalog.tools.find((candidate) => candidate.schema.name === toolName);
+    if (!tool) {
+      throw new McpCliError("tool_not_found", `MCP tool '${toolName}' is not available`);
+    }
+    printJson(stdout, tool.schema);
+    return 0;
+  } finally {
+    await catalog.close();
+  }
+}
 async function runSearch(parsed, deps, agentId, stdout) {
   const serverSearchAvailable = serverMcpAvailable(deps);
   const hasClientLocalServers = getLocalServers(deps, agentId).length > 0;
   return runMcpSearch({
     query: parsed.target,
-    mode: stringValue5(parsed.values.mode),
-    limit: stringValue5(parsed.values.limit),
+    mode: stringValue4(parsed.values.mode),
+    limit: stringValue4(parsed.values.limit),
     stdout,
     searchTools: async (request) => {
       if (!serverSearchAvailable) {
@@ -433190,15 +433005,20 @@ async function runSearch(parsed, deps, agentId, stdout) {
           catalogPromise
         ]);
         catalog = resolvedCatalog;
-        const serverResults = searchResults.map((result2) => {
+        const serverResults = searchResults.flatMap((result2) => {
           const callable = resolvedCatalog.tools.find((tool) => tool.target.kind === "server" && tool.target.toolId === result2.toolId);
           if (!callable) {
+            if (resolvedCatalog.excludedHostedStdioServers) {
+              return [];
+            }
             throw new Error(`MCP search returned unavailable tool '${result2.toolId}'`);
           }
-          return {
-            tool: result2.jsonSchema === null ? null : { ...result2.jsonSchema, name: callable.schema.name },
-            score: result2.score
-          };
+          return [
+            {
+              tool: result2.jsonSchema === null ? null : { ...result2.jsonSchema, name: callable.schema.name },
+              score: result2.score
+            }
+          ];
         });
         if (!includeLocal)
           return serverResults;
@@ -433221,7 +433041,7 @@ async function runCall(parsed, deps, agentId, stdout) {
   if (!toolName) {
     throw new McpCliError("invalid_arguments", "Usage: letta mcp call <tool-name> [--args '<json>']");
   }
-  const args = await loadMcpToolArgs(stringValue5(parsed.values.args), stringValue5(parsed.values["args-file"]), deps);
+  const args = await loadMcpToolArgs(stringValue4(parsed.values.args), stringValue4(parsed.values["args-file"]), deps);
   const catalog = await buildToolCatalog(deps, agentId, { toolName });
   try {
     const tool = catalog.tools.find((candidate) => candidate.schema.name === toolName);
@@ -433235,7 +433055,7 @@ async function runCall(parsed, deps, agentId, stdout) {
       toolId: tool.target.toolId,
       args
     }));
-    printJson2(stdout, result2);
+    printJson(stdout, result2);
     return result2.isError === true ? 2 : 0;
   } finally {
     await catalog.close();
@@ -433255,7 +433075,7 @@ async function runMcpSubcommand(argv, deps = {}) {
     printMcpUsage(stdout);
     return 0;
   }
-  const agentId = resolveMcpAgentId(stringValue5(parsed.values.agent), stringValue5(parsed.values["agent-id"]), deps.env ?? process.env);
+  const agentId = resolveMcpAgentId(stringValue4(parsed.values.agent), stringValue4(parsed.values["agent-id"]), deps.env ?? process.env);
   if (!agentId) {
     printMcpError(stderr, new McpCliError("agent_id_required", "No agent context found", "Pass --agent <agent-id> or set LETTA_AGENT_ID."));
     return 1;
@@ -433270,7 +433090,9 @@ async function runMcpSubcommand(argv, deps = {}) {
       case "tools":
       case "list-tools":
       case "list_tools":
-        return await runTools(deps, agentId, parsed.target, stdout);
+        return await runTools(deps, agentId, parsed.target, parsed.values.full === true, stdout);
+      case "schema":
+        return await runSchema(deps, agentId, parsed.target, stdout);
       case "search":
         return await runSearch(parsed, deps, agentId, stdout);
       case "call":
@@ -433286,19 +433108,21 @@ async function runMcpSubcommand(argv, deps = {}) {
     return 1;
   }
 }
-var init_mcp = __esm(async () => {
+var SENSITIVE_NAME;
+var init_mcp = __esm(() => {
+  init_oauth();
   init_backend2();
   init_client2();
+  init_server_url();
   init_unified_mcp();
   init_mcp_client();
   init_mcp_oauth();
+  init_mcp_runtime();
   init_settings_manager();
   init_mcp_io();
   init_mcp_search();
-  await __promiseAll([
-    init_mcp_runtime(),
-    init_mcp_tool_names()
-  ]);
+  init_mcp_tool_names();
+  SENSITIVE_NAME = /token|key|secret|password|signature|credential|auth/i;
 });
 
 // src/cli/subcommands/memory-tokens.ts
@@ -433327,7 +433151,7 @@ function printText(total, files, top, quiet) {
     console.log(`  ${formatNumber(row.tokens).padStart(8)}  ${row.path}`);
   }
 }
-function printJson3(total, files) {
+function printJson2(total, files) {
   console.log(JSON.stringify({
     total_tokens: total,
     files
@@ -433368,7 +433192,7 @@ async function runMemoryTokensAction(options) {
   }
   const { total, files } = estimate;
   if (format5 === "json") {
-    printJson3(total, files);
+    printJson2(total, files);
   } else {
     printText(total, files, top, options.quiet);
   }
@@ -433383,8 +433207,8 @@ var init_memory_tokens = __esm(() => {
 import { cpSync, existsSync as existsSync57, mkdirSync as mkdirSync39, rmSync as rmSync12, statSync as statSync19 } from "node:fs";
 import { readdir as readdir12 } from "node:fs/promises";
 import { dirname as dirname31, join as join72 } from "node:path";
-import { parseArgs as parseArgs12 } from "node:util";
-function printUsage9() {
+import { parseArgs as parseArgs11 } from "node:util";
+function printUsage8() {
   console.log(`
 Usage:
   letta memory status [--agent <id>]
@@ -433417,7 +433241,7 @@ function getAgentId3(agentFromArgs, agentIdFromArgs) {
   return agentFromArgs || agentIdFromArgs || process.env.LETTA_AGENT_ID || "";
 }
 function parseMemoryArgs(argv) {
-  return parseArgs12({
+  return parseArgs11({
     args: argv,
     options: MEMORY_OPTIONS,
     strict: true,
@@ -433478,12 +433302,12 @@ async function runMemorySubcommand(argv) {
   } catch (error5) {
     const message = error5 instanceof Error ? error5.message : String(error5);
     console.error(`Error: ${message}`);
-    printUsage9();
+    printUsage8();
     return 1;
   }
   const [action3] = parsed.positionals;
   if (parsed.values.help || !action3 || action3 === "help") {
-    printUsage9();
+    printUsage8();
     return 0;
   }
   const agentId = getAgentId3(parsed.values.agent, parsed.values["agent-id"]);
@@ -433627,7 +433451,7 @@ async function runMemorySubcommand(argv) {
     return 1;
   }
   console.error(`Unknown action: ${action3}`);
-  printUsage9();
+  printUsage8();
   return 1;
 }
 var MEMORY_OPTIONS;
@@ -433986,8 +433810,8 @@ var init_message_search = __esm(() => {
 // src/cli/subcommands/messages.ts
 import { writeFile as writeFile16 } from "node:fs/promises";
 import { resolve as resolve35 } from "node:path";
-import { parseArgs as parseArgs13 } from "node:util";
-function printUsage10() {
+import { parseArgs as parseArgs12 } from "node:util";
+function printUsage9() {
   console.log(`
 Usage:
   letta messages search --query <text> [options]
@@ -434072,7 +433896,7 @@ function pageItems4(page) {
   return [];
 }
 function parseMessagesArgs(argv) {
-  return parseArgs13({
+  return parseArgs12({
     args: argv,
     options: MESSAGES_OPTIONS,
     strict: true,
@@ -434086,12 +433910,12 @@ async function runMessagesSubcommand(argv, deps = {}) {
   } catch (error5) {
     const message = error5 instanceof Error ? error5.message : String(error5);
     console.error(`Error: ${message}`);
-    printUsage10();
+    printUsage9();
     return 1;
   }
   const [action3] = parsed.positionals;
   if (parsed.values.help || !action3 || action3 === "help") {
-    printUsage10();
+    printUsage9();
     return 0;
   }
   try {
@@ -434333,7 +434157,7 @@ async function runMessagesSubcommand(argv, deps = {}) {
     return 1;
   }
   console.error(`Unknown action: ${action3}`);
-  printUsage10();
+  printUsage9();
   return 1;
 }
 var MESSAGES_OPTIONS;
@@ -434378,7 +434202,7 @@ import {
 } from "node:fs";
 import { tmpdir as tmpdir10 } from "node:os";
 import path46 from "node:path";
-function isRecord18(value) {
+function isRecord17(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isPathInsideOrEqual2(childPath, parentPath) {
@@ -434394,7 +434218,7 @@ function readPackageJson(packageJsonPath) {
   } catch (error5) {
     throw new Error(`Could not read package.json: ${error5 instanceof Error ? error5.message : String(error5)}`);
   }
-  if (!isRecord18(parsed)) {
+  if (!isRecord17(parsed)) {
     throw new Error("package.json must be an object");
   }
   return parsed;
@@ -434404,7 +434228,7 @@ function formatRepository(repository) {
     const trimmed2 = repository.trim();
     return trimmed2 || undefined;
   }
-  if (!isRecord18(repository))
+  if (!isRecord17(repository))
     return;
   const url2 = repository.url;
   if (typeof url2 !== "string")
@@ -434934,7 +434758,7 @@ function hasRuntimeDependencies(packageJson) {
   if (!packageJson)
     return false;
   const dependencies4 = packageJson.dependencies;
-  return isRecord18(dependencies4) && Object.keys(dependencies4).length > 0;
+  return isRecord17(dependencies4) && Object.keys(dependencies4).length > 0;
 }
 function readPackageJsonIfExists(packageDirectory) {
   const packageJsonPath = path46.join(packageDirectory, "package.json");
@@ -435363,8 +435187,8 @@ var init_package_scaffolder = __esm(() => {
 
 // src/cli/subcommands/mods.ts
 import { dirname as dirname32, join as join74 } from "node:path";
-import { parseArgs as parseArgs14 } from "node:util";
-function printUsage11() {
+import { parseArgs as parseArgs13 } from "node:util";
+function printUsage10() {
   console.log(`
 Usage:
   letta mods list [--agent <id>]
@@ -435381,7 +435205,7 @@ Options:
 `.trim());
 }
 function parseModsArgs(argv) {
-  return parseArgs14({
+  return parseArgs13({
     args: argv,
     options: MODS_OPTIONS,
     strict: true,
@@ -435389,7 +435213,7 @@ function parseModsArgs(argv) {
   });
 }
 function parseModsPackageArgs(argv) {
-  return parseArgs14({
+  return parseArgs13({
     args: argv,
     options: MODS_PACKAGE_OPTIONS,
     strict: true,
@@ -435487,16 +435311,16 @@ async function runList2(argv, options = {}) {
     parsed = parseModsArgs(argv);
   } catch (error5) {
     console.error(`Error: ${error5 instanceof Error ? error5.message : String(error5)}`);
-    printUsage11();
+    printUsage10();
     return 1;
   }
   if (parsed.values.help) {
-    printUsage11();
+    printUsage10();
     return 0;
   }
   if (parsed.positionals.length > 0) {
     console.error(`Unexpected argument: ${parsed.positionals[0]}`);
-    printUsage11();
+    printUsage10();
     return 1;
   }
   const agentId = getExplicitAgentId(parsed.values);
@@ -435513,27 +435337,27 @@ async function runPackageMutation(action3, argv, options = {}) {
     parsed = parseModsArgs(argv);
   } catch (error5) {
     console.error(`Error: ${error5 instanceof Error ? error5.message : String(error5)}`);
-    printUsage11();
+    printUsage10();
     return 1;
   }
   if (parsed.values.help) {
-    printUsage11();
+    printUsage10();
     return 0;
   }
   if (getExplicitAgentId(parsed.values)) {
     console.error(`--agent is only supported for 'letta mods list'.`);
-    printUsage11();
+    printUsage10();
     return 1;
   }
   const [specifier, extra] = parsed.positionals;
   if (!specifier) {
     console.error(`Missing package specifier.`);
-    printUsage11();
+    printUsage10();
     return 1;
   }
   if (extra) {
     console.error(`Unexpected argument: ${extra}`);
-    printUsage11();
+    printUsage10();
     return 1;
   }
   try {
@@ -435559,27 +435383,27 @@ async function runPackageUpdate(argv, options = {}) {
     parsed = parseModsArgs(argv);
   } catch (error5) {
     console.error(`Error: ${error5 instanceof Error ? error5.message : String(error5)}`);
-    printUsage11();
+    printUsage10();
     return 1;
   }
   if (parsed.values.help) {
-    printUsage11();
+    printUsage10();
     return 0;
   }
   if (getExplicitAgentId(parsed.values)) {
     console.error(`--agent is not supported for 'letta mods update'.`);
-    printUsage11();
+    printUsage10();
     return 1;
   }
   const [specifier, extra] = parsed.positionals;
   if (!specifier) {
     console.error(`Missing package specifier.`);
-    printUsage11();
+    printUsage10();
     return 1;
   }
   if (extra) {
     console.error(`Unexpected argument: ${extra}`);
-    printUsage11();
+    printUsage10();
     return 1;
   }
   try {
@@ -435601,33 +435425,33 @@ async function runPackageScaffold(argv) {
     parsed = parseModsPackageArgs(argv);
   } catch (error5) {
     console.error(`Error: ${error5 instanceof Error ? error5.message : String(error5)}`);
-    printUsage11();
+    printUsage10();
     return 1;
   }
   if (parsed.values.help) {
-    printUsage11();
+    printUsage10();
     return 0;
   }
   if (getExplicitAgentId(parsed.values)) {
     console.error(`--agent is not supported for 'letta mods package'.`);
-    printUsage11();
+    printUsage10();
     return 1;
   }
   const [sourceFile, extra] = parsed.positionals;
   if (!sourceFile) {
     console.error(`Missing mod file.`);
-    printUsage11();
+    printUsage10();
     return 1;
   }
   if (extra) {
     console.error(`Unexpected argument: ${extra}`);
-    printUsage11();
+    printUsage10();
     return 1;
   }
   const packageName = parsed.values.name;
   if (typeof packageName !== "string" || !packageName.trim()) {
     console.error(`Missing required --name <package-name>.`);
-    printUsage11();
+    printUsage10();
     return 1;
   }
   try {
@@ -435649,7 +435473,7 @@ async function runPackageScaffold(argv) {
 async function runModsSubcommand(argv, options = {}) {
   const [action3, ...rest4] = argv;
   if (!action3 || action3 === "help" || action3 === "--help" || action3 === "-h") {
-    printUsage11();
+    printUsage10();
     return 0;
   }
   switch (action3) {
@@ -435665,7 +435489,7 @@ async function runModsSubcommand(argv, options = {}) {
       return runPackageMutation(action3, rest4, options);
     default:
       console.error(`Unknown mods action: ${action3}`);
-      printUsage11();
+      printUsage10();
       return 1;
   }
 }
@@ -435745,8 +435569,8 @@ var init_sandbox_files = __esm(() => {
 // src/cli/subcommands/sandbox.ts
 import { readFile as readFile24, stat as stat16, writeFile as writeFile17 } from "node:fs/promises";
 import { basename as basename26, resolve as resolve36 } from "node:path";
-import { parseArgs as parseArgs15 } from "node:util";
-function printUsage12() {
+import { parseArgs as parseArgs14 } from "node:util";
+function printUsage11() {
   console.log(`
 Usage:
   letta sandbox upload <local-path>
@@ -435760,7 +435584,7 @@ Notes:
 `.trim());
 }
 function parseSandboxArgs(argv) {
-  return parseArgs15({
+  return parseArgs14({
     args: argv,
     options: SANDBOX_OPTIONS,
     strict: true,
@@ -435800,17 +435624,17 @@ async function runSandboxSubcommand(argv, deps = {}) {
     parsed = parseSandboxArgs(argv);
   } catch (error5) {
     console.error(`Error: ${error5 instanceof Error ? error5.message : error5}`);
-    printUsage12();
+    printUsage11();
     return 1;
   }
   const [action3, path48] = parsed.positionals;
   if (parsed.values.help || !action3 || action3 === "help") {
-    printUsage12();
+    printUsage11();
     return 0;
   }
   if (action3 !== "upload" && action3 !== "download" || !path48) {
     console.error("Error: expected upload or download with a file path");
-    printUsage12();
+    printUsage11();
     return 1;
   }
   try {
@@ -435854,8 +435678,8 @@ var init_sandbox2 = __esm(() => {
 });
 
 // src/cli/subcommands/secret.ts
-import { parseArgs as parseArgs16 } from "node:util";
-function printUsage13() {
+import { parseArgs as parseArgs15 } from "node:util";
+function printUsage12() {
   console.log(`
 Usage:
   letta secret set KEY --env SOURCE_VAR   Set KEY from environment variable SOURCE_VAR
@@ -435880,7 +435704,7 @@ Notes:
 `.trim());
 }
 function parseSecretArgs(argv) {
-  return parseArgs16({
+  return parseArgs15({
     args: argv,
     options: SECRET_OPTIONS,
     strict: true,
@@ -435915,11 +435739,11 @@ async function runSecretSubcommand(argv, deps = {}) {
     parsed = parseSecretArgs(argv);
   } catch (error5) {
     printError(error5);
-    printUsage13();
+    printUsage12();
     return 1;
   }
   if (parsed.values.help || parsed.positionals.length === 0) {
-    printUsage13();
+    printUsage12();
     return parsed.values.help ? 0 : 1;
   }
   const [verb, rawKey, rawValue] = parsed.positionals;
@@ -435929,7 +435753,7 @@ async function runSecretSubcommand(argv, deps = {}) {
   }
   switch (verb) {
     case "help": {
-      printUsage13();
+      printUsage12();
       return 0;
     }
     case "list": {
@@ -436037,7 +435861,7 @@ async function runSecretSubcommand(argv, deps = {}) {
     }
     default: {
       console.error(`Unknown subcommand '${verb ?? ""}'.`);
-      printUsage13();
+      printUsage12();
       return 1;
     }
   }
@@ -436055,7 +435879,7 @@ var init_secret = __esm(() => {
 });
 
 // src/cli/subcommands/app-server.ts
-import { parseArgs as parseArgs17 } from "node:util";
+import { parseArgs as parseArgs16 } from "node:util";
 function printAppServerHelp() {
   console.log(`Usage: letta server --listen [url]
 
@@ -436103,7 +435927,7 @@ Stopped App Server (${signal}).`);
 async function runAppServerSubcommand(argv) {
   let parsed;
   try {
-    parsed = parseArgs17({
+    parsed = parseArgs16({
       args: argv,
       allowPositionals: false,
       options: {
@@ -436172,10 +435996,10 @@ function printServerHelp() {
   letta server [remote options]
   letta server --listen [url] [App Server options]
 
-Run the local agent server as a remote environment, with messaging channels, or as an App Server.
+Run the local agent server as a remote computer, with messaging channels, or as an App Server.
 
-Remote environment options:
-  --env-name <name>  Friendly name for this environment (uses hostname if not provided)
+Remote computer options:
+  --computer-name <name>  Friendly name for this computer (uses hostname if not provided)
   --channels <list>  Comma-separated channel names to enable (e.g. telegram)
   --install-channel-runtimes  Install missing runtime dependencies for selected channels
   --debug  Log WebSocket events instead of showing the interactive status UI
@@ -436196,7 +436020,7 @@ Common options:
 
 Examples:
   letta server
-  letta server --env-name "work-laptop"
+  letta server --computer-name "work-laptop"
   letta server --channels telegram
   letta server --listen
   letta server --listen ws://127.0.0.1:4500
@@ -436235,7 +436059,7 @@ function resolveServerCommand(argv) {
     }
   }
   if (foundListen) {
-    const conflictingOption = argv.find((arg) => arg === "--env-name" || arg.startsWith("--env-name=") || arg === "--channels" || arg.startsWith("--channels="));
+    const conflictingOption = argv.find((arg) => arg === "--computer-name" || arg.startsWith("--computer-name=") || arg === "--env-name" || arg.startsWith("--env-name=") || arg === "--channels" || arg.startsWith("--channels="));
     if (conflictingOption) {
       throw new Error(`${conflictingOption.split("=")[0]} cannot be used with --listen`);
     }
@@ -436688,7 +436512,7 @@ var init_setup6 = __esm(async () => {
 });
 
 // src/cli/subcommands/setup.ts
-function printUsage14() {
+function printUsage13() {
   console.log(`
 Usage:
   letta setup
@@ -436699,12 +436523,12 @@ Re-run the interactive setup menu to choose local mode or sign in with Letta.
 async function runSetupSubcommand(argv) {
   const [arg, ...rest4] = argv;
   if (arg === "help" || arg === "--help" || arg === "-h") {
-    printUsage14();
+    printUsage13();
     return 0;
   }
   if (arg || rest4.length > 0) {
     console.error(`Unexpected arguments: ${[arg, ...rest4].filter(Boolean).join(" ")}`);
-    printUsage14();
+    printUsage13();
     return 1;
   }
   await settingsManager.initialize();
@@ -436719,8 +436543,8 @@ var init_setup7 = __esm(async () => {
 // src/cli/subcommands/shared-memory.ts
 import { existsSync as existsSync61 } from "node:fs";
 import { join as join75 } from "node:path";
-import { parseArgs as parseArgs18 } from "node:util";
-function printUsage15() {
+import { parseArgs as parseArgs17 } from "node:util";
+function printUsage14() {
   console.log(`
 Usage:
   letta shared-memory list [--agent <id>]
@@ -436755,7 +436579,7 @@ Examples:
 `.trim());
 }
 function parseSharedMemoryArgs(argv) {
-  return parseArgs18({
+  return parseArgs17({
     args: argv,
     options: SHARED_MEMORY_OPTIONS,
     strict: true,
@@ -436831,12 +436655,12 @@ async function runSharedMemorySubcommand(argv, deps = {}) {
     parsed = parseSharedMemoryArgs(argv);
   } catch (error5) {
     console.error(error5 instanceof Error ? error5.message : String(error5));
-    printUsage15();
+    printUsage14();
     return 1;
   }
   const [action3, reference] = parsed.positionals;
   if (parsed.values.help || !action3 || action3 === "help") {
-    printUsage15();
+    printUsage14();
     return 0;
   }
   if (isLocalBackendEnvEnabled()) {
@@ -436941,7 +436765,7 @@ async function runSharedMemorySubcommand(argv, deps = {}) {
       return result2.failed > 0 ? 1 : 0;
     }
     console.error(`Unknown action: ${action3}`);
-    printUsage15();
+    printUsage14();
     return 1;
   } catch (error5) {
     console.error(error5 instanceof Error ? error5.message : String(error5));
@@ -438449,8 +438273,8 @@ import {
 import { mkdir as mkdir14, readdir as readdir13 } from "node:fs/promises";
 import { tmpdir as tmpdir11 } from "node:os";
 import { basename as basename27, dirname as dirname33, join as join76, normalize as normalize5, resolve as resolve37, sep as sep8 } from "node:path";
-import { parseArgs as parseArgs19, TextDecoder as TextDecoder2, TextEncoder as TextEncoder2 } from "node:util";
-function printUsage16() {
+import { parseArgs as parseArgs18, TextDecoder as TextDecoder2, TextEncoder as TextEncoder2 } from "node:util";
+function printUsage15() {
   console.log(`
 Usage:
   letta install <thing> [--agent <id> | -n <agent name>] [--force]
@@ -438477,7 +438301,7 @@ Options:
 `.trim());
 }
 function parseSkillsArgs(argv) {
-  return parseArgs19({
+  return parseArgs18({
     args: argv,
     options: SKILLS_OPTIONS,
     strict: true,
@@ -439125,17 +438949,17 @@ async function runInstall(argv, options = {}) {
     parsed = parseSkillsArgs(argv);
   } catch (error5) {
     console.error(`Error: ${error5 instanceof Error ? error5.message : String(error5)}`);
-    printUsage16();
+    printUsage15();
     return 1;
   }
   const [specifier] = parsed.positionals;
   if (parsed.values.help || !specifier || specifier === "help") {
-    printUsage16();
+    printUsage15();
     return 0;
   }
   if (parsed.positionals.length > 1) {
     console.error(`Unexpected argument: ${parsed.positionals[1]}`);
-    printUsage16();
+    printUsage15();
     return 1;
   }
   if (specifier.startsWith("npm:")) {
@@ -439226,16 +439050,16 @@ async function runList3(argv) {
     parsed = parseSkillsArgs(argv);
   } catch (error5) {
     console.error(`Error: ${error5 instanceof Error ? error5.message : String(error5)}`);
-    printUsage16();
+    printUsage15();
     return 1;
   }
   if (parsed.values.help) {
-    printUsage16();
+    printUsage15();
     return 0;
   }
   if (parsed.positionals.length > 0) {
     console.error(`Unexpected argument: ${parsed.positionals[0]}`);
-    printUsage16();
+    printUsage15();
     return 1;
   }
   try {
@@ -439256,17 +439080,17 @@ async function runDelete(argv) {
     parsed = parseSkillsArgs(argv);
   } catch (error5) {
     console.error(`Error: ${error5 instanceof Error ? error5.message : String(error5)}`);
-    printUsage16();
+    printUsage15();
     return 1;
   }
   const [skillName] = parsed.positionals;
   if (parsed.values.help || !skillName || skillName === "help") {
-    printUsage16();
+    printUsage15();
     return 0;
   }
   if (parsed.positionals.length > 1) {
     console.error(`Unexpected argument: ${parsed.positionals[1]}`);
-    printUsage16();
+    printUsage15();
     return 1;
   }
   const agentId = getExplicitAgentId2(parsed.values);
@@ -439306,11 +439130,11 @@ async function runSkillsSubcommand(argv) {
     case "help":
     case "--help":
     case "-h":
-      printUsage16();
+      printUsage15();
       return 0;
     default:
       console.error(`Unknown action: ${action3}`);
-      printUsage16();
+      printUsage15();
       return 1;
   }
 }
@@ -439329,31 +439153,31 @@ var init_skills4 = __esm(() => {
 });
 
 // src/cli/subcommands/teleport.ts
-import { parseArgs as parseArgs20 } from "node:util";
-function printUsage17() {
+import { parseArgs as parseArgs19 } from "node:util";
+function printUsage16() {
   console.log(`
 Usage:
   letta teleport list
   letta teleport cloud
   letta teleport local
-  letta teleport <environment>
+  letta teleport <computer>
 
 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 an active conversation.
-  - list: prints accessible online remote environments as JSON.
+  - list: prints accessible online remote computers as JSON.
   - cloud: teleports to the agent's Cloud sandbox.
-  - local: teleports to the one online Desktop environment. Desktop Remote
+  - local: teleports to the one online Desktop computer. Desktop Remote
     Access must be enabled; if several are online, choose one explicitly.
-  - <environment>: teleports to a specific remote environment by name,
-    device-id, connection-id, or environment id.
+  - <computer>: teleports to a specific remote computer by name,
+    device-id, connection-id, or computer id.
   - Output is JSON only.
 `.trim());
 }
 function parseTeleportArgs(argv) {
-  return parseArgs20({
+  return parseArgs19({
     args: argv,
     options: TELEPORT_OPTIONS,
     strict: true,
@@ -439413,7 +439237,7 @@ function isTeleportableRemoteEnvironment(environment2) {
 }
 function assertTeleportableRemoteEnvironment(environment2) {
   if (!isTeleportableRemoteEnvironment(environment2)) {
-    throw new Error("The Desktop-local connection is not Cloud-routable. Use `letta teleport local` to resolve its Remote Access environment.");
+    throw new Error("The Desktop-local connection is not Cloud-routable. Use `letta teleport local` to resolve its Remote Access computer.");
   }
 }
 async function initializeTeleportSettings() {
@@ -439426,12 +439250,12 @@ async function runTeleportSubcommand(argv, deps = {}) {
     parsed = parseTeleportArgs(argv);
   } catch (error5) {
     console.error(`Error: ${error5 instanceof Error ? error5.message : error5}`);
-    printUsage17();
+    printUsage16();
     return 1;
   }
   const [action3] = parsed.positionals;
   if (parsed.values.help || !action3 || action3 === "help") {
-    printUsage17();
+    printUsage16();
     return 0;
   }
   try {
@@ -439456,7 +439280,7 @@ async function runTeleportSubcommand(argv, deps = {}) {
       const result3 = await resolve38();
       targetConnectionId = result3.connectionId;
     } else if (action3 === "back") {
-      throw new Error("Teleport back is not supported. Use `letta teleport local` or choose an explicit environment.");
+      throw new Error("Teleport back is not supported. Use `letta teleport local` or choose an explicit computer.");
     } else {
       const resolve38 = deps.resolveEnvironmentConnectionId ?? resolveEnvironmentConnectionId;
       const resolved = await resolve38(action3);
@@ -439867,8 +439691,8 @@ var init_review = () => {};
 
 // src/cli/subcommands/trajectories.ts
 import { readFile as readFile28 } from "node:fs/promises";
-import { parseArgs as parseArgs21 } from "node:util";
-function printUsage18() {
+import { parseArgs as parseArgs20 } from "node:util";
+function printUsage17() {
   console.log(`
 Usage:
   letta trajectories export [options]
@@ -440006,7 +439830,7 @@ ${results.length} session(s) matched "${keyword}"`);
   return 0;
 }
 function parseTrajectoriesArgs(argv) {
-  return parseArgs21({
+  return parseArgs20({
     args: argv,
     options: TRAJECTORIES_OPTIONS,
     strict: true,
@@ -440019,12 +439843,12 @@ async function runTrajectoriesSubcommand(argv) {
     parsed = parseTrajectoriesArgs(argv);
   } catch (error5) {
     console.error(`Error: ${error5 instanceof Error ? error5.message : String(error5)}`);
-    printUsage18();
+    printUsage17();
     return 1;
   }
   const [action3] = parsed.positionals;
   if (parsed.values.help || action3 === "help" || !action3) {
-    printUsage18();
+    printUsage17();
     return parsed.values.help || action3 === "help" ? 0 : 1;
   }
   const asJson = Boolean(parsed.values.json);
@@ -440056,7 +439880,7 @@ async function runTrajectoriesSubcommand(argv) {
   }
   if (action3 !== "export") {
     console.error(`Unknown command: ${action3}`);
-    printUsage18();
+    printUsage17();
     return 1;
   }
   const options = {
@@ -441605,9 +441429,9 @@ class ChannelRichDraftStreamerImpl {
       return;
     }
     const record5 = asRecord10(chunk2);
-    const messageType = stringValue6(record5?.message_type);
+    const messageType = stringValue5(record5?.message_type);
     if (messageType === "tool_return_message") {
-      const toolCallId = stringValue6(record5?.tool_call_id);
+      const toolCallId = stringValue5(record5?.tool_call_id);
       if (toolCallId) {
         this.finishCall(toolCallId);
       }
@@ -441900,14 +441724,14 @@ function extractToolCallFragments2(record5) {
   const fragments = [];
   for (const rawToolCall of rawToolCalls) {
     const toolCall = asRecord10(rawToolCall);
-    const toolCallId = stringValue6(toolCall?.tool_call_id);
+    const toolCallId = stringValue5(toolCall?.tool_call_id);
     if (!toolCallId) {
       continue;
     }
     fragments.push({
       toolCallId,
-      name: stringValue6(toolCall?.name),
-      argumentsDelta: stringValue6(toolCall?.arguments)
+      name: stringValue5(toolCall?.name),
+      argumentsDelta: stringValue5(toolCall?.arguments)
     });
   }
   return fragments;
@@ -442027,7 +441851,7 @@ function buildDraftId(seed) {
 function asRecord10(value) {
   return value && typeof value === "object" ? value : null;
 }
-function stringValue6(value) {
+function stringValue5(value) {
   return typeof value === "string" ? value : undefined;
 }
 var MESSAGE_CHANNEL_TOOL_NAMES, DEFAULT_DRAFT_DEBOUNCE_MS = 1000, MIN_DRAFT_TEXT_LENGTH = 1;
@@ -444895,14 +444719,14 @@ var exports_channel_gateway = {};
 __export(exports_channel_gateway, {
   runChannelGatewaySubcommand: () => runChannelGatewaySubcommand
 });
-import { parseArgs as parseArgs22 } from "node:util";
+import { parseArgs as parseArgs21 } from "node:util";
 function isGatewayCommandEnvelope(value) {
   return Boolean(value && typeof value === "object" && "type" in value && value.type === "command" && "requestId" in value && typeof value.requestId === "string" && "command" in value && value.command && typeof value.command === "object");
 }
 async function runChannelGatewaySubcommand(argv) {
   let values3;
   try {
-    ({ values: values3 } = parseArgs22({
+    ({ values: values3 } = parseArgs21({
       args: argv,
       strict: true,
       allowPositionals: false,
@@ -445029,6 +444853,7 @@ function subcommandNeedsEarlyBackendMode(command) {
     case "channel-gateway":
     case "agents":
     case "connect":
+    case "computers":
     case "environments":
     case "envs":
     case "feedback":
@@ -445042,7 +444867,6 @@ function subcommandNeedsEarlyBackendMode(command) {
     case "sandbox":
     case "secret":
     case "server":
-    case "cloud-mcp":
     case "shared-memory":
     case "skills":
     case "teleport":
@@ -445074,6 +444898,7 @@ async function runSubcommand(argv) {
       return runMessagesSubcommand(rest4);
     case "mcp":
       return runMcpSubcommand(rest4);
+    case "computers":
     case "environments":
     case "envs":
       return runEnvironmentsSubcommand(rest4);
@@ -445087,8 +444912,6 @@ async function runSubcommand(argv) {
       return runTeleportSubcommand(rest4);
     case "server":
       return runServerSubcommand(rest4);
-    case "cloud-mcp":
-      return runCloudMcpSubcommand(rest4);
     case "feedback":
       return runFeedbackSubcommand(rest4);
     case "remote":
@@ -445126,11 +444949,11 @@ var init_router = __esm(async () => {
   init_agents6();
   init_backend3();
   init_channels();
-  init_cloud_mcp();
   init_connect();
   init_environments3();
   init_feedback3();
   init_local_backend2();
+  init_mcp();
   init_memory7();
   init_messages10();
   init_sandbox2();
@@ -445142,7 +444965,6 @@ var init_router = __esm(async () => {
   await __promiseAll([
     init_cron2(),
     init_listen(),
-    init_mcp(),
     init_mods(),
     init_server(),
     init_setup7()
@@ -447304,7 +447126,7 @@ function getEnvironmentRoutedMessagingUnsupportedReason(environment2) {
   if (environment2.metadata?.environmentMessageProtocol === "v2-input") {
     return null;
   }
-  return `Environment ${environment2.connectionName} (${environment2.deviceId}) is running Letta Code ${environment2.metadata?.lettaCodeVersion ?? "unknown"} and does not advertise environment-routed headless messaging support. Update that runtime or omit --environment to use same-environment messaging.`;
+  return `Computer ${environment2.connectionName} (${environment2.deviceId}) is running Letta Code ${environment2.metadata?.lettaCodeVersion ?? "unknown"} and does not advertise computer-routed headless messaging support. Update that runtime or omit --computer to use same-computer messaging.`;
 }
 async function handleHeadlessCommand(parsedArgs, model, skillsDirectoryOverride, skillSourcesOverride, systemInfoReminderEnabledOverride, startupOptions = {}) {
   const { values: values3, positionals } = parsedArgs;
@@ -447377,7 +447199,7 @@ In headless mode, use:
   }
   let forceNewConversation = values3.new ?? false;
   const fromAgentId = values3["from-agent"];
-  const explicitEnvironmentSelector = values3.environment || values3.env;
+  const explicitEnvironmentSelector = values3.computer ?? values3.environment ?? values3.env;
   const usesRemoteEnvironment = typeof explicitEnvironmentSelector === "string" && explicitEnvironmentSelector.trim().length > 0;
   let agent = null;
   let ephemeralConversationId = null;
@@ -447745,9 +447567,6 @@ Current session AGENT_ID=${process.env.AGENT_ID}; --backend local switches to a
   markMilestone("HEADLESS_AGENT_RESOLVED");
   const publicAgentId = ephemeralFlag ? null : agent.id;
   telemetry.setCurrentAgent(publicAgentId, agent.tags);
-  if (!ephemeralFlag) {
-    await replaceClientMcpServers(agent.id, settingsManager.getMcpServers(agent.id), { stderr: "pipe" });
-  }
   const isResumingAgent = !ephemeralFlag && !!(specifiedAgentId || !forceNew && !fromAfFile);
   if (isResumingAgent) {
     if (model) {
@@ -447936,7 +447755,7 @@ Current session AGENT_ID=${process.env.AGENT_ID}; --backend local switches to a
     process.exit(1);
   }
   if (usesRemoteEnvironment && isBidirectionalMode) {
-    console.error("Error: remote environment routing cannot be used with --input-format stream-json");
+    console.error("Error: remote computer routing cannot be used with --input-format stream-json");
     process.exit(1);
   }
   const sessionStats = new SessionStats;
@@ -448373,6 +448192,7 @@ ${loadedContents.join(`
   let emptyResponseRetries = 0;
   let conversationBusyRetries = 0;
   let chatgptPlanSwaps = 0;
+  const chatgptExhaustedProviders = new Set;
   markMilestone("HEADLESS_FIRST_STREAM_START");
   measureSinceMilestone("headless-setup-total", "HEADLESS_CLIENT_READY");
   const checkMaxTurns = async () => {
@@ -448640,6 +448460,7 @@ ${loadedContents.join(`
         emptyResponseRetries = 0;
         conversationBusyRetries = 0;
         chatgptPlanSwaps = 0;
+        chatgptExhaustedProviders.clear();
         const continueMessage = await emitHeadlessTurnEnd({
           agent,
           conversationId,
@@ -448743,8 +448564,10 @@ ${loadedContents.join(`
       if (chatgptPlanSwaps < CHATGPT_PLAN_ROTATION_MAX_SWAPS_PER_TURN) {
         const rotation = await rotateChatGPTPlanOnQuotaLimit({
           agentId: agent.id,
+          conversationId,
           currentHandle: null,
-          error: runErrorInfo2 ?? detailFromRun ?? latestErrorText
+          error: runErrorInfo2 ?? detailFromRun ?? latestErrorText,
+          exhaustedProviders: chatgptExhaustedProviders
         });
         if (rotation) {
           chatgptPlanSwaps += 1;
@@ -450160,6 +449983,7 @@ var init_headless = __esm(async () => {
   init_headless_environment_response();
   init_headless_reflection_settings();
   init_diff_preview();
+  init_mcp_runtime();
   init_format_denial();
   init_startup();
   init_queue_runtime();
@@ -450178,7 +450002,6 @@ var init_headless = __esm(async () => {
     init_headless_ephemeral_startup(),
     init_headless_mod_adapter(),
     init_headless_tool_events(),
-    init_mcp_runtime(),
     init_manager4(),
     init_toolset()
   ]);
@@ -465838,6 +465661,110 @@ var init_LettaLoginOverlay = __esm(async () => {
   jsx_dev_runtime63 = __toESM(require_jsx_dev_runtime(), 1);
 });
 
+// src/backend/api/mcp-servers.ts
+function withTimeout3(promise2, timeoutMs, label) {
+  let timer;
+  const timeout = new Promise((_4, reject2) => {
+    timer = setTimeout(() => reject2(new Error(`${label} timed out after ${timeoutMs}ms`)), timeoutMs);
+  });
+  return Promise.race([promise2, timeout]).finally(() => {
+    if (timer !== undefined)
+      clearTimeout(timer);
+  });
+}
+function listServerMcpServers(client, timeoutMs = 1e4) {
+  return withTimeout3(client.mcpServers.list(), timeoutMs, "Listing server-side MCP servers");
+}
+async function listLiveServerMcpTools(client, serverName2, timeoutMs = 15000) {
+  const result2 = await withTimeout3(client.get(`/v1/tools/mcp/servers/${encodeURIComponent(serverName2)}/tools`), timeoutMs, `Listing tools for MCP server "${serverName2}"`);
+  if (!Array.isArray(result2))
+    return [];
+  return result2.filter((tool) => typeof tool === "object" && tool !== null && typeof tool.name === "string");
+}
+async function loadServerMcpEntries(client, timeoutMs = 15000) {
+  const servers = await listServerMcpServers(client, timeoutMs);
+  return Promise.all(servers.map(async (server2) => {
+    try {
+      const tools = await listLiveServerMcpTools(client, server2.server_name, timeoutMs);
+      return { server: server2, tools };
+    } catch (cause) {
+      return {
+        server: server2,
+        tools: [],
+        toolsError: cause instanceof Error ? cause.message : String(cause)
+      };
+    }
+  }));
+}
+function parseMcpMetadata(tool) {
+  const metadata = tool.metadata_;
+  const mcp = metadata?.mcp;
+  if (typeof mcp !== "object" || mcp === null)
+    return null;
+  const { server_id, server_name } = mcp;
+  return {
+    ...typeof server_id === "string" && { serverId: server_id },
+    ...typeof server_name === "string" && { serverName: server_name }
+  };
+}
+async function listAgentMcpAttachments(client, agentId) {
+  const attachments = [];
+  for await (const tool of client.agents.tools.list(agentId, { limit: 100 })) {
+    if (tool.tool_type !== "external_mcp" || !tool.id || !tool.name)
+      continue;
+    attachments.push({
+      toolId: tool.id,
+      toolName: tool.name,
+      ...parseMcpMetadata(tool)
+    });
+  }
+  return attachments;
+}
+function attachmentsForEntry(entry, attachments) {
+  return attachments.filter((attachment) => attachment.serverId && entry.server.id ? attachment.serverId === entry.server.id : attachment.serverName === entry.server.server_name);
+}
+function attachedToolNamesForEntry(entry, attachments) {
+  return new Set(attachmentsForEntry(entry, attachments).map((attachment) => attachment.toolName));
+}
+async function registerServerMcpTool(client, serverName2, toolName) {
+  const result2 = await client.post(`/v1/tools/mcp/servers/${encodeURIComponent(serverName2)}/${encodeURIComponent(toolName)}`);
+  if (typeof result2?.id !== "string") {
+    throw new Error(`Registering MCP tool "${toolName}" on server "${serverName2}" returned no tool id`);
+  }
+  return { id: result2.id };
+}
+async function attachServerMcpTools(client, agentId, serverName2, toolNames) {
+  await Promise.all(toolNames.map(async (toolName) => {
+    const { id: id2 } = await registerServerMcpTool(client, serverName2, toolName);
+    await client.agents.tools.attach(id2, { agent_id: agentId });
+  }));
+}
+async function detachServerMcpTools(client, agentId, toolIds) {
+  await Promise.all(toolIds.map((toolId) => client.agents.tools.detach(toolId, { agent_id: agentId })));
+}
+function refreshServerMcpServer(client, mcpServerId, agentId) {
+  return client.mcpServers.refresh(mcpServerId, { agent_id: agentId });
+}
+function planServerMcpToggle(entry, attachments) {
+  const attached = attachmentsForEntry(entry, attachments);
+  if (attached.length > 0) {
+    return {
+      action: "detach",
+      toolIds: attached.map((attachment) => attachment.toolId)
+    };
+  }
+  return { action: "attach", toolNames: entry.tools.map((tool) => tool.name) };
+}
+function describeServerMcpTarget(server2) {
+  if ("server_url" in server2 && server2.server_url) {
+    return server2.server_url;
+  }
+  if ("command" in server2 && server2.command) {
+    return [server2.command, ...server2.args ?? []].join(" ");
+  }
+  return "";
+}
+
 // src/cli/components/McpSelector.tsx
 function buildMcpRows(localStates, serverEntries) {
   return [
@@ -465954,15 +465881,14 @@ var import_react87, jsx_dev_runtime64, SOLID_LINE12 = "─", DISPLAY_PAGE_SIZE2
 var init_McpSelector = __esm(async () => {
   init_backend2();
   init_client2();
-  init_mcp_servers2();
   init_truncate_text();
   init_use_terminal_width();
   init_mcp_oauth();
+  init_mcp_runtime();
   init_settings_manager();
   init_colors();
   await __promiseAll([
     init_build4(),
-    init_mcp_runtime(),
     init_Text2()
   ]);
   import_react87 = __toESM(require_react(), 1);
@@ -466264,7 +466190,7 @@ var init_McpSelector = __esm(async () => {
             flexDirection: "column",
             children: [
               /* @__PURE__ */ jsx_dev_runtime64.jsxDEV(Text2, {
-                children: tool.label ?? tool.name
+                children: tool.title ?? tool.name
               }, undefined, false, undefined, this),
               /* @__PURE__ */ jsx_dev_runtime64.jsxDEV(Text2, {
                 dimColor: true,
@@ -466274,7 +466200,7 @@ var init_McpSelector = __esm(async () => {
                 ]
               }, undefined, true, undefined, this)
             ]
-          }, tool.registrationKey ?? tool.name, true, undefined, this)),
+          }, tool.name, true, undefined, this)),
           /* @__PURE__ */ jsx_dev_runtime64.jsxDEV(Box_default, {
             marginTop: 1,
             children: /* @__PURE__ */ jsx_dev_runtime64.jsxDEV(Text2, {
@@ -475585,7 +475511,7 @@ var init_ToolCallMessageRich = __esm(async () => {
       let shellSemanticKind = null;
       let hasShellDescription = false;
       if (!isQuestionTool(rawName)) {
-        const parseArgs23 = () => {
+        const parseArgs22 = () => {
           if (!argsText.trim()) {
             return { formatted: null, parseable: true };
           }
@@ -475599,7 +475525,7 @@ var init_ToolCallMessageRich = __esm(async () => {
             return { formatted: null, parseable: false };
           }
         };
-        const { formatted, parseable } = parseArgs23();
+        const { formatted, parseable } = parseArgs22();
         const argsComplete = parseable || line.phase === "running" || line.phase === "finished" || !isStreaming;
         if (!argsComplete) {
           args = "(…)";
@@ -477815,7 +477741,7 @@ function updateCommandResult(buffersRef, refreshDerived, cmdId, input, output, s
   buffersRef.current.byId.set(cmdId, line);
   refreshDerived();
 }
-function parseArgs23(msg) {
+function parseArgs22(msg) {
   return msg.trim().split(/\s+/).filter(Boolean);
 }
 function formatConnectUsage() {
@@ -478197,7 +478123,7 @@ ${formatBedrockUsage2()}`, false);
   }
 }
 async function handleConnect(ctx, msg) {
-  const parts = parseArgs23(msg);
+  const parts = parseArgs22(msg);
   const providerToken = parts[1];
   if (!providerToken) {
     addCommandResult(ctx.buffersRef, ctx.refreshDerived, msg, formatConnectUsage(), false);
@@ -493905,20 +493831,20 @@ var init_session3 = __esm(() => {
 });
 
 // src/cli/app/use-agent-mcp-servers.ts
-function useAgentMcpServers(agentId) {
+function useMcpCleanup(agentId) {
+  const previousAgentId = import_react110.useRef(agentId);
   import_react110.useEffect(() => {
-    const refresh = agentId ? replaceClientMcpServers(agentId, settingsManager.getMcpServers(agentId)) : closeClientMcpServers();
-    refresh.catch((error5) => debugWarn("mcp", `Failed to switch agent MCP servers: ${String(error5)}`));
+    if (previousAgentId.current === agentId)
+      return;
+    previousAgentId.current = agentId;
+    closeClientMcpServers().catch((error5) => debugWarn("mcp", `Failed to close client MCP servers: ${String(error5)}`));
   }, [agentId]);
 }
 var import_react110;
-var init_use_agent_mcp_servers = __esm(async () => {
-  init_settings_manager();
+var init_use_agent_mcp_servers = __esm(() => {
+  init_mcp_runtime();
+  init_mcp_runtime();
   init_debug();
-  await __promiseAll([
-    init_mcp_runtime(),
-    init_mcp_runtime()
-  ]);
   import_react110 = __toESM(require_react(), 1);
 });
 
@@ -495908,6 +495834,7 @@ function useConversationLoop(ctx) {
     clearApprovalToolContext,
     closeTrajectorySegment,
     chatgptPlanSwapsRef,
+    chatgptExhaustedProvidersRef,
     consumeQueuedMessages,
     queueModeRef,
     contextTrackerRef,
@@ -496140,6 +496067,7 @@ function useConversationLoop(ctx) {
       conversationBusyRetriesRef.current = 0;
       quotaAutoSwapAttemptedRef.current = false;
       chatgptPlanSwapsRef.current = 0;
+      chatgptExhaustedProvidersRef.current.clear();
     }
     let currentRunId;
     let preserveTranscriptStartForApproval = false;
@@ -497107,8 +497035,10 @@ ${feedback}
         if (chatgptPlanSwapsRef.current < CHATGPT_PLAN_ROTATION_MAX_SWAPS_PER_TURN) {
           const rotation = await rotateChatGPTPlanOnQuotaLimit({
             agentId: agentIdRef.current,
+            conversationId: conversationIdRef.current,
             currentHandle: currentModelId,
-            error: runErrorInfo2 ?? detailFromRun ?? fallbackError
+            error: runErrorInfo2 ?? detailFromRun ?? fallbackError,
+            exhaustedProviders: chatgptExhaustedProvidersRef.current
           });
           if (rotation) {
             chatgptPlanSwapsRef.current += 1;
@@ -498026,6 +497956,8 @@ function useFeedbackHandler(ctx) {
         await submitFeedbackMetadata(apiKey, settingsManager.getOrCreateDeviceId(), {
           message: resolvedMessage,
           feature: "letta-code",
+          submission_source: "slash_command",
+          client_type: getFeedbackClientType(),
           agent_id: agentId,
           session_id: telemetry.getSessionId(),
           run_id: lastRunIdRef.current ?? undefined,
@@ -501442,10 +501374,10 @@ function mcpHelpText() {
 `);
 }
 var activeCommandId2 = null;
-var init_mcp2 = __esm(async () => {
+var init_mcp2 = __esm(() => {
   init_error_formatter();
+  init_mcp_runtime();
   init_settings_manager();
-  await init_mcp_runtime();
 });
 
 // src/cli/commands/listen.ts
@@ -501508,24 +501440,24 @@ Listener disconnected from Letta Cloud.`, true);
     return;
   }
   if (msg.includes("--help") || msg.includes("-h")) {
-    addCommandResult3(ctx.buffersRef, ctx.refreshDerived, msg, `Usage: /server [--env-name <name>]
+    addCommandResult3(ctx.buffersRef, ctx.refreshDerived, msg, `Usage: /server [--computer-name <name>]
        /server off
 
-Register this letta-code instance to receive messages from Letta Cloud.
+Register this computer to receive messages from Letta Cloud.
 Alias: /remote
 
 Options:
-  --env-name <name>  Friendly name for this environment (uses hostname if not provided)
+  --computer-name <name>  Friendly name for this computer (uses hostname if not provided)
   off                Stop the active listener connection
   -h, --help         Show this help message
 
 Examples:
   /server                         # Start listener with hostname
-  /server --env-name "work-laptop" # Start with custom name
+  /server --computer-name "work-laptop" # Start with custom name
   /server off                     # Stop listening
 
 Once connected, this instance will listen for incoming messages from cloud agents.
-Messages will be executed locally using your letta-code environment.`, true);
+Messages will be executed locally on this computer.`, true);
     return;
   }
   let connectionName;
@@ -501575,7 +501507,7 @@ Retry ${attempt2} in ${Math.round(delayMs / 1000)}s: ${error5.message}`, true, "
     updateCommandResult3(ctx.buffersRef, ctx.refreshDerived, cmdId, msg, `✓ Registered successfully!
 
 ` + `Connection ID: ${connectionId}
-Environment: "${connectionName}"
+Computer: "${connectionName}"
 WebSocket: ${wsUrl}
 
 Starting WebSocket connection...`, true, "running");
@@ -501593,18 +501525,18 @@ Starting WebSocket connection...`, true, "running");
           const url2 = buildConnectionUrl(id2);
           const urlText = url2 ? `
 
-Connect to this environment:
+Connect to this computer:
 ${url2}` : "";
-          updateCommandResult3(ctx.buffersRef, ctx.refreshDerived, cmdId, msg, `Environment initialized: ${connectionName}
+          updateCommandResult3(ctx.buffersRef, ctx.refreshDerived, cmdId, msg, `Computer initialized: ${connectionName}
 ${statusText}${urlText}`, true, "finished");
         },
         onRetrying: (attempt2, _maxAttempts, nextRetryIn, id2) => {
           const url2 = buildConnectionUrl(id2);
           const urlText = url2 ? `
 
-Connect to this environment:
+Connect to this computer:
 ${url2}` : "";
-          updateCommandResult3(ctx.buffersRef, ctx.refreshDerived, cmdId, msg, `Environment initialized: ${connectionName}
+          updateCommandResult3(ctx.buffersRef, ctx.refreshDerived, cmdId, msg, `Computer initialized: ${connectionName}
 Reconnecting to Letta Cloud...
 Attempt ${attempt2}, retrying in ${Math.round(nextRetryIn / 1000)}s${urlText}`, true, "running");
         },
@@ -501612,14 +501544,14 @@ Attempt ${attempt2}, retrying in ${Math.round(nextRetryIn / 1000)}s${urlText}`,
           const url2 = buildConnectionUrl(id2);
           const urlText = url2 ? `
 
-Connect to this environment:
+Connect to this computer:
 ${url2}` : "";
-          updateCommandResult3(ctx.buffersRef, ctx.refreshDerived, cmdId, msg, `Environment initialized: ${connectionName}
+          updateCommandResult3(ctx.buffersRef, ctx.refreshDerived, cmdId, msg, `Computer initialized: ${connectionName}
 Awaiting instructions${urlText}`, true, "finished");
           ctx.setCommandRunning(false);
         },
         onNeedsReregister: async () => {
-          updateCommandResult3(ctx.buffersRef, ctx.refreshDerived, cmdId, msg, `Environment expired, re-registering "${connectionName}"...`, true, "running");
+          updateCommandResult3(ctx.buffersRef, ctx.refreshDerived, cmdId, msg, `Computer connection expired, re-registering "${connectionName}"...`, true, "running");
           try {
             const nextRegisterOptions = await resolveRegisterOptions();
             const reregisterResult = await registerWithCloudRetry(nextRegisterOptions, {
@@ -501745,7 +501677,7 @@ async function handleConnectionCommand(msg, trimmed, ctx) {
     for (let i4 = 1;i4 < parts.length; i4++) {
       const part = parts[i4];
       const nextPart = parts[i4 + 1];
-      if (part === "--env-name" && nextPart) {
+      if ((part === "--computer-name" || part === "--env-name") && nextPart) {
         name = nextPart;
         i4++;
       }
@@ -501768,8 +501700,8 @@ async function handleConnectionCommand(msg, trimmed, ctx) {
   }
   return null;
 }
-var init_submit_connection_commands = __esm(async () => {
-  await init_mcp2();
+var init_submit_connection_commands = __esm(() => {
+  init_mcp2();
 });
 
 // src/cli/helpers/context-chart.ts
@@ -505551,6 +505483,7 @@ var init_use_submit_handler = __esm(async () => {
   init_command_routing();
   init_ids();
   init_session3();
+  init_submit_connection_commands();
   init_submit_diagnostics_commands();
   init_submit_profile_commands();
   await __promiseAll([
@@ -505558,7 +505491,6 @@ var init_use_submit_handler = __esm(async () => {
     init_mods2(),
     init_PinDialog(),
     init_accumulator(),
-    init_submit_connection_commands(),
     init_submit_navigation_commands()
   ]);
   import_react120 = __toESM(require_react(), 1);
@@ -506254,6 +506186,7 @@ function App2({
   const quotaAutoSwapAttemptedRef = import_react121.useRef(false);
   const emptyResponseRetriesRef = import_react121.useRef(0);
   const chatgptPlanSwapsRef = import_react121.useRef(0);
+  const chatgptExhaustedProvidersRef = import_react121.useRef(new Set);
   const conversationBusyRetriesRef = import_react121.useRef(0);
   const [queueDisplay, setQueueDisplay] = import_react121.useState([]);
   const tuiQueueRef = import_react121.useRef(null);
@@ -506910,7 +506843,7 @@ function App2({
   import_react121.useEffect(() => {
     buffersRef.current.agentId = agentState?.id;
   }, [agentState?.id]);
-  useAgentMcpServers(agentState?.id);
+  useMcpCleanup(agentState?.id);
   const precomputedDiffsRef = import_react121.useRef(new Map);
   const eagerCommittedPreviewsRef = import_react121.useRef(new Set);
   const estimateApprovalPreviewLines = import_react121.useCallback((approval) => {
@@ -507743,6 +507676,7 @@ Memory may be stale. Try running: git -C ${getScopedMemoryFilesystemRoot(agentId
     buffersRef,
     clearApprovalToolContext,
     chatgptPlanSwapsRef,
+    chatgptExhaustedProvidersRef,
     closeTrajectorySegment,
     consumeQueuedMessages,
     queueModeRef,
@@ -508904,6 +508838,7 @@ var init_AppCoordinator = __esm(async () => {
   init_ids();
   init_model_config();
   init_session3();
+  init_use_agent_mcp_servers();
   init_use_feedback_handler();
   init_use_queued_approval_submit();
   init_use_reasoning_cycle();
@@ -508919,7 +508854,6 @@ var init_AppCoordinator = __esm(async () => {
     init_manager4(),
     init_toolset(),
     init_AppView(),
-    init_use_agent_mcp_servers(),
     init_use_approval_flow(),
     init_use_bash_handlers(),
     init_use_configuration_handlers(),
@@ -509136,14 +509070,13 @@ USAGE
   letta update          Check for updates and install (aliases: upgrade, --update, --upgrade)
   letta memory ...      Memory filesystem subcommands
   letta agents ...      Agents subcommands (JSON-only)
-  letta environments ... List available remote environments (JSON-only)
-  letta teleport ...    Move the current conversation between environments
+  letta computers ...   List available remote computers (JSON-only)
+  letta teleport ...    Move the current conversation between computers
   letta messages ...    Messages subcommands (JSON-only)
   letta mcp ...         List, search, and call MCP servers available to an agent
-  letta cloud-mcp ...   Legacy server-side MCP commands (JSON-only)
   letta mods ...        List and manage local mods
   letta sandbox ...     Transfer files to or from the current Cloud sandbox
-  letta server ...      Run a remote environment, channels, or the App Server
+  letta server ...      Run a remote computer, channels, or the App Server
   letta connect ...     Connect providers from terminal
   letta backend ...     Show or set the default backend
   letta setup           Re-run first-run setup
@@ -509162,20 +509095,19 @@ SUBCOMMANDS
   letta memory pull --agent <id>
   letta memory tokens [--memory-dir <path>] [--agent <id>] [--format text|json]
   letta agents list [--query <text> | --name <name> | --tags <tags>]
-  letta environments list [--online-only]
-  letta environments current
-  letta teleport list|cloud|local|<environment>
+  letta computers list [--online-only]
+  letta computers current
+  letta teleport list|cloud|local|<computer>
   letta messages search --query <text> [--all-agents]
   letta messages list [--agent <id>]
   letta messages transcript --conversation <id> [--out <path>]
-  letta cloud-mcp list|tools|run ... [--agent <id>]
   letta mods list [--agent <id>]
   letta mods package <mod-file> --name <package-name> [--out <dir>]
   letta mods enable <package-spec>
   letta mods disable <package-spec>
   letta mods remove <package-spec>
   letta mcp list|get|tools|search|call ... [--agent <id>]
-  letta server [--env-name <name> | --listen [url]] [options]
+  letta server [--computer-name <name> | --listen [url]] [options]
   letta connect <provider> [options]
   letta install <thing> [--agent <id> | -n <name>]
   letta skills list [--agent <id> | -n <name>]
@@ -509936,7 +509868,7 @@ Error: ${message}`);
   markMilestone("REACT_IMPORT_DONE");
   await terminalPreflightPromise;
   markMilestone("TERMINAL_PREFLIGHT_DONE");
-  const { useState: useState56, useEffect: useEffect50, useRef: useRef20 } = React14;
+  const { useState: useState56, useEffect: useEffect50, useRef: useRef21 } = React14;
   const App3 = AppModule.App;
   function LoadingApp({
     forceNew: forceNew2,
@@ -509960,7 +509892,7 @@ Error: ${message}`);
     const [resumedExistingConversation, setResumedExistingConversation] = useState56(false);
     const [agentProvenance, setAgentProvenance] = useState56(null);
     const [selectedGlobalAgentId, setSelectedGlobalAgentId] = useState56(null);
-    const startupCreatedAgentRef = useRef20(null);
+    const startupCreatedAgentRef = useRef21(null);
     const [startupHasCloudCredentials, setStartupHasCloudCredentials] = useState56(Boolean(settings3.refreshToken || apiKey));
     const [fileAutocompleteFdPath, setFileAutocompleteFdPath] = useState56(() => resolveFdPath());
     const [startupHasAvailableLocalModels, setStartupHasAvailableLocalModels] = useState56(true);
@@ -512995,4 +512927,4 @@ function registerBunOAuthFlows() {
 registerBunOAuthFlows();
 await init_src5().then(() => exports_src2);
 
-//# debugId=39DF2EA197BB152964756E2164756E21
+//# debugId=D6C12B8170F7A1C664756E2164756E21