@letta-ai/letta-code 0.27.9 → 0.27.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@letta-ai/letta-code",
-  "version": "0.27.9",
+  "version": "0.27.10",
   "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/SKILL.md

@@ -11,7 +11,7 @@ Use this skill to create or update trusted global Letta Code mods in:
 ~/.letta/mods/
 ```
 
-Mods are trusted local code for Letta Code. They add small composable capabilities through mod APIs, not by importing app internals. Prefer scoped handles (`ctx.conversation`, `ctx.cwd`, `ctx.agent`, `letta.getContext()`) and guard optional UI with `letta.capabilities`.
+Mods are trusted local code for Letta Code. They add small composable capabilities through mod APIs, not by importing app internals. Dynamic agent/conversation/workspace/model state is passed as `ctx` to tool, command, event, permission, status, and statusline callbacks; do not read mutable global context for model-callable behavior. Prefer scoped handles (`ctx.conversation`, `ctx.cwd`, `ctx.agent`) and guard optional UI with `letta.capabilities`.
 
 Capabilities vary by surface. TUI/headless may load tools, commands, events, UI, and providers; the desktop listener loads provider-only mods for local provider discovery. Always guard optional capabilities.
 
@@ -132,7 +132,7 @@ Before finishing, verify:
 - Timers, intervals, event registrations, and panels are cleaned up in a disposer.
 - Busy commands return `{ type: "handled" }` quickly and avoid main-conversation sends.
 - Conversation work uses `ctx.conversation` or forked handles, not app internals.
-- Local shell/file work is scoped to `ctx.cwd` / `ctx.workingDirectory` unless intentionally global.
+- Local shell/file work is scoped to `ctx.cwd` unless intentionally global.
 - Errors shown to the user are short and actionable.
 
 ## References

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

@@ -30,7 +30,7 @@ export default function activate(letta) {
 
   return letta.events.on("conversation_open", (event, ctx) => {
     console.log(`conversation ${event.reason}: ${event.agentName ?? event.agentId}`);
-    console.log(`cwd: ${ctx.context.workspace.currentDir}`);
+    console.log(`cwd: ${ctx.cwd}`);
   });
 }
 ```
@@ -180,13 +180,15 @@ Handlers also receive:
     getHistory(options?): Promise<Message[]>;
     sendMessageStream(messages, options?): Promise<AsyncIterable<chunk>>;
   };
-  context: letta.getContext();
-  getContext: () => letta.getContext();
+  agent: ModContext["agent"];
+  cwd: string;
+  model: ModContext["model"];
+  permissionMode: string | null;
   signal: AbortSignal;
 }
 ```
 
-`ctx.conversation` is bound when the event is dispatched. Use it for scoped conversation calls made while handling that event. If an event needs background model work, prefer `ctx.conversation.fork()` and send to the fork. Do not send to the active conversation from `turn_start`; that event is already in the path of sending a turn.
+`ctx` and `ctx.conversation` are bound when the event is dispatched. Use direct fields such as `ctx.agent`, `ctx.cwd`, `ctx.model`, and `ctx.permissionMode` for scoped state. If an event needs background model work, prefer `ctx.conversation.fork()` and send to the fork. Do not send to the active conversation from `turn_start`; that event is already in the path of sending a turn.
 
 Respect `ctx.signal` for long-running async work. It is aborted on `/reload` and app shutdown.
 

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

@@ -19,7 +19,8 @@ For tools that are part of a larger mod with commands, UI, local state, or event
 - `requiresApproval: false` only for read-only, low-risk local introspection.
 - `approvalPolicy: "alwaysAsk"` only for tools that must pause for human approval even in unrestricted/yolo mode.
 - `parallelSafe: true` only for read-only tools with no shared mutation or long-lived exclusive resource.
-- Use `ctx.cwd` / `ctx.workingDirectory` as the workspace.
+- Use `ctx.cwd` as the invocation workspace.
+- Use the dynamic context passed to `run(ctx)` (`ctx.agent`, `ctx.model`, `ctx.toolset`, `ctx.permissionMode`) instead of reading global app context.
 - Use `await ctx.conversation.getHistory()` when a tool needs recent conversation context. It returns the most recent messages in chronological order by default.
 - Respect `ctx.signal` for long-running work when practical.
 - Tools should return information for the model to use; they should not start hidden model runs.

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

@@ -18,6 +18,8 @@ letta.capabilities.ui.customStatuslineRenderer
 
 ## Panels
 
+Panels are app/TUI-global today. Desktop/listener disables panel UI; future scoped panels need an explicit design instead of sharing this global registry across panes/conversations.
+
 ```ts
 if (letta.capabilities.ui.panels) {
   const panel = letta.ui.openPanel({

package/skills/customizing-statusline/references/api.md

@@ -28,8 +28,6 @@ export default function activate(letta) {
 ## API
 
 ```ts
-letta.getContext(): StatuslineRenderContext
-
 letta.capabilities.ui.statusValues: boolean
 letta.capabilities.ui.customStatuslineRenderer: boolean
 
@@ -72,9 +70,8 @@ export default function activate(letta) {
 
   const update = async () => {
     try {
-      const context = letta.getContext();
       const { stdout } = await execFileAsync("git", ["branch", "--show-current"], {
-        cwd: context.workspace.currentDir,
+        cwd: process.cwd(),
       });
       if (letta.capabilities.ui.statusValues) {
         letta.ui.setStatus("branch", stdout.trim());

package/skills/customizing-statusline/references/examples.md

@@ -28,9 +28,8 @@ export default function activate(letta) {
 
   const update = async () => {
     try {
-      const context = letta.getContext();
       const { stdout } = await execFileAsync("git", ["branch", "--show-current"], {
-        cwd: context.workspace.currentDir,
+        cwd: process.cwd(),
       });
       letta.ui.setStatus("branch", stdout.trim());
     } catch {
@@ -85,11 +84,10 @@ export default function activate(letta) {
 
   const update = async () => {
     try {
-      const context = letta.getContext();
       const { stdout } = await execFileAsync(
         "gh",
         ["pr", "view", "--json", "number,title", "--jq", "\"#\\(.number) \\(.title)\""],
-        { cwd: context.workspace.currentDir },
+        { cwd: process.cwd() },
       );
       const pr = stdout.trim();
       pr ? letta.ui.setStatus("pr", pr) : letta.ui.clearStatus("pr");

package/skills/customizing-statusline/references/migration.md

@@ -60,9 +60,8 @@ import { promisify } from "node:util";
 const execFileAsync = promisify(execFile);
 
 const update = async () => {
-  const context = letta.getContext();
   const { stdout } = await execFileAsync("git", ["branch", "--show-current"], {
-    cwd: context.workspace.currentDir,
+    cwd: process.cwd(),
   });
   letta.ui.setStatus("branch", stdout.trim());
 };

package/skills/image-generation/SKILL.md

@@ -14,7 +14,9 @@ save either form to a local image file before replying.
 Generate the image, save it locally, then show it inline:
 
 ```bash
-curl -sS -X POST "https://api.letta.com/v1/images/generations" \
+base_url="${LETTA_BASE_URL%/}"
+
+curl -sS -X POST "$base_url/v1/images/generations" \
   -H "Authorization: Bearer $LETTA_API_KEY" \
   -H "Content-Type: application/json" \
   -d '{"provider":"gemini","prompt":"a friendly robot mascot waving, flat vector logo, mint green background","n":1}' \
@@ -39,11 +41,13 @@ print("saved robot-mascot.png; credits:", response["billing"]["credits_charged"]
 PY
 ```
 
-In Bash tools launched by Letta Code, the current Letta credential is available
-as `$LETTA_API_KEY`. This works for both Letta auth modes: it may be a normal
-Letta API key, or the OAuth access token from a Letta Cloud OAuth login. Reference
-it directly. If it is missing, the user needs to authenticate with Letta Cloud (or
-provide a Letta API key); do **not** ask for a Flux/OpenAI/Gemini provider key. This
+In Bash tools launched by Letta Code, use the runtime-provided
+`LETTA_BASE_URL` and `LETTA_API_KEY` together for Letta API calls. Build URLs
+relative to `${LETTA_BASE_URL%/}` and send `Authorization: Bearer $LETTA_API_KEY`.
+Do not hardcode `https://api.letta.com`: Desktop and remote runtimes may provide
+a proxy base URL, and the credential may only be valid through that URL. If
+either variable is missing, the user needs to authenticate with Letta Cloud (or
+provide a Letta API key); do **not** ask for an OpenAI/Gemini provider key. This
 endpoint also does not use `/connect` BYOK providers — the only `provider` values
 supported here are `flux`, `gemini`, and `openai`.
 

package/vendor/ink-text-input/build/index.js

@@ -13,7 +13,7 @@ const CURSOR_SENTINEL = '\u{10FFFD}';
  * Determines if the input should be treated as a control sequence (not inserted as text).
  * This centralizes escape sequence filtering to prevent garbage characters from being inserted.
  */
-function isControlSequence(input, key) {
+export function isControlSequence(input, key) {
     // Pasted content is handled separately
     if (key?.isPasted) return true;
 
@@ -31,8 +31,10 @@ function isControlSequence(input, key) {
     // The handled ones are: ctrl+a, ctrl+e, ctrl+k, ctrl+u, ctrl+y (see useInput below)
     if (key.ctrl && input && /^[a-z]$/i.test(input) && !['a', 'e', 'k', 'u', 'y'].includes(input.toLowerCase())) return true;
 
-    // Option+Arrow escape sequences: Ink parses \x1bb as meta=true, input='b'
-    if (key.meta && (input === 'b' || input === 'B' || input === 'f' || input === 'F')) return true;
+    // Meta/Option shortcuts are handled by parent components and should not
+    // also mutate focused text inputs. This covers terminal-specific encodings
+    // like Ghostty CSI-u (input='p', meta=true) and WezTerm ESC+p.
+    if (key.meta && input) return true;
 
     // Filter specific escape sequences that would insert garbage, but allow plain ESC through
     // CSI sequences (ESC[...), Option+Delete (ESC + DEL), and other multi-char escape sequences