@letta-ai/letta-code 0.31.12 → 0.31.13

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@letta-ai/letta-code",
-  "version": "0.31.12",
+  "version": "0.31.13",
   "description": "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
   "type": "module",
-  "packageManager": "bun@1.3.10",
+  "packageManager": "bun@1.3.14",
   "bin": {
     "letta": "letta.js"
   },
@@ -122,6 +122,7 @@
   },
   "license": "Apache-2.0",
   "engines": {
+    "bun": ">=1.3.2",
     "node": ">=22.19.0"
   },
   "publishConfig": {

package/scripts/codex-watch/release-analysis.test.ts

@@ -1,5 +1,6 @@
 import {
   findLatestStableReleaseAfter,
+  listStableReleases,
   type Release,
   releaseNotesForRange,
 } from "./release-analysis.ts";
@@ -49,3 +50,89 @@ describe("Codex stable release range", () => {
     );
   });
 });
+
+describe("Codex GitHub release fetch", () => {
+  test("retries a server error before succeeding", async () => {
+    const sleeps: number[] = [];
+    let requests = 0;
+
+    const releases = await listStableReleases({
+      fetchImpl: (async () => {
+        requests++;
+        if (requests === 1) {
+          return new Response("Gateway Timeout", { status: 504 });
+        }
+        return new Response(JSON.stringify(STABLES), { status: 200 });
+      }) as typeof fetch,
+      sleep: async (delayMs) => {
+        sleeps.push(delayMs);
+      },
+    });
+
+    expect(requests).toBe(2);
+    expect(sleeps).toEqual([1000]);
+    expect(releases).toEqual(STABLES);
+  });
+
+  test("retries a network error before succeeding", async () => {
+    const sleeps: number[] = [];
+    let requests = 0;
+
+    const releases = await listStableReleases({
+      fetchImpl: (async () => {
+        requests++;
+        if (requests === 1) throw new TypeError("fetch failed: ECONNRESET");
+        return new Response(JSON.stringify(STABLES), { status: 200 });
+      }) as typeof fetch,
+      sleep: async (delayMs) => {
+        sleeps.push(delayMs);
+      },
+    });
+
+    expect(requests).toBe(2);
+    expect(sleeps).toEqual([1000]);
+    expect(releases).toEqual(STABLES);
+  });
+
+  test("stops after the bounded retry budget", async () => {
+    const sleeps: number[] = [];
+    let requests = 0;
+
+    const result = listStableReleases({
+      fetchImpl: (async () => {
+        requests++;
+        return new Response("Gateway Timeout", { status: 504 });
+      }) as typeof fetch,
+      sleep: async (delayMs) => {
+        sleeps.push(delayMs);
+      },
+    });
+
+    await expect(result).rejects.toThrow(
+      "GitHub releases API failed (504): Gateway Timeout",
+    );
+    expect(requests).toBe(3);
+    expect(sleeps).toEqual([1000, 2000]);
+  });
+
+  test("fails immediately on a client error", async () => {
+    const sleeps: number[] = [];
+    let requests = 0;
+
+    const result = listStableReleases({
+      fetchImpl: (async () => {
+        requests++;
+        return new Response("Not Found", { status: 404 });
+      }) as typeof fetch,
+      sleep: async (delayMs) => {
+        sleeps.push(delayMs);
+      },
+    });
+
+    await expect(result).rejects.toThrow(
+      "GitHub releases API failed (404): Not Found",
+    );
+    expect(requests).toBe(1);
+    expect(sleeps).toEqual([]);
+  });
+});

package/scripts/codex-watch/release-analysis.ts

@@ -21,6 +21,8 @@ export const WATCHED_PATHS = [
 ];
 
 const MAX_COMMITS_PER_PATH = 8;
+const GITHUB_RELEASES_FETCH_ATTEMPTS = 3;
+const GITHUB_RELEASES_RETRY_DELAY_MS = 1_000;
 
 export interface Release {
   tag_name: string;
@@ -167,7 +169,12 @@ export async function analyzeCodexRelease(
   }
 }
 
-export async function listStableReleases(): Promise<Release[]> {
+export async function listStableReleases(
+  options: {
+    fetchImpl?: typeof fetch;
+    sleep?: (delayMs: number) => Promise<void>;
+  } = {},
+): Promise<Release[]> {
   const releases: Release[] = [];
   const headers: Record<string, string> = {
     Accept: "application/vnd.github+json",
@@ -175,15 +182,15 @@ export async function listStableReleases(): Promise<Release[]> {
   };
   const token = process.env.GH_TOKEN || process.env.GITHUB_TOKEN;
   if (token) headers.Authorization = `Bearer ${token}`;
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const sleep =
+    options.sleep ??
+    ((delayMs: number) =>
+      new Promise<void>((resolve) => setTimeout(resolve, delayMs)));
 
   for (let page = 1; page <= 10; page++) {
     const url = `https://api.github.com/repos/${CODEX_REPO}/releases?per_page=100&page=${page}`;
-    const res = await fetch(url, { headers });
-    if (!res.ok) {
-      throw new Error(
-        `GitHub releases API failed (${res.status}): ${await res.text()}`,
-      );
-    }
+    const res = await fetchGitHubReleasesPage(url, headers, fetchImpl, sleep);
     const batch = (await res.json()) as Release[];
     releases.push(...batch);
     if (batch.length < 100) break;
@@ -193,6 +200,49 @@ export async function listStableReleases(): Promise<Release[]> {
     .sort((a, b) => (a.published_at ?? "").localeCompare(b.published_at ?? ""));
 }
 
+async function fetchGitHubReleasesPage(
+  url: string,
+  headers: Record<string, string>,
+  fetchImpl: typeof fetch,
+  sleep: (delayMs: number) => Promise<void>,
+): Promise<Response> {
+  for (let attempt = 1; ; attempt++) {
+    let response: Response;
+    try {
+      response = await fetchImpl(url, { headers });
+    } catch (error) {
+      if (attempt === GITHUB_RELEASES_FETCH_ATTEMPTS) {
+        throw new Error(
+          `GitHub releases API request failed after ${attempt} attempts: ${String(error)}`,
+          { cause: error },
+        );
+      }
+      await retryGitHubReleasesFetch(attempt, String(error), sleep);
+      continue;
+    }
+
+    if (response.ok) return response;
+
+    const message = `GitHub releases API failed (${response.status}): ${await response.text()}`;
+    if (response.status < 500 || attempt === GITHUB_RELEASES_FETCH_ATTEMPTS) {
+      throw new Error(message);
+    }
+    await retryGitHubReleasesFetch(attempt, message, sleep);
+  }
+}
+
+async function retryGitHubReleasesFetch(
+  attempt: number,
+  error: string,
+  sleep: (delayMs: number) => Promise<void>,
+): Promise<void> {
+  const delayMs = GITHUB_RELEASES_RETRY_DELAY_MS * 2 ** (attempt - 1);
+  console.warn(
+    `${error}; retrying GitHub releases request in ${delayMs}ms (${attempt}/${GITHUB_RELEASES_FETCH_ATTEMPTS})`,
+  );
+  await sleep(delayMs);
+}
+
 function isStableRelease(release: Release): boolean {
   if (release.draft || release.prerelease) return false;
   return /^(rust-v|v)?\d+\.\d+\.\d+$/.test(release.tag_name);

package/scripts/postinstall-patches.js

@@ -16,6 +16,20 @@ import { fileURLToPath } from "node:url";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkgRoot = dirname(__dirname);
 const require = createRequire(import.meta.url);
+const packageJson = JSON.parse(
+  readFileSync(join(pkgRoot, "package.json"), "utf-8"),
+);
+const minimumBunVersion = packageJson.engines.bun.replace(/^>=/, "");
+
+function isBunVersionSupported(version) {
+  const current = version.split(".").map(Number);
+  const minimum = minimumBunVersion.split(".").map(Number);
+  for (let index = 0; index < minimum.length; index++) {
+    if ((current[index] ?? 0) > (minimum[index] ?? 0)) return true;
+    if ((current[index] ?? 0) < (minimum[index] ?? 0)) return false;
+  }
+  return true;
+}
 
 async function copyToResolved(srcRel, targetSpecifier) {
   const src = join(pkgRoot, srcRel);
@@ -100,7 +114,10 @@ await copyToResolved(
   "ink/build/hooks/use-input.js",
 );
 await copyToResolved("vendor/ink/build/devtools.js", "ink/build/devtools.js");
-await copyToResolved("vendor/ink/build/log-update.js", "ink/build/log-update.js");
+await copyToResolved(
+  "vendor/ink/build/log-update.js",
+  "ink/build/log-update.js",
+);
 await copyToResolved("vendor/ink/build/wrap-text.js", "ink/build/wrap-text.js");
 
 // ink-text-input (optional vendor with externalCursorOffset support)
@@ -111,24 +128,30 @@ await copyToResolved(
 
 console.log("[patch] Ink runtime patched");
 
-// On Unix with Bun available, use polyglot shebang to prefer Bun runtime.
+// On Unix with a supported Bun available, use a polyglot shebang to prefer it.
 // This enables Bun.secrets for secure keychain storage instead of fallback.
-// Windows always uses #!/usr/bin/env node (polyglot shebang breaks npm wrappers).
+// Windows and installs with an older Bun keep the Node shebang.
 if (process.platform !== "win32") {
   try {
-    execSync("bun --version", { stdio: "ignore" });
-    const lettaPath = join(pkgRoot, "letta.js");
-    if (existsSync(lettaPath)) {
-      let content = readFileSync(lettaPath, "utf-8");
-      if (content.startsWith("#!/usr/bin/env node")) {
-        content = content.replace(
-          "#!/usr/bin/env node",
-          `#!/bin/sh
+    const bunVersion = execSync("bun --version", { encoding: "utf-8" }).trim();
+    if (isBunVersionSupported(bunVersion)) {
+      const lettaPath = join(pkgRoot, "letta.js");
+      if (existsSync(lettaPath)) {
+        let content = readFileSync(lettaPath, "utf-8");
+        if (content.startsWith("#!/usr/bin/env node")) {
+          content = content.replace(
+            "#!/usr/bin/env node",
+            `#!/bin/sh
 ":" //#; exec /usr/bin/env sh -c 'command -v bun >/dev/null && exec bun "$0" "$@" || exec node "$0" "$@"' "$0" "$@"`,
-        );
-        writeFileSync(lettaPath, content);
-        console.log("[patch] Configured letta to prefer Bun runtime");
+          );
+          writeFileSync(lettaPath, content);
+          console.log("[patch] Configured letta to prefer Bun runtime");
+        }
       }
+    } else {
+      console.log(
+        `[patch] Bun ${bunVersion} is below ${minimumBunVersion}; keeping Node runtime`,
+      );
     }
   } catch {
     // Bun not available, keep node shebang

package/scripts/source-file-size-baseline.json

@@ -10,7 +10,7 @@
   "src/cli/app/use-approval-flow.ts": 1163,
   "src/cli/app/use-configuration-handlers.ts": 1421,
   "src/cli/app/use-conversation-loop.ts": 2912,
-  "src/cli/app/use-submit-handler.ts": 4075,
+  "src/cli/app/use-submit-handler.ts": 4074,
   "src/cli/components/AgentSelector.tsx": 1104,
   "src/cli/components/InputRich.tsx": 2225,
   "src/cli/components/ModelSelector.tsx": 1259,
@@ -44,6 +44,6 @@
   "src/websocket/listener/file-commands.ts": 1053,
   "src/websocket/listener/lifecycle.ts": 1048,
   "src/websocket/listener/protocol-inbound.ts": 2207,
-  "src/websocket/listener/protocol-outbound.ts": 1047,
+  "src/websocket/listener/protocol-outbound.ts": 1042,
   "src/websocket/listener/turn.ts": 1058
 }

package/skills/dispatching-coding-agents/SKILL.md

@@ -66,7 +66,7 @@ Different agents have different strengths. Track what works in your memory over
 - Use `--max-budget-usd N` (Claude Code) to cap spend on exploratory tasks
 
 ### Known quirks
-- **Claude Code can hang on large repos** with unrestricted tools — consider `--allowedTools "Read Grep Glob"` (no Bash) and shorter timeouts for research tasks
+- **Claude Code can hang on large repos** with unrestricted tools — consider `--tools "Read Grep Glob"` (no Bash) and shorter timeouts for research tasks
 - **Codex compactions can destroy long trajectories** — for very long tasks, prefer multiple shorter sessions over one marathon
 - **Opus tends to over-generate** — produces more code than necessary. Good for exploration, verify before applying.
 
@@ -135,7 +135,7 @@ cd /path/to/repo && claude -p "Read /tmp/my-plan.md and critique it. What am I m
 
 ## Handling Failures
 
-- **Timeout**: If an agent times out (especially Claude Code on large repos), try: (1) a shorter, more focused prompt, (2) restricting tools with `--allowedTools`, (3) switching to Codex which handles large repos better
+- **Timeout**: If an agent times out (especially Claude Code on large repos), try: (1) a shorter, more focused prompt, (2) restricting tools with `--tools`, (3) switching to Codex which handles large repos better
 - **Garbage output**: If results are incoherent, the prompt was probably too vague. Rewrite with more specific file paths and clearer instructions.
 - **Session errors**: Claude Code can hit "stale approval from interrupted session" — `--dangerously-skip-permissions` prevents this. If Codex errors, start a fresh `exec` session.
 - **Compaction mid-task**: If a Codex session runs long enough to compact, it may lose earlier context. Break long tasks into smaller sequential sessions.
@@ -153,12 +153,13 @@ claude -p "YOUR PROMPT" --model MODEL --dangerously-skip-permissions
 | `-p` / `--print` | Non-interactive mode, prints response and exits |
 | `--dangerously-skip-permissions` | Skip approval prompts (prevents stale approval errors on timeout) |
 | `--model MODEL` | Alias or model name accepted by the installed CLI; omit to use the configured default |
-| `--effort LEVEL` | `low`, `medium`, `high` — controls reasoning depth |
+| `--effort LEVEL` | `low`, `medium`, `high`, `xhigh`, `max` — controls reasoning depth |
 | `--append-system-prompt "..."` | Inject additional system instructions |
-| `--allowedTools "Bash Edit Read"` | Restrict available tools |
+| `--allowedTools "Bash Edit Read"` | Tools that execute without prompting for permission |
+| `--tools "Read Grep Glob"` | Restrict which built-in tools are available |
 | `--max-budget-usd N` | Cap spend for the invocation |
 | `--add-dir DIR` | Allow access to an additional directory; does not change the working directory |
-| `--output-format json` | Structured output with `session_id`, `cost_usd`, `duration_ms` |
+| `--output-format json` | Structured output with `session_id`, `total_cost_usd`, `duration_ms` |
 
 Set Claude Code's working directory with `cd /path/to/repo && claude ...` in the Bash command, not with a Claude flag.
 
@@ -174,7 +175,6 @@ codex exec "YOUR PROMPT" --sandbox workspace-write
 | `-m MODEL` | Model accepted by the installed CLI; omit to use the configured default |
 | `--sandbox MODE` | Select a read-only or writable sandbox |
 | `-C DIR` | Set working directory |
-| `--search` | Enable web search tool |
 | `review` | Native code review — `codex review --uncommitted` or `codex exec review "prompt"` |
 
 ## Session Management

package/skills/messaging-agents/SKILL.md

@@ -78,12 +78,21 @@ letta -p --from-agent $LETTA_AGENT_ID \
   "message text"
 ```
 
+Use `--computer cloud` to route through the target agent's cloud sandbox:
+
+```bash
+letta -p --from-agent $LETTA_AGENT_ID \
+  --agent <id> \
+  --computer cloud \
+  "message text"
+```
+
 **Arguments:**
 | Arg | Required | Description |
 |-----|----------|-------------|
 | `--agent <id>` | Yes | Target agent ID to message |
 | `--from-agent <id>` | Yes | Sender agent ID (injects agent-to-agent system reminder) |
-| `--computer <selector>` | No | Route through an online computer by connection name, device ID, or connection ID |
+| `--computer <selector>` | No | Route through `cloud` (target agent's cloud sandbox) or an online computer by connection name, device ID, or connection ID |
 | `"message text"` | Yes | Message body (positional after flags) |
 
 **Example:**
@@ -93,13 +102,17 @@ letta -p --from-agent $LETTA_AGENT_ID \
   "What do you know about the authentication system?"
 ```
 
-**Response:**
+**Response (JSON format with `--output json`):**
 ```json
 {
-  "conversation_id": "conversation-xyz789",
-  "response": "The authentication system uses JWT tokens...",
+  "type": "result",
+  "subtype": "success",
+  "is_error": false,
+  "result": "The authentication system uses JWT tokens...",
   "agent_id": "agent-abc123",
-  "agent_name": "BackendExpert"
+  "conversation_id": "conversation-xyz789",
+  "environment": { "source": "same-environment" },
+  "usage": { "prompt_tokens": 120, "completion_tokens": 80, "total_tokens": 200, "step_count": 1 }
 }
 ```
 

package/dist/types/tools/impl/foreground-sleep.d.ts

@@ -1,13 +0,0 @@
-export declare const FOREGROUND_SLEEP_BLOCKED_MESSAGE = "Foreground `sleep` is blocked \u2014 it stalls the session while nothing happens. Run the wait in the background and keep working: use Bash with `run_in_background` and a command that exits when the condition is true, e.g. `until grep -q \"Ready in\" dev.log; do sleep 0.5; done`. You get a single completion notification when it exits. For one notification per occurrence (\"tell me every time an ERROR line appears\"), use the Monitor tool instead. `sleep` inside `run_in_background` commands and Monitor scripts is fine.";
-/**
- * True when the command would execute `sleep` in the foreground: `sleep` in
- * command position in any top-level segment, including loop bodies
- * (`while true; do sleep 1; done`).
- *
- * This is a workflow nudge, not a security boundary — commands the splitter
- * cannot analyze (unsafe redirects, substitutions in double quotes) are let
- * through rather than blocked, and `sleep` in argument position
- * (`grep sleep file.txt`) never matches.
- */
-export declare function commandRunsForegroundSleep(command: string): boolean;
-//# sourceMappingURL=foreground-sleep.d.ts.map

package/dist/types/tools/impl/foreground-sleep.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"foreground-sleep.d.ts","sourceRoot":"","sources":["../../../../src/tools/impl/foreground-sleep.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,gCAAgC,ghBACyd,CAAC;AA4BvgB;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAwBnE"}