@letta-ai/letta-code 0.27.19 → 0.27.20

package/letta.js

@@ -4790,7 +4790,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.27.19",
+    version: "0.27.20",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     packageManager: "bun@1.3.0",
@@ -170051,7 +170051,13 @@ var init_system_prompt_warning = __esm(() => {
 });
 
 // src/websocket/listener/constants.ts
-var MAX_RETRY_DURATION_MS, INITIAL_RETRY_DELAY_MS2 = 1000, MAX_RETRY_DELAY_MS = 30000, SYSTEM_REMINDER_RE, LLM_API_ERROR_MAX_RETRIES = 3, EMPTY_RESPONSE_MAX_RETRIES = 2, MAX_PRE_STREAM_RECOVERY = 2, MAX_POST_STOP_APPROVAL_RECOVERY = 2, PROVIDER_FALLBACK_MAP, PROVIDER_FALLBACK_NOTICE = "Anthropic API error; falling back to Bedrock...";
+function isListenerPongStale(lastPongAt, now, timeoutMs) {
+  if (lastPongAt === null) {
+    return false;
+  }
+  return now - lastPongAt > timeoutMs;
+}
+var MAX_RETRY_DURATION_MS, INITIAL_RETRY_DELAY_MS2 = 1000, MAX_RETRY_DELAY_MS = 30000, LISTENER_HEARTBEAT_INTERVAL_MS = 30000, LISTENER_PONG_TIMEOUT_MS = 90000, SYSTEM_REMINDER_RE, LLM_API_ERROR_MAX_RETRIES = 3, EMPTY_RESPONSE_MAX_RETRIES = 2, MAX_PRE_STREAM_RECOVERY = 2, MAX_POST_STOP_APPROVAL_RECOVERY = 2, PROVIDER_FALLBACK_MAP, PROVIDER_FALLBACK_NOTICE = "Anthropic API error; falling back to Bedrock...";
 var init_constants3 = __esm(() => {
   MAX_RETRY_DURATION_MS = 5 * 60 * 1000;
   SYSTEM_REMINDER_RE = /<system-reminder>[\s\S]*?<\/system-reminder>/g;
@@ -381853,6 +381859,18 @@ function isModelOutputEvent(event2) {
       return false;
   }
 }
+function llmEndErrorFromError(error54) {
+  const info = normalizeLocalProviderError(error54);
+  return {
+    error: {
+      message: info.message,
+      detail: info.detail,
+      errorType: info.error_type,
+      retryable: info.retryable
+    },
+    stopReason: info.stop_reason
+  };
+}
 function isOverflowError(error54, contextWindow) {
   if (error54 instanceof PiProviderError) {
     return isContextOverflow(error54.assistant, contextWindow);
@@ -382027,6 +382045,17 @@ class PiStreamAdapter {
     }
     const restoreEnv = applyPiEnvOverrides(resolved.envOverrides);
     const llmStartedAt = Date.now();
+    let llmEnded = false;
+    const emitLlmEnd = async (info) => {
+      llmEnded = true;
+      await this.onLlmEnd?.({
+        agentId: input.agentId,
+        conversationId: input.conversationId,
+        model: input.agent.model,
+        durationMs: Date.now() - llmStartedAt,
+        ...info
+      });
+    };
     try {
       await this.onLlmStart?.({
         agentId: input.agentId,
@@ -382055,17 +382084,15 @@ class PiStreamAdapter {
       if (streamError)
         throw streamError;
       finalMessage ??= await result.result();
-      await this.onLlmEnd?.({
-        agentId: input.agentId,
-        conversationId: input.conversationId,
-        model: input.agent.model,
+      const finalMessageError = finalMessage.stopReason === "error" || finalMessage.stopReason === "aborted" ? llmEndErrorFromError(new PiProviderError(finalMessage)).error : undefined;
+      await emitLlmEnd({
         stopReason: finalMessage.stopReason,
         usage: {
           promptTokens: finalMessage.usage.input,
           completionTokens: finalMessage.usage.output,
           totalTokens: finalMessage.usage.totalTokens
         },
-        durationMs: Date.now() - llmStartedAt
+        ...finalMessageError ? { error: finalMessageError } : {}
       });
       if (finalMessage.stopReason === "error" || finalMessage.stopReason === "aborted") {
         throw new PiProviderError(finalMessage);
@@ -382076,6 +382103,16 @@ class PiStreamAdapter {
           yield* this.emitCompactionChunks(compaction, "context_window_limit");
         }
       }
+    } catch (error54) {
+      if (!llmEnded) {
+        const endError = llmEndErrorFromError(error54);
+        await emitLlmEnd({
+          stopReason: endError.stopReason,
+          usage: null,
+          error: endError.error
+        });
+      }
+      throw error54;
     } finally {
       restoreEnv();
     }
@@ -445547,6 +445584,9 @@ function createListenerMessageHandler(params) {
     try {
       const lifecycleMessage = parseServerLifecycleMessage(data);
       if (lifecycleMessage) {
+        if (lifecycleMessage.type === "pong") {
+          runtime.lastPongAt = Date.now();
+        }
         safeEmitWsEvent("recv", "lifecycle", lifecycleMessage);
         return;
       }
@@ -446398,6 +446438,7 @@ function createRuntime() {
     streamTransport: null,
     heartbeatInterval: null,
     reconnectTimeout: null,
+    lastPongAt: null,
     intentionallyClosed: false,
     hasSuccessfulConnection: false,
     everConnected: false,
@@ -446544,9 +446585,15 @@ async function startConnectedListenerRuntime(runtime, transport, opts, processQu
     scheduleQueuePump(targetRuntime, transport, opts, processQueuedTurn);
   });
   if (shouldStartHeartbeat) {
+    runtime.lastPongAt = Date.now();
     runtime.heartbeatInterval = setInterval(() => {
+      if (getListenerTransportKind(transport) === "websocket" && isListenerPongStale(runtime.lastPongAt, Date.now(), LISTENER_PONG_TIMEOUT_MS)) {
+        trackListenerError4("listener_pong_timeout", new Error(`No relay pong within ${LISTENER_PONG_TIMEOUT_MS}ms; terminating half-open socket to force reconnect`), "listener_heartbeat");
+        runtime.socket?.terminate();
+        return;
+      }
       safeTransportSend(transport, { type: "ping" }, "listener_ping_send_failed", "listener_heartbeat");
-    }, 30000);
+    }, LISTENER_HEARTBEAT_INTERVAL_MS);
   }
   if (shouldStartCronScheduler) {
     startScheduler(transport, opts, processQueuedTurn);
@@ -449938,6 +449985,12 @@ function createLegacyTestRuntime() {
         listener.heartbeatInterval = value;
       }
     },
+    lastPongAt: {
+      get: () => listener.lastPongAt,
+      set: (value) => {
+        listener.lastPongAt = value;
+      }
+    },
     intentionallyClosed: {
       get: () => listener.intentionallyClosed,
       set: (value) => {
@@ -454084,7 +454137,8 @@ function installLocalBackendModEventHooks(options3) {
         model: info.model,
         stopReason: info.stopReason,
         usage: info.usage,
-        durationMs: info.durationMs
+        durationMs: info.durationMs,
+        ...info.error ? { error: info.error } : {}
       }, buildContext(info.conversationId));
     }
   });
@@ -524463,6 +524517,8 @@ await __promiseAll([
 var DEFAULT_LISTEN_URL = "ws://127.0.0.1:0";
 var DEFAULT_WS_PATH = "/ws";
 var PENDING_STREAM_TIMEOUT_MS = 5000;
+var APP_SERVER_HEARTBEAT_INTERVAL_MS = 30000;
+var APP_SERVER_PONG_TIMEOUT_MS = 90000;
 function getRequiredAddressInfo(server2) {
   const address = server2.address();
   if (!address || typeof address === "string") {
@@ -524598,6 +524654,7 @@ async function startAppServer(options3 = {}) {
   let pendingStreamSocket = null;
   let pendingStreamTimeout = null;
   let resolvedInfo = null;
+  const lastPongAtBySocket = new WeakMap;
   const clearPendingStream = () => {
     if (pendingStreamTimeout) {
       clearTimeout(pendingStreamTimeout);
@@ -524608,6 +524665,10 @@ async function startAppServer(options3 = {}) {
     return socket;
   };
   const handleWebSocketConnection = (socket, channel) => {
+    lastPongAtBySocket.set(socket, Date.now());
+    socket.on("pong", () => {
+      lastPongAtBySocket.set(socket, Date.now());
+    });
     if (channel === "stream") {
       if (activeSession) {
         attachStreamSocket(activeSession, socket);
@@ -524706,6 +524767,26 @@ async function startAppServer(options3 = {}) {
       handleWebSocketConnection(websocket, channel);
     });
   });
+  const heartbeatIntervalMs = options3.heartbeatIntervalMs ?? APP_SERVER_HEARTBEAT_INTERVAL_MS;
+  const pongTimeoutMs = options3.pongTimeoutMs ?? APP_SERVER_PONG_TIMEOUT_MS;
+  const heartbeatInterval = setInterval(() => {
+    const now = Date.now();
+    for (const client of wss.clients) {
+      const lastPongAt = lastPongAtBySocket.get(client) ?? now;
+      if (now - lastPongAt > pongTimeoutMs) {
+        options3.onLog?.(`App-server terminating unresponsive socket (no pong in ${pongTimeoutMs}ms)`);
+        client.terminate();
+        continue;
+      }
+      if (client.readyState === WebSocket7.OPEN) {
+        client.ping();
+      }
+    }
+  }, heartbeatIntervalMs);
+  heartbeatInterval.unref?.();
+  wss.on("close", () => {
+    clearInterval(heartbeatInterval);
+  });
   await new Promise((resolve30, reject) => {
     const onError = (error54) => {
       server2.off("listening", onListening);
@@ -524730,6 +524811,7 @@ async function startAppServer(options3 = {}) {
   return {
     ...resolvedInfo,
     close: async () => {
+      clearInterval(heartbeatInterval);
       const streamSocket = clearPendingStream();
       terminateSocket(streamSocket);
       if (activeSession) {
@@ -533971,4 +534053,4 @@ Error during initialization: ${message}`);
 }
 main2();
 
-//# debugId=3D66948C285952FE64756E2164756E21
+//# debugId=EC4DC695909CD41C64756E2164756E21

package/package.json

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

package/skills/creating-mods/references/events.md

@@ -284,12 +284,18 @@ Handlers run in registration order. Later handlers see the current input after e
     promptTokens: number;
     completionTokens: number;
     totalTokens: number;
-  };
+  } | null;
   durationMs: number;
+  error?: {
+    message: string;
+    detail: string;
+    errorType: "llm_error" | "local_backend_error";
+    retryable: boolean;
+  };
 }
 ```
 
-`llm_end` fires once a provider request produces a final message, carrying the stop reason, token usage, and wall-clock duration. A request that fails before producing a final message (e.g. a transport error that triggers a retry) emits no `llm_end`. Both events are notification-only; return values are ignored. A throwing handler is isolated and never breaks the provider request.
+`llm_end` fires when a provider request ends, success or failure. Successful requests include token usage. Requests that fail before usage is available set `usage: null` and include `error`. Retry/failover effects are not supported yet; both events are notification-only and return values are ignored. A throwing handler is isolated and never breaks the provider request.
 
 Handlers also receive: