@letta-ai/letta-code 0.34.15 → 0.34.16

package/letta.js

@@ -5913,7 +5913,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.34.15",
+    version: "0.34.16",
     lettaStartupLogProtocol: 1,
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
@@ -113780,7 +113780,7 @@ function selectChatGPTQuotaFailoverHandle(params) {
   const index = Math.min(Math.floor(random() * candidates2.length), candidates2.length - 1);
   return candidates2[index]?.handle ?? null;
 }
-var INVALID_TOOL_CALL_IDS_FRAGMENT = "invalid tool call ids", APPROVAL_PENDING_DETAIL_FRAGMENT = "waiting for approval", CONVERSATION_BUSY_DETAIL_FRAGMENTS, CONVERSATION_BUSY_RUN_ID_PATTERN, EMPTY_RESPONSE_DETAIL_FRAGMENT = "empty content in", RETRYABLE_PROVIDER_DETAIL_PATTERNS, NON_RETRYABLE_PROVIDER_DETAIL_PATTERNS, NON_RETRYABLE_RUN_ERROR_TYPES, NON_RETRYABLE_429_REASONS, NON_RETRYABLE_QUOTA_DETAIL_PATTERNS, NON_RETRYABLE_4XX_PATTERN, RETRYABLE_429_PATTERN, DEFAULT_TRANSIENT_RETRY_BASE_DELAY_MS = 1000, CLOUDFLARE_EDGE_52X_RETRY_BASE_DELAY_MS = 5000, CONVERSATION_BUSY_RETRY_BASE_DELAY_MS = 1e4, EMPTY_RESPONSE_RETRY_BASE_DELAY_MS = 500, STALE_APPROVAL_RECOVERY_DENIAL_REASON = "The agent harness automatically closed this stale pending tool call to recover from a client/server state desync: the server was still waiting on a result for it, but the harness had no matching tool execution in flight and no result was ever recorded. It was not denied by the user or a permissions policy. Re-issue the tool call if you still need it.", CHATGPT_USAGE_LIMIT_FRAGMENT = "usage_limit_reached", CHATGPT_OAUTH_PROVIDER_TYPE2 = "chatgpt_oauth", BYOK_PROVIDER_CATEGORY = "byok";
+var INVALID_TOOL_CALL_IDS_FRAGMENT = "invalid tool call ids", APPROVAL_PENDING_DETAIL_FRAGMENT = "waiting for approval", CONVERSATION_BUSY_DETAIL_FRAGMENTS, CONVERSATION_BUSY_RUN_ID_PATTERN, EMPTY_RESPONSE_DETAIL_FRAGMENT = "empty content in", RETRYABLE_PROVIDER_DETAIL_PATTERNS, NON_RETRYABLE_PROVIDER_DETAIL_PATTERNS, NON_RETRYABLE_RUN_ERROR_TYPES, NON_RETRYABLE_429_REASONS, NON_RETRYABLE_QUOTA_DETAIL_PATTERNS, NON_RETRYABLE_4XX_PATTERN, RETRYABLE_429_PATTERN, DEFAULT_TRANSIENT_RETRY_BASE_DELAY_MS = 1000, CLOUDFLARE_EDGE_52X_RETRY_BASE_DELAY_MS = 5000, CONVERSATION_BUSY_RETRY_BASE_DELAY_MS = 1e4, EMPTY_RESPONSE_RETRY_BASE_DELAY_MS = 500, STALE_APPROVAL_RECOVERY_DENIAL_REASON = "The agent harness automatically closed this stale pending tool call to recover from a client/server state desync: the server was still waiting on a result for it, but the harness had no matching tool execution in flight and no result was ever recorded. It was not denied by the user or a permissions policy. Re-issue the tool call if you still need it.", STARTED_TOOL_CALL_RECOVERY_DENIAL_REASON = "The agent harness closed this pending tool call while recovering from an interrupted turn. The call had started, but its result was not recorded, so it may or may not have run. Check whether its effect already happened before running it again.", CHATGPT_USAGE_LIMIT_FRAGMENT = "usage_limit_reached", CHATGPT_OAUTH_PROVIDER_TYPE2 = "chatgpt_oauth", BYOK_PROVIDER_CATEGORY = "byok";
 var init_turn_recovery_policy = __esm(() => {
   init_error_formatter();
   init_zai_errors();
@@ -114121,7 +114121,9 @@ var init_local_provider_errors = __esm(() => {
     "timed out",
     "terminated",
     "retry delay",
-    "unable to verify"
+    "unable to verify",
+    "websocket connection limit reached",
+    "exceeded request buffer limit"
   ];
 });
 
@@ -210859,7 +210861,7 @@ var init_mcp_client = __esm(() => {
   init_streamableHttp();
   DEFAULT_CLIENT_INFO = {
     name: "letta-code",
-    version: "0.34.15"
+    version: "0.34.16"
   };
 });
 
@@ -215074,6 +215076,7 @@ agent IDs backed by their native sessions. A message to active work steers its
 in-flight turn (Claude interrupts through stream-json and sends the replacement
 instruction; Codex uses app-server turn/steer). An idle follow-up starts one tracked local background
 turn. Neither path uses the Cloud messaging backend.
+Computer-qualified IDs returned by remote launches can be steered too.
 
 An agent has a persistent identity and shared memory. It can have multiple
 conversations, each with its own message history.
@@ -223299,6 +223302,7 @@ function buildSubagentSnapshot(runtime, scope) {
     prompt: a2.prompt,
     status: a2.status,
     agent_url: a2.agentURL,
+    agent_id: a2.agentId ?? null,
     conversation_id: a2.conversationId ?? null,
     super_run_id: a2.superRunId,
     model: a2.model,
@@ -240089,7 +240093,7 @@ class CodexAppServerClient {
     await this.request("initialize", {
       clientInfo: {
         name: "letta-code",
-        version: "0.34.15"
+        version: "0.34.16"
       },
       capabilities: null
     });
@@ -241207,10 +241211,22 @@ async function buildAgentInfoReminder(context3) {
   context3.state.hasSentAgentInfo = true;
   return reminder || null;
 }
+async function listAvailableSecretNames(agentId, lookupParent) {
+  const { ensureSecretsLoaded: ensureSecretsLoaded2, listSecretNames: listSecretNames2 } = await Promise.resolve().then(() => (init_secrets_store(), exports_secrets_store));
+  const names2 = new Set(listSecretNames2(agentId));
+  try {
+    const scopeAgentId = await getMcpScopeAgentId(agentId, undefined, lookupParent);
+    if (scopeAgentId !== agentId) {
+      await ensureSecretsLoaded2(scopeAgentId);
+      for (const name of listSecretNames2(scopeAgentId))
+        names2.add(name);
+    }
+  } catch {}
+  return [...names2].sort();
+}
 async function buildSecretsInfoReminder(context3) {
   try {
-    const { listSecretNames: listSecretNames2 } = await Promise.resolve().then(() => (init_secrets_store(), exports_secrets_store));
-    const names2 = listSecretNames2(context3.agent.id);
+    const names2 = await listAvailableSecretNames(context3.agent.id);
     const namesKey = names2.join("\x00");
     const isRefresh = context3.state.pendingSecretsInfoRefresh;
     const namesChanged = context3.state.lastSentSecretNamesKey !== null && context3.state.lastSentSecretNamesKey !== namesKey;
@@ -242574,18 +242590,24 @@ function createExternalCodingAgentConfig(type3) {
 function isExternalCodingAgentType(value) {
   return EXTERNAL_CODING_AGENT_TYPES.includes(value);
 }
-function formatExternalCodingAgentId(type3, sessionId) {
-  return `${EXTERNAL_AGENT_ID_PREFIXES[type3]}${sessionId}`;
+function formatExternalCodingAgentId(type3, sessionId, computer) {
+  const id2 = `${EXTERNAL_AGENT_ID_PREFIXES[type3]}${sessionId}`;
+  return computer ? `${id2}@${computer}` : id2;
 }
 function parseExternalCodingAgentId(agentId) {
   if (!agentId)
     return null;
+  const separator = agentId.lastIndexOf("@");
+  const nativeId = separator === -1 ? agentId : agentId.slice(0, separator);
+  const computer = separator === -1 ? undefined : agentId.slice(separator + 1);
+  if (computer !== undefined && !computer.trim())
+    return null;
   for (const type3 of EXTERNAL_CODING_AGENT_TYPES) {
     const prefix = EXTERNAL_AGENT_ID_PREFIXES[type3];
-    if (agentId.startsWith(prefix)) {
-      const sessionId = agentId.slice(prefix.length);
+    if (nativeId.startsWith(prefix)) {
+      const sessionId = nativeId.slice(prefix.length);
       if ((type3 === "opencode" ? /^ses_[a-zA-Z0-9]+$/ : NATIVE_SESSION_ID_PATTERN).test(sessionId)) {
-        return { type: type3, sessionId };
+        return { type: type3, sessionId, ...computer ? { computer } : {} };
       }
     }
   }
@@ -242768,10 +242790,27 @@ function parseExternalCodingAgentOutput(type3, stdout) {
     ...sessionId ? { sessionId } : {}
   };
 }
+async function resolveExternalCodingAgentSecretEnv(parentAgentId, lookupParent) {
+  const { ensureSecretsLoaded: ensureSecretsLoaded2, loadSecrets: loadSecrets2 } = await Promise.resolve().then(() => (init_secrets_store(), exports_secrets_store));
+  let inherited = {};
+  try {
+    const scopeAgentId = await getMcpScopeAgentId(parentAgentId, undefined, lookupParent);
+    if (scopeAgentId !== parentAgentId) {
+      await ensureSecretsLoaded2(scopeAgentId);
+      inherited = loadSecrets2(scopeAgentId);
+    }
+  } catch {}
+  try {
+    await ensureSecretsLoaded2(parentAgentId);
+  } catch {}
+  return { ...inherited, ...loadSecrets2(parentAgentId) };
+}
 async function runExternalCodingAgent(options, deps = {}) {
   const startedAt = Date.now();
+  const secretEnv = await (deps.resolveSecretEnv ?? resolveExternalCodingAgentSecretEnv)(options.parentAgentId);
   const env6 = {
     ...deps.env ?? process.env,
+    ...secretEnv,
     AGENT_ID: options.parentAgentId,
     LETTA_AGENT_ID: options.parentAgentId,
     LETTA_PARENT_AGENT_ID: options.parentAgentId,
@@ -242798,7 +242837,14 @@ async function runExternalCodingAgent(options, deps = {}) {
     captureReservation ??= reserveNativeSessionCapture(source, sessionId, scope, env6);
     return captureReservation;
   };
-  const capture = async (result3) => {
+  const capture = async (rawResult) => {
+    const result3 = {
+      ...rawResult,
+      report: scrubSecretsFromString(rawResult.report, secretEnv),
+      ...rawResult.error !== undefined && {
+        error: scrubSecretsFromString(rawResult.error, secretEnv)
+      }
+    };
     const sessionId = result3.runtimeSessionId ?? captureSessionId;
     if (scope && sessionId) {
       try {
@@ -242931,6 +242977,7 @@ var init_external_coding_agent = __esm(() => {
   init_mcp_scope();
   init_engine3();
   init_runtime_context();
+  init_secret_substitution();
   init_claude_stream_session();
   init_codex_app_server();
   init_native_session_capture();
@@ -243628,7 +243675,7 @@ function isAppServerInfoResponseMessage(message2) {
     return false;
   }
   const capabilityRecord = capabilities;
-  return candidate.type === "app_server_info_response" && typeof candidate.request_id === "string" && candidate.request_id.length > 0 && candidate.success === true && (candidate.backend === "local" || candidate.backend === "api") && typeof candidate.letta_code_version === "string" && typeof candidate.protocol_version === "number" && Number.isInteger(candidate.protocol_version) && typeof capabilityRecord.agent_management === "boolean" && typeof capabilityRecord.conversation_management === "boolean" && typeof capabilityRecord.memory_management === "boolean" && typeof capabilityRecord.runtime_start === "boolean" && (capabilityRecord.agent_free_conversations === undefined || typeof capabilityRecord.agent_free_conversations === "boolean") && (capabilityRecord.launch_subagent === undefined || typeof capabilityRecord.launch_subagent === "boolean") && (capabilityRecord.launch_subagent_notify_caller === undefined || typeof capabilityRecord.launch_subagent_notify_caller === "boolean") && (capabilityRecord.runtime_workspace_sandbox === undefined || typeof capabilityRecord.runtime_workspace_sandbox === "boolean") && (capabilityRecord.runtime_external_tools_update === undefined || typeof capabilityRecord.runtime_external_tools_update === "boolean") && (capabilityRecord.structured_outputs === undefined || typeof capabilityRecord.structured_outputs === "boolean") && (capabilityRecord.write_file_base64 === undefined || typeof capabilityRecord.write_file_base64 === "boolean") && typeof capabilityRecord.split_channels === "boolean";
+  return candidate.type === "app_server_info_response" && typeof candidate.request_id === "string" && candidate.request_id.length > 0 && candidate.success === true && (candidate.backend === "local" || candidate.backend === "api") && typeof candidate.letta_code_version === "string" && typeof candidate.protocol_version === "number" && Number.isInteger(candidate.protocol_version) && typeof capabilityRecord.agent_management === "boolean" && typeof capabilityRecord.conversation_management === "boolean" && typeof capabilityRecord.memory_management === "boolean" && typeof capabilityRecord.runtime_start === "boolean" && (capabilityRecord.agent_free_conversations === undefined || typeof capabilityRecord.agent_free_conversations === "boolean") && (capabilityRecord.launch_subagent === undefined || typeof capabilityRecord.launch_subagent === "boolean") && (capabilityRecord.launch_subagent_notify_caller === undefined || typeof capabilityRecord.launch_subagent_notify_caller === "boolean") && (capabilityRecord.subagent_message === undefined || typeof capabilityRecord.subagent_message === "boolean") && (capabilityRecord.runtime_workspace_sandbox === undefined || typeof capabilityRecord.runtime_workspace_sandbox === "boolean") && (capabilityRecord.runtime_external_tools_update === undefined || typeof capabilityRecord.runtime_external_tools_update === "boolean") && (capabilityRecord.structured_outputs === undefined || typeof capabilityRecord.structured_outputs === "boolean") && (capabilityRecord.write_file_base64 === undefined || typeof capabilityRecord.write_file_base64 === "boolean") && typeof capabilityRecord.split_channels === "boolean";
 }
 var APP_SERVER_PROTOCOL_VERSION = 1;
 
@@ -243882,6 +243929,26 @@ class AppServerClient {
       predicate: (message2) => message2.type === "launch_subagent_response"
     });
   }
+  sendSubagentMessage(command, options = {}) {
+    return this.request({
+      ...command,
+      type: "subagent_message",
+      request_id: command.request_id ?? this.nextRequestId("subagent-message")
+    }, {
+      ...options,
+      predicate: (message2) => message2.type === "subagent_message_response"
+    });
+  }
+  stopSubagent(command, options = {}) {
+    return this.request({
+      ...command,
+      type: "subagent_stop",
+      request_id: command.request_id ?? this.nextRequestId("subagent-stop")
+    }, {
+      ...options,
+      predicate: (message2) => message2.type === "subagent_stop_response" && message2.agent_id === command.agent_id
+    });
+  }
   runtimeStart(command, options = {}) {
     return this.request({
       type: "runtime_start",
@@ -246262,6 +246329,9 @@ function formatRemoteStartupError(type3, computer, code2) {
 function formatOutdatedComputerError(type3, computer) {
   return `${computer} is running an older Letta Code that can't run ${DISPLAY_NAMES[type3]} subagents remotely. Update Letta Code on ${computer}.`;
 }
+function formatOutdatedSteeringError(computer) {
+  return `${computer} is running an older Letta Code that can't steer Claude Code subagents remotely. Update Letta Code on ${computer}.`;
+}
 async function defaultResolveComputer(computer, scope) {
   if (!isCloudEnvironmentSelector(computer))
     return resolveEnvironmentConnectionId(computer);
@@ -246290,6 +246360,18 @@ async function defaultConnect(connectionId, scope) {
     throw error5;
   }
 }
+async function resolveQualifiedComputer(deviceId) {
+  try {
+    const environment2 = await getEnvironmentConnection(deviceId);
+    if (!isEnvironmentOnline(environment2) || !environment2.connectionId)
+      throw new Error(`Computer "${deviceId}" is offline`);
+    return { connectionId: environment2.connectionId, environment: environment2 };
+  } catch (error5) {
+    if (errorMessage3(error5).includes("offline"))
+      throw error5;
+    return resolveEnvironmentConnectionId(deviceId);
+  }
+}
 function errorMessage3(error5) {
   return error5 instanceof Error ? error5.message : String(error5);
 }
@@ -246342,6 +246424,22 @@ class RemoteSubagentFollower {
   markLaunched() {
     this.launched = true;
   }
+  async waitForAgentId(timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      if (this.latest?.agent_id)
+        return this.latest.agent_id;
+      const remaining = deadline - Date.now();
+      if (remaining <= 0 || this.closed || this.lost)
+        break;
+      await Promise.race([
+        this.wake.promise,
+        new Promise((resolve37) => setTimeout(resolve37, remaining))
+      ]);
+      this.wake = Promise.withResolvers();
+    }
+    return this.latest?.agent_id ?? null;
+  }
   close() {
     this.closed = true;
     this.detach?.();
@@ -246395,6 +246493,8 @@ class RemoteSubagentFollower {
 async function launchRemoteExternalCodingAgent(params, deps) {
   const { type: type3, computer, parentScope } = params;
   let connectionId;
+  let deviceId;
+  let supportsSteering;
   try {
     const resolved2 = await (deps.resolveComputer ?? defaultResolveComputer)(computer, parentScope);
     if (resolved2.environment.metadata?.launch_subagent_notify_caller !== true)
@@ -246403,6 +246503,8 @@ async function launchRemoteExternalCodingAgent(params, deps) {
         error: formatOutdatedComputerError(type3, computer)
       };
     connectionId = resolved2.connectionId;
+    deviceId = resolved2.environment.deviceId;
+    supportsSteering = resolved2.environment.metadata?.subagent_message === true;
   } catch (error5) {
     return { success: false, error: errorMessage3(error5) };
   }
@@ -246454,7 +246556,10 @@ async function launchRemoteExternalCodingAgent(params, deps) {
     };
   }
   follower.markLaunched();
-  const { taskId, outputFile } = deps.spawn({
+  const nativeAgentId = supportsSteering ? await follower.waitForAgentId(deps.agentIdWaitMs ?? 2000) : null;
+  const parsedNativeAgentId = nativeAgentId ? parseExternalCodingAgentId(nativeAgentId) : null;
+  const qualifiedAgentId = parsedNativeAgentId && !parsedNativeAgentId.computer ? formatExternalCodingAgentId(parsedNativeAgentId.type, parsedNativeAgentId.sessionId, deviceId) : null;
+  const { taskId, outputFile, subagentId } = deps.spawn({
     subagentType: type3,
     config: createExternalCodingAgentConfig(type3),
     prompt: params.prompt,
@@ -246463,16 +246568,16 @@ async function launchRemoteExternalCodingAgent(params, deps) {
     toolCallId: params.toolCallId,
     parentScope,
     deps: {
-      spawnSubagentImpl: async (_type, _prompt, model, subagentId, signal) => {
+      spawnSubagentImpl: async (_type, _prompt, model, subagentId2, signal) => {
         const startedAt = Date.now();
-        updateSubagent(subagentId, { status: "running" });
+        updateSubagent(subagentId2, { status: "running" });
         try {
-          const final = await follower.waitForTerminal(signal, (snapshot2) => updateSubagent(subagentId, {
+          const final = await follower.waitForTerminal(signal, (snapshot2) => updateSubagent(subagentId2, {
             toolCalls: snapshot2.tool_calls,
             totalTokens: snapshot2.total_tokens
           }));
           return {
-            agentId: parentScope.agentId,
+            agentId: qualifiedAgentId ?? parentScope.agentId,
             model: final.model ?? model,
             report: final.result ?? "",
             success: final.status === "completed",
@@ -246495,14 +246600,142 @@ async function launchRemoteExternalCodingAgent(params, deps) {
       }
     }
   });
+  if (qualifiedAgentId)
+    updateSubagent(subagentId, { agentId: qualifiedAgentId });
   return {
     success: true,
     task_id: taskId,
     output_file: outputFile,
-    agent_id: null,
+    agent_id: qualifiedAgentId,
     conversation_id: null
   };
 }
+async function connectQualifiedTarget(agentId, parentScope, deps) {
+  const target2 = parseExternalCodingAgentId(agentId);
+  if (!target2?.computer || target2.type === "opencode")
+    throw new Error(`Invalid remote external coding agent ID: ${agentId}`);
+  const resolved2 = await (deps.resolveComputer ?? resolveQualifiedComputer)(target2.computer);
+  if (resolved2.environment.metadata?.subagent_message !== true)
+    throw new Error(formatOutdatedSteeringError(target2.computer));
+  return {
+    target: target2,
+    client: await (deps.connect ?? defaultConnect)(resolved2.connectionId, parentScope)
+  };
+}
+async function stopRemoteExternalCodingAgent(params, deps = {}) {
+  const requestId = `subagent-stop-${randomUUID41()}`;
+  const { target: target2, client } = await connectQualifiedTarget(params.agentId, params.parentScope, deps);
+  try {
+    const response = await client.stopSubagent({
+      request_id: requestId,
+      runtime: {
+        agent_id: params.parentScope.agentId,
+        conversation_id: params.parentScope.conversationId,
+        ...params.parentScope.actingUserId ? { acting_user_id: params.parentScope.actingUserId } : {}
+      },
+      agent_id: formatExternalCodingAgentId(target2.type, target2.sessionId)
+    });
+    if (!response.success)
+      throw new Error(response.error ?? "Stop failed");
+    return { stopped: response.stopped };
+  } finally {
+    client.close();
+  }
+}
+async function sendRemoteExternalCodingAgentMessage(params, deps = {}) {
+  const requestId = `subagent-message-${randomUUID41()}`;
+  const { target: target2, client } = await connectQualifiedTarget(params.agentId, params.parentScope, deps);
+  const toolCallId = params.toolCallId ?? `remote-followup-${randomUUID41()}`;
+  const connect = async () => {
+    const resolved2 = await (deps.resolveComputer ?? resolveQualifiedComputer)(target2.computer);
+    return (deps.connect ?? defaultConnect)(resolved2.connectionId, params.parentScope);
+  };
+  const follower = new RemoteSubagentFollower(params.parentScope, toolCallId, connect, 2000);
+  follower.attach(client);
+  const bareAgentId = formatExternalCodingAgentId(target2.type, target2.sessionId);
+  let response;
+  try {
+    response = await client.sendSubagentMessage({
+      request_id: requestId,
+      runtime: {
+        agent_id: params.parentScope.agentId,
+        conversation_id: params.parentScope.conversationId,
+        ...params.parentScope.actingUserId ? { acting_user_id: params.parentScope.actingUserId } : {}
+      },
+      agent_id: bareAgentId,
+      message: params.message,
+      tool_call_id: toolCallId
+    });
+  } catch (error5) {
+    follower.close();
+    throw error5;
+  }
+  if (!response.success) {
+    follower.close();
+    throw new Error(response.error);
+  }
+  if (response.delivery === "steered") {
+    follower.close();
+    return { delivery: "steered" };
+  }
+  follower.markLaunched();
+  const completion = follower.waitForTerminal(undefined, () => {
+    return;
+  }).then((final) => ({
+    agentId: bareAgentId,
+    model: final.model,
+    report: final.result ?? "",
+    success: final.status === "completed",
+    ...final.status === "error" ? { error: final.error ?? "Remote follow-up failed" } : {},
+    totalTokens: final.total_tokens,
+    durationMs: final.duration_ms
+  })).finally(() => follower.close());
+  const interrupt = async () => {
+    const resolved2 = await (deps.resolveComputer ?? resolveQualifiedComputer)(target2.computer);
+    const stopClient = await (deps.connect ?? defaultConnect)(resolved2.connectionId, params.parentScope);
+    try {
+      await stopClient.stopSubagent({
+        runtime: {
+          agent_id: params.parentScope.agentId,
+          conversation_id: params.parentScope.conversationId
+        },
+        agent_id: bareAgentId
+      });
+    } finally {
+      stopClient.close();
+    }
+  };
+  const track = deps.track;
+  if (!track) {
+    follower.close();
+    throw new Error("Remote follow-up tracking is unavailable");
+  }
+  let tracked;
+  try {
+    tracked = track({
+      type: target2.type,
+      agentId: params.agentId,
+      message: params.message,
+      parentScope: params.parentScope,
+      completion,
+      interrupt
+    });
+  } catch (error5) {
+    try {
+      await interrupt();
+    } catch {}
+    follower.close();
+    completion.catch(() => {
+      return;
+    });
+    throw error5;
+  }
+  return {
+    delivery: "resumed",
+    taskId: tracked.taskId,
+    outputFile: tracked.outputFile
+  };
+}
 var DISPLAY_NAMES, RemoteWorkerLostError;
 var init_remote_external_coding_agent = __esm(() => {
   init_subagent_state();
@@ -247160,6 +247393,8 @@ function trackExternalFollowupCompletion(args) {
     prompt: args.message,
     description: `Continue ${args.type} session`,
     existingAgentId: args.agentId,
+    toolCallId: args.toolCallId,
+    publishResult: args.publishResult,
     parentScope: args.parentScope,
     actingUserId: args.parentScope.actingUserId,
     deps: {
@@ -247273,6 +247508,28 @@ async function send_agent_message(args, deps = {}) {
       }
       args.signal?.throwIfAborted();
       const parentScope = sender;
+      if (externalTarget.computer) {
+        const receipt3 = await (deps.sendRemoteExternalMessage ?? sendRemoteExternalCodingAgentMessage)({
+          agentId: args.agent_id,
+          message: args.message,
+          parentScope: {
+            ...parentScope,
+            actingUserId: getRuntimeActingUserAttribution()
+          }
+        }, {
+          track: deps.trackExternalFollowup ?? trackExternalFollowupCompletion
+        });
+        return {
+          content: JSON.stringify({
+            status: "accepted",
+            agent_id: args.agent_id,
+            delivery: receipt3.delivery === "steered" ? "remote/steer" : "remote/resume",
+            ...receipt3.taskId ? { task_id: receipt3.taskId } : {},
+            ...receipt3.outputFile ? { output_file: receipt3.outputFile } : {}
+          }),
+          status: "success"
+        };
+      }
       if (externalTarget.type === "opencode") {
         const receipt3 = await sendOpenCodeMessage({
           sessionId: externalTarget.sessionId,
@@ -247546,6 +247803,7 @@ var init_send_agent_message = __esm(async () => {
   init_external_coding_agent();
   init_native_session_capture();
   init_opencode_session();
+  init_remote_external_coding_agent();
   await init_external_coding_agent_task();
   FULL_CONVERSATION_ID = /^conv-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 });
@@ -248068,13 +248326,40 @@ async function cancelRemoteRun(subagentId) {
     };
   }
 }
-async function task_stop(args) {
+async function task_stop(args, deps = {}) {
   validateRequiredParams(args, ["task_id"], "TaskStop");
   const { task_id } = args;
   const task2 = backgroundTasks.get(task_id);
   if (task2) {
     if (task2.status === "running" && task2.abortController) {
-      const remote = task2.remote ? await cancelRemoteRun(task2.subagentId) : undefined;
+      const child = getSubagents().find((agent) => agent.id === task2.subagentId);
+      const external3 = parseExternalCodingAgentId(child?.agentId ?? undefined);
+      let remote;
+      if (external3?.computer) {
+        try {
+          if (!task2.runtimeScope)
+            throw new Error("its parent conversation is not known");
+          const result3 = await (deps.stopRemoteExternal ?? stopRemoteExternalCodingAgent)({
+            agentId: child?.agentId,
+            parentScope: {
+              agentId: task2.runtimeScope.agentId,
+              conversationId: task2.runtimeScope.conversationId,
+              actingUserId: task2.actingUserId
+            }
+          });
+          remote = {
+            killed: result3.stopped,
+            output: result3.stopped ? "Stopped the remote external subagent" : "The remote external subagent was not running"
+          };
+        } catch (error5) {
+          remote = {
+            killed: false,
+            output: `Couldn't stop the remote external subagent: ${getErrorMessage2(error5)}`
+          };
+        }
+      } else if (task2.remote) {
+        remote = await cancelRemoteRun(task2.subagentId);
+      }
       if (remote && !remote.killed)
         return remote;
       task2.abortController.abort();
@@ -248091,7 +248376,9 @@ async function task_stop(args) {
 var init_task_stop = __esm(async () => {
   init_subagent_state();
   init_backend2();
+  init_external_coding_agent();
   init_process_manager();
+  init_remote_external_coding_agent();
   await init_kill_bash();
 });
 
@@ -258274,11 +258561,13 @@ function buildQueuedTurnMessage(runtime, batch) {
     return null;
   const scopeItem = batch.items[0];
   const batchActingUserId = batch.items.some((item) => item.kind === "message") ? getBatchActingUserId(batch.items) : template3?.actingUserId ?? getBatchActingUserId(batch.items);
+  const processOwnedTurn = !batch.items.some((item) => item.kind === "message");
   return {
     type: "message",
     agentId: scopeItem?.agentId ?? runtime.agentId ?? undefined,
     conversationId: scopeItem?.conversationId ?? runtime.conversationId,
     ...template3,
+    ...processOwnedTurn ? { processOwnedTurn: true } : {},
     actingUserId: batchActingUserId ?? undefined,
     suppressActingUserFallback: batchActingUserId === null || batchActingUserId === undefined && template3?.suppressActingUserFallback === true,
     ...durableInputIdentities.length > 0 ? { durableInputIdentities: [...new Set(durableInputIdentities)] } : {},
@@ -262377,17 +262666,11 @@ function ListenerStatusUI(props) {
           }, undefined, false, undefined, this)
         ]
       }, undefined, true, undefined, this),
-      /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(Box_default, {
-        children: isFirstRun ? /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(Text, {
+      isFirstRun && /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(Box_default, {
+        children: /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(Text, {
           dimColor: true,
           children: "Connected. Head back to Letta in your browser — it will detect this computer automatically. Keep this window open."
-        }, undefined, false, undefined, this) : /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(Text, {
-          dimColor: true,
-          children: [
-            '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)
+        }, undefined, false, undefined, this)
       }, undefined, false, undefined, this)
     ]
   }, undefined, true, undefined, this);
@@ -263018,6 +263301,7 @@ async function registerWithCloud(opts, fetchImpl = fetch) {
         supportsPairedListenerGenerations: true,
         supported_commands: SUPPORTED_REMOTE_COMMANDS,
         launch_subagent_notify_caller: true,
+        subagent_message: true,
         self_update: getSelfUpdateStatus()
       }
     })
@@ -264207,6 +264491,20 @@ function isLaunchSubagentCommand(value) {
     return false;
   return args.max_turns === undefined || typeof args.max_turns === "number" && Number.isSafeInteger(args.max_turns) && args.max_turns > 0;
 }
+function hasValidControlBase(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const c = value;
+  return typeof c.request_id === "string" && c.request_id.trim().length > 0 && isAgentRuntimeScope(c.runtime) && c.runtime.agent_id.trim().length > 0 && c.runtime.conversation_id.trim().length > 0 && typeof c.agent_id === "string" && c.agent_id.trim().length > 0;
+}
+function isSubagentMessageCommand(value) {
+  if (!hasValidControlBase(value) || value.type !== "subagent_message")
+    return false;
+  return typeof value.message === "string" && value.message.trim().length > 0 && (value.tool_call_id === undefined || typeof value.tool_call_id === "string" && value.tool_call_id.trim().length > 0);
+}
+function isSubagentStopCommand(value) {
+  return hasValidControlBase(value) && value.type === "subagent_stop";
+}
 var ARGUMENTS;
 var init_subagent_protocol_inbound = __esm(() => {
   ARGUMENTS = new Set([
@@ -264250,7 +264548,7 @@ var init_browser_device_mcp_oauth_protocol_inbound = __esm(() => {
 
 // src/websocket/listener/task-control-protocol-inbound.ts
 function isTaskControlProtocolCommand(value) {
-  return isBrowserDeviceMcpOAuthProtocolCommand(value) || isExecuteCommandCommand(value) || isRemoveQueueItemCommand(value) || isMonitorStopCommand(value);
+  return isBrowserDeviceMcpOAuthProtocolCommand(value) || isExecuteCommandCommand(value) || isRemoveQueueItemCommand(value) || isMonitorStopCommand(value) || isSubagentMessageCommand(value) || isSubagentStopCommand(value);
 }
 function isExecuteCommandCommand(value) {
   if (!value || typeof value !== "object")
@@ -264272,6 +264570,7 @@ function isMonitorStopCommand(value) {
 }
 var init_task_control_protocol_inbound = __esm(() => {
   init_browser_device_mcp_oauth_protocol_inbound();
+  init_subagent_protocol_inbound();
 });
 
 // src/websocket/listener/protocol-inbound.ts
@@ -459752,6 +460051,7 @@ function buildAppServerInfoResponse(command, options) {
       agent_free_conversations: true,
       launch_subagent: true,
       launch_subagent_notify_caller: true,
+      subagent_message: true,
       runtime_workspace_sandbox: true,
       runtime_external_tools_update: true,
       structured_outputs: options.backend === "api",
@@ -461248,6 +461548,174 @@ var init_monitors = __esm(async () => {
   ]);
 });
 
+// src/websocket/listener/commands/subagent-control.ts
+function dedupeKey(command) {
+  return JSON.stringify([
+    command.runtime.agent_id,
+    command.runtime.conversation_id,
+    command.agent_id,
+    command.request_id
+  ]);
+}
+function finishUntrackedNativeCapture2(completion, reservation, source, sessionId) {
+  if (!reservation)
+    return;
+  completion.then(() => reservation.capture(), () => reservation.capture()).catch((error5) => reportNativeSessionCaptureFailure(source, sessionId, error5));
+}
+function findOwnedTask(runtime, agentId) {
+  const subagent = getSubagents().find((entry) => entry.agentId === agentId && entry.parentAgentId === runtime.agentId && entry.parentConversationId === runtime.conversationId);
+  if (!subagent)
+    return;
+  return [...backgroundTasks.entries()].find(([, task2]) => task2.subagentId === subagent.id);
+}
+function runtimeContext(parent, command) {
+  return {
+    agentId: parent.agentId,
+    conversationId: parent.conversationId,
+    actingUserId: command.runtime.acting_user_id,
+    workingDirectory: getConversationWorkingDirectory(parent.listener, parent.agentId, parent.conversationId),
+    skillSources: parent.skillSources,
+    workspaceSandbox: parent.workspaceSandbox,
+    executionSettings: parent.executionSettings
+  };
+}
+async function handleSubagentMessageCommand(command, parent, deps = {}) {
+  const now2 = (deps.now ?? Date.now)();
+  const key3 = dedupeKey(command);
+  for (const [id2, cached4] of responses) {
+    if (cached4.expiresAt <= now2)
+      responses.delete(id2);
+  }
+  const cached3 = responses.get(key3);
+  if (cached3)
+    return cached3.response;
+  const response = (async () => {
+    const base2 = {
+      type: "subagent_message_response",
+      request_id: command.request_id,
+      runtime: command.runtime
+    };
+    try {
+      if (parent.agentId !== command.runtime.agent_id || parent.conversationId !== command.runtime.conversation_id)
+        throw new Error("Parent runtime does not match the message request");
+      if (!findOwnedTask(parent, command.agent_id))
+        throw new Error("Subagent does not belong to this conversation");
+      const target2 = parseExternalCodingAgentId(command.agent_id);
+      if (!target2 || target2.computer || !isExternalCodingAgentType(target2.type))
+        throw new Error("Invalid external coding agent ID");
+      if (!target2.sessionId)
+        throw new Error("External coding agent ID has no session ID");
+      const sessionId = target2.sessionId;
+      if (target2.type === "opencode")
+        throw new Error("Remote OpenCode steering is not supported");
+      let captureReservation;
+      const source = target2.type === "claude-code" ? "claude_code" : "codex";
+      const receipt = await runOutsideRuntimeContext(() => runWithRuntimeContext(runtimeContext(parent, command), () => target2.type === "claude-code" ? (deps.sendClaude ?? sendClaudeMessage)({
+        sessionId: target2.sessionId,
+        prompt: command.message,
+        parentAgentId: command.runtime.agent_id,
+        cwd: getCurrentWorkingDirectory(),
+        beforeStart: async () => {
+          captureReservation = await (deps.reserveCapture ?? reserveNativeSessionCapture)(source, sessionId, {
+            agentId: command.runtime.agent_id,
+            conversationId: command.runtime.conversation_id,
+            actingUserId: command.runtime.acting_user_id
+          });
+        }
+      }) : (deps.sendCodex ?? sendCodexMessage)({
+        threadId: target2.sessionId,
+        prompt: command.message,
+        parentAgentId: command.runtime.agent_id,
+        cwd: getCurrentWorkingDirectory(),
+        beforeStart: async () => {
+          captureReservation = await (deps.reserveCapture ?? reserveNativeSessionCapture)(source, sessionId, {
+            agentId: command.runtime.agent_id,
+            conversationId: command.runtime.conversation_id,
+            actingUserId: command.runtime.acting_user_id
+          });
+        }
+      })));
+      if (receipt.mode === "steered")
+        return { ...base2, success: true, delivery: "steered" };
+      if (!receipt.completion || !receipt.interrupt)
+        throw new Error("External coding agent returned an incomplete receipt");
+      try {
+        (deps.track ?? trackExternalFollowupCompletion)({
+          type: target2.type,
+          agentId: command.agent_id,
+          message: command.message,
+          parentScope: {
+            agentId: parent.agentId,
+            conversationId: parent.conversationId,
+            actingUserId: command.runtime.acting_user_id
+          },
+          completion: receipt.completion,
+          interrupt: receipt.interrupt,
+          captureReservation,
+          toolCallId: command.tool_call_id,
+          publishResult: true
+        });
+      } catch (error5) {
+        await receipt.interrupt().catch(() => {
+          return;
+        });
+        finishUntrackedNativeCapture2(receipt.completion, captureReservation, source, sessionId);
+        throw error5;
+      }
+      return { ...base2, success: true, delivery: "resumed" };
+    } catch (error5) {
+      return {
+        ...base2,
+        success: false,
+        error: error5 instanceof Error ? error5.message : String(error5)
+      };
+    }
+  })();
+  responses.set(key3, {
+    expiresAt: now2 + DEDUPE_TTL_MS,
+    response
+  });
+  const result3 = await response;
+  if (!result3.success && responses.get(key3)?.response === response)
+    responses.delete(key3);
+  return result3;
+}
+async function handleSubagentStopCommand(command, parent) {
+  const base2 = {
+    type: "subagent_stop_response",
+    request_id: command.request_id,
+    runtime: command.runtime,
+    agent_id: command.agent_id,
+    success: false,
+    stopped: false
+  };
+  if (parent.agentId !== command.runtime.agent_id || parent.conversationId !== command.runtime.conversation_id)
+    return { ...base2, error: "Parent runtime does not match the stop request" };
+  const owned = findOwnedTask(parent, command.agent_id);
+  if (!owned)
+    return { ...base2, error: "Subagent does not belong to this conversation" };
+  const [, task2] = owned;
+  if (task2.status !== "running")
+    return { ...base2, success: true };
+  if (!task2.abortController)
+    return { ...base2, error: "Subagent could not be stopped" };
+  task2.abortController.abort(new Error("Stopped by remote parent"));
+  return { ...base2, success: true, stopped: true };
+}
+var DEDUPE_TTL_MS = 30000, responses;
+var init_subagent_control = __esm(async () => {
+  init_subagent_state();
+  init_runtime_context();
+  init_claude_stream_session();
+  init_codex_app_server();
+  init_external_coding_agent();
+  init_native_session_capture();
+  init_process_manager();
+  init_cwd();
+  await init_external_coding_agent_task();
+  responses = new Map;
+});
+
 // src/websocket/listener/commands/subagents.ts
 async function handleLaunchSubagentCommand(command, parent, connectionId, launch = launchSubagent, startupTimeoutMs2 = 25000) {
   const response = {
@@ -461330,10 +461798,16 @@ async function handleTaskControlCommand(command, context3) {
     safeSocketSend
   } = context3;
   const execute = async () => {
-    const response = command.type === "monitor_stop" ? await handleMonitorStopCommand(command, runtime) : await handleLaunchSubagentCommand(command, getOrCreateScopedRuntime2(runtime, command.runtime.agent_id, command.runtime.conversation_id), connectionId);
+    if (command.type === "monitor_stop") {
+      const response2 = await handleMonitorStopCommand(command, runtime);
+      safeSocketSend(socket, response2, response2.type, command.type);
+      return;
+    }
+    const parent = getOrCreateScopedRuntime2(runtime, command.runtime.agent_id, command.runtime.conversation_id);
+    const response = command.type === "launch_subagent" ? await handleLaunchSubagentCommand(command, parent, connectionId) : command.type === "subagent_message" ? await handleSubagentMessageCommand(command, parent) : await handleSubagentStopCommand(command, parent);
     safeSocketSend(socket, response, response.type, command.type);
   };
-  if (command.type === "launch_subagent") {
+  if (command.type === "launch_subagent" || command.type === "subagent_message") {
     runDetachedListenerTask2(command.type, execute);
   } else {
     await execute();
@@ -461342,6 +461816,7 @@ async function handleTaskControlCommand(command, context3) {
 var init_task_control = __esm(async () => {
   await __promiseAll([
     init_monitors(),
+    init_subagent_control(),
     init_subagents3()
   ]);
 });
@@ -461415,7 +461890,7 @@ function createListenerMessageHandler(params) {
         handleTurnFinishedAck(runtime, socket, connectionId, parsed);
         return;
       }
-      if (parsed.type === "launch_subagent" || parsed.type === "monitor_stop") {
+      if (parsed.type === "launch_subagent" || parsed.type === "monitor_stop" || parsed.type === "subagent_message" || parsed.type === "subagent_stop") {
         const { handleTaskControlCommand: handleTaskControlCommand2 } = await init_task_control().then(() => exports_task_control);
         await handleTaskControlCommand2(parsed, {
           runtime,
@@ -462959,7 +463434,7 @@ async function recoverApprovalStateForSync(runtime, scope, deps = {}, opts = {})
         return {
           type: "deny",
           approval,
-          reason: STALE_APPROVAL_RECOVERY_DENIAL_REASON
+          reason: STARTED_TOOL_CALL_RECOVERY_DENIAL_REASON
         };
       }
       if (!("tool_return" in saved)) {
@@ -479495,14 +479970,14 @@ async function executeChannelServiceCommand(command) {
   if (!isDetachedChannelsCommand(command)) {
     throw new Error(`Unsupported ChannelGateway command: ${command.type}`);
   }
-  const responses = [];
+  const responses2 = [];
   const detachedTasks = [];
   const socket = {};
   const safeSocketSend2 = (_socket, payload) => {
     if (!payload || typeof payload !== "object" || !("type" in payload)) {
       throw new Error("ChannelGateway service emitted an invalid response");
     }
-    responses.push(payload);
+    responses2.push(payload);
     return true;
   };
   const runDetachedListenerTask2 = (_commandName, task2) => {
@@ -479510,7 +479985,7 @@ async function executeChannelServiceCommand(command) {
   };
   await handleChannelsProtocolCommand(command, socket, runDetachedListenerTask2, safeSocketSend2);
   await Promise.all(detachedTasks);
-  return responses;
+  return responses2;
 }
 async function executeGatewayServiceCommand(request3) {
   if (request3.kind === "protocol") {
@@ -522281,6 +522756,18 @@ var init_reasoning_tab_toggle = __esm(() => {
   DISABLE_ARGS = new Set(["off", "disable", "disabled", "false", "0"]);
 });
 
+// src/cli/helpers/rename-conversation-target.ts
+async function renameConvo(conversationId, summary) {
+  if (conversationId === "default") {
+    throw new Error(DEFAULT_CONVERSATION_RENAME_ERROR);
+  }
+  await getBackend().updateConversation(conversationId, { summary });
+}
+var DEFAULT_CONVERSATION_RENAME_ERROR = "The default conversation can't be renamed. Start a named one with /new <name>, or switch to another conversation first.";
+var init_rename_conversation_target = __esm(() => {
+  init_backend2();
+});
+
 // src/cli/app/command-routing.ts
 function aliasBareExitCommand(input) {
   if (input === "exit" || input === "quit")
@@ -525328,23 +525815,18 @@ Tip: Use /clear instead to clear the current message buffer.`;
           });
           setCommandRunning(true);
           try {
-            const backend3 = getBackend();
             if (shouldAutoGenerate) {
               const conversationTitle = await generateConversationTitle();
               if (!conversationTitle) {
                 cmd.fail("No conversation content available to generate a title");
                 return { submitted: true };
               }
-              await backend3.updateConversation(conversationId, {
-                summary: conversationTitle
-              });
+              await renameConvo(conversationIdRef.current, conversationTitle);
               setConversationSummary(conversationTitle);
               setConversationAutoTitleEligibility(false);
               cmd.finish(`Conversation title set to "${conversationTitle}"`, true);
             } else {
-              await backend3.updateConversation(conversationId, {
-                summary: newValue
-              });
+              await renameConvo(conversationIdRef.current, newValue);
               setConversationSummary(newValue);
               setConversationAutoTitleEligibility(false);
               cmd.finish(`Conversation renamed to "${newValue}"`, true);
@@ -526458,6 +526940,7 @@ var init_use_submit_handler = __esm(async () => {
   init_reflection_completion();
   init_reflection_launcher();
   init_reflection_transcript();
+  init_rename_conversation_target();
   init_system_prompt_warning();
   init_thinking_messages();
   init_command_runtime();
@@ -533937,4 +534420,4 @@ function registerBunOAuthFlows() {
 registerBunOAuthFlows();
 await init_src5().then(() => exports_src2);
 
-//# debugId=7FE5874CEEAF628D64756E2164756E21
+//# debugId=B487A0F42461099B64756E2164756E21