@letta-ai/letta-code 0.24.3 → 0.24.4

package/letta.js

@@ -3269,7 +3269,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.24.3",
+    version: "0.24.4",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     bin: {
@@ -87563,6 +87563,60 @@ class StreamProcessor {
 }
 
 // src/cli/helpers/stream.ts
+function summarizeStreamForDebug(stream2) {
+  if (!stream2 || typeof stream2 !== "object") {
+    return `type=${typeof stream2}`;
+  }
+  const record = stream2;
+  const ctor = stream2.constructor?.name;
+  const controller = record.controller && typeof record.controller === "object" ? record.controller : null;
+  const keys = Object.keys(record).slice(0, 8);
+  return [
+    `ctor=${ctor ?? "unknown"}`,
+    `asyncIterator=${typeof record[Symbol.asyncIterator]}`,
+    `controller=${typeof record.controller}`,
+    `controllerAbort=${typeof controller?.abort}`,
+    `controllerSignal=${typeof controller?.signal}`,
+    keys.length > 0 ? `keys=${keys.join(",")}` : "keys=(none)"
+  ].join(" ");
+}
+function summarizeChunkForDebug(chunk) {
+  if (!chunk) {
+    return "none";
+  }
+  const record = chunk;
+  const parts = [`message_type=${chunk.message_type ?? "unknown"}`];
+  for (const key of ["run_id", "seq_id", "id", "otid", "tool_call_id"]) {
+    const value = record[key];
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      parts.push(`${key}=${value}`);
+    }
+  }
+  if (chunk.message_type === "stop_reason") {
+    parts.push(`stop_reason=${String(record.stop_reason ?? "unknown")}`);
+  }
+  const toolCalls = record.tool_calls;
+  if (Array.isArray(toolCalls)) {
+    parts.push(`tool_calls=${toolCalls.length}`);
+  }
+  return parts.join(" ");
+}
+function abortStreamController(stream2, reason) {
+  const controller = stream2.controller;
+  if (!controller || typeof controller !== "object") {
+    debugWarn("drainStream", "stream.controller is unavailable during %s - cannot abort HTTP request (%s)", reason, summarizeStreamForDebug(stream2));
+    return;
+  }
+  const controllerRecord = controller;
+  if (controllerRecord.signal?.aborted) {
+    return;
+  }
+  if (typeof controllerRecord.abort !== "function") {
+    debugWarn("drainStream", "stream.controller.abort is unavailable during %s - cannot abort HTTP request (%s)", reason, summarizeStreamForDebug(stream2));
+    return;
+  }
+  controllerRecord.abort();
+}
 function hasPaginatedItems(response) {
   return !Array.isArray(response) && typeof response.getPaginatedItems === "function";
 }
@@ -87640,28 +87694,26 @@ async function drainStream(stream2, buffers, refresh, abortSignal, onFirstMessag
   let stopReason = null;
   let hasCalledFirstMessage = false;
   let fallbackError = null;
+  let lastChunkDebugSummary = "none";
   let abortedViaListener = false;
   const startAbortGen = buffers.abortGeneration || 0;
   const abortHandler = () => {
     abortedViaListener = true;
-    if (!stream2.controller) {
-      debugWarn("drainStream", "stream.controller is undefined - cannot abort HTTP request");
-      return;
-    }
-    if (!stream2.controller.signal.aborted) {
-      stream2.controller.abort();
-    }
+    abortStreamController(stream2, "abort_signal");
   };
   if (abortSignal && !abortSignal.aborted) {
     abortSignal.addEventListener("abort", abortHandler, { once: true });
   } else if (abortSignal?.aborted) {
     abortedViaListener = true;
-    if (stream2.controller && !stream2.controller.signal.aborted) {
-      stream2.controller.abort();
-    }
+    abortStreamController(stream2, "pre_aborted_signal");
   }
   try {
+    const asyncIterator = stream2[Symbol.asyncIterator];
+    if (typeof asyncIterator !== "function") {
+      throw new TypeError(`Stream is not async iterable (${summarizeStreamForDebug(stream2)})`);
+    }
     for await (const chunk of stream2) {
+      lastChunkDebugSummary = summarizeChunkForDebug(chunk);
       recordTuiJsonPayload(`stream_chunk:${chunk.message_type ?? "unknown"}`, chunk);
       if ((buffers.abortGeneration || 0) !== startAbortGen) {
         stopReason = "cancelled";
@@ -87730,7 +87782,10 @@ async function drainStream(stream2, buffers, refresh, abortSignal, onFirstMessag
     const errorMessage = e instanceof Error ? e.message : String(e);
     const sdkDiagnostic = consumeLastSDKDiagnostic();
     const errorMessageWithDiagnostic = sdkDiagnostic ? `${errorMessage} [${sdkDiagnostic}]` : errorMessage;
-    debugWarn("drainStream", "Stream error caught:", errorMessage);
+    debugWarn("drainStream", "Stream error caught: %s last_chunk=%s stream=%s", errorMessageWithDiagnostic, lastChunkDebugSummary, summarizeStreamForDebug(stream2));
+    if (e instanceof Error && e.stack) {
+      debugWarn("drainStream", "Stream error stack: %s", e.stack);
+    }
     if (!streamProcessor.lastRunId && e instanceof APIError2 && e.error) {
       const errorObj = e.error;
       if ("run_id" in errorObj && typeof errorObj.run_id === "string") {
@@ -95763,7 +95818,7 @@ function isSyncCommand(value) {
     return false;
   }
   const candidate = value;
-  return candidate.type === "sync" && isRuntimeScope(candidate.runtime);
+  return candidate.type === "sync" && isRuntimeScope(candidate.runtime) && (candidate.recover_approvals === undefined || typeof candidate.recover_approvals === "boolean");
 }
 function isTerminalSpawnCommand(value) {
   if (!value || typeof value !== "object")
@@ -96444,12 +96499,14 @@ function runDetachedListenerTask(commandName, task2) {
 async function replaySyncStateForRuntime(listenerRuntime, socket, scope, opts) {
   const syncScopedRuntime = getOrCreateScopedRuntime(listenerRuntime, scope.agent_id, scope.conversation_id);
   const recoverFn = opts?.recoverApprovalStateForSync ?? recoverApprovalStateForSync;
-  try {
-    await recoverFn(syncScopedRuntime, scope);
-  } catch (error) {
-    trackListenerError("listener_sync_recovery_failed", error, "listener_sync_recovery");
-    if (isDebugEnabled()) {
-      console.warn("[Listen] Sync approval recovery failed:", error);
+  if (opts?.recoverApprovals ?? true) {
+    try {
+      await recoverFn(syncScopedRuntime, scope);
+    } catch (error) {
+      trackListenerError("listener_sync_recovery_failed", error, "listener_sync_recovery");
+      if (isDebugEnabled()) {
+        console.warn("[Listen] Sync approval recovery failed:", error);
+      }
     }
   }
   emitStateSync(socket, listenerRuntime, scope);
@@ -98796,7 +98853,9 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
           console.log(`[Listen V2] Dropping sync: runtime mismatch or closed`);
           return;
         }
-        await replaySyncStateForRuntime(runtime, socket, parsed.runtime);
+        await replaySyncStateForRuntime(runtime, socket, parsed.runtime, {
+          recoverApprovals: parsed.recover_approvals !== false
+        });
         return;
       }
       if (parsed.type === "input") {
@@ -168653,4 +168712,4 @@ Error during initialization: ${message}`);
 }
 main();
 
-//# debugId=22CE2EBE31776A7764756E2164756E21
+//# debugId=A2D8C37B0089C68564756E2164756E21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@letta-ai/letta-code",
-  "version": "0.24.3",
+  "version": "0.24.4",
   "description": "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
   "type": "module",
   "bin": {