@letta-ai/letta-code 0.11.2-next.1 → 0.11.2-next.3

package/letta.js

@@ -3237,7 +3237,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.11.2-next.1",
+    version: "0.11.2-next.3",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     bin: {
@@ -33383,6 +33383,17 @@ function getRipgrepBinDir() {
     return;
   }
 }
+function getPackageNodeModulesDir() {
+  try {
+    const __filename2 = fileURLToPath(import.meta.url);
+    const require2 = createRequire2(__filename2);
+    const clientPath = require2.resolve("@letta-ai/letta-client");
+    const match = clientPath.match(/^(.+[/\\]node_modules)[/\\]/);
+    return match ? match[1] : undefined;
+  } catch {
+    return;
+  }
+}
 function getShellEnv() {
   const env3 = { ...process.env };
   const rgBinDir = getRipgrepBinDir();
@@ -33401,6 +33412,11 @@ function getShellEnv() {
       }
     } catch {}
   }
+  const nodeModulesDir = getPackageNodeModulesDir();
+  if (nodeModulesDir) {
+    const currentNodePath = env3.NODE_PATH || "";
+    env3.NODE_PATH = currentNodePath ? `${nodeModulesDir}${path3.delimiter}${currentNodePath}` : nodeModulesDir;
+  }
   return env3;
 }
 var init_shellEnv = __esm(async () => {
@@ -77085,4 +77101,4 @@ Error during initialization: ${message}`);
 }
 main();
 
-//# debugId=CC2D0370FEDF40B764756E2164756E21
+//# debugId=97EC206550CD703E64756E2164756E21

package/package.json

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

package/skills/creating-skills/SKILL.md

@@ -263,7 +263,7 @@ When creating a new skill from scratch, always run the `init-skill.ts` script. T
 Usage:
 
 ```bash
-npx ts-node scripts/init-skill.ts <skill-name> --path <output-directory>
+npx tsx <SKILL_DIR>/scripts/init-skill.ts <skill-name> --path <output-directory>
 ```
 
 The script:
@@ -335,13 +335,13 @@ Write instructions for using the skill and its bundled resources.
 Once development of the skill is complete, it must be packaged into a distributable .skill file that gets shared with the user. The packaging process automatically validates the skill first to ensure it meets all requirements:
 
 ```bash
-npx ts-node scripts/package-skill.ts <path/to/skill-folder>
+npx tsx <SKILL_DIR>/scripts/package-skill.ts <path/to/skill-folder>
 ```
 
 Optional output directory specification:
 
 ```bash
-npx ts-node scripts/package-skill.ts <path/to/skill-folder> ./dist
+npx tsx <SKILL_DIR>/scripts/package-skill.ts <path/to/skill-folder> ./dist
 ```
 
 The packaging script will:

package/skills/finding-agents/SKILL.md

@@ -18,7 +18,7 @@ This skill helps you find other agents on the same Letta server.
 ## Script Usage
 
 ```bash
-npx ts-node scripts/find-agents.ts [options]
+npx tsx <SKILL_DIR>/scripts/find-agents.ts [options]
 ```
 
 ### Options
@@ -39,7 +39,7 @@ npx ts-node scripts/find-agents.ts [options]
 Agents created by Letta Code are tagged with `origin:letta-code`. To find only Letta Code agents:
 
 ```bash
-npx ts-node scripts/find-agents.ts --tags "origin:letta-code"
+npx tsx <SKILL_DIR>/scripts/find-agents.ts --tags "origin:letta-code"
 ```
 
 This is useful when the user is looking for agents they've worked with in Letta Code CLI sessions.
@@ -49,39 +49,39 @@ This is useful when the user is looking for agents they've worked with in Letta
 If the user has agents created outside Letta Code (via ADE, SDK, etc.), search without the tag filter:
 
 ```bash
-npx ts-node scripts/find-agents.ts
+npx tsx <SKILL_DIR>/scripts/find-agents.ts
 ```
 
 ## Examples
 
 **List all agents (up to 20):**
 ```bash
-npx ts-node scripts/find-agents.ts
+npx tsx <SKILL_DIR>/scripts/find-agents.ts
 ```
 
 **Find agent by exact name:**
 ```bash
-npx ts-node scripts/find-agents.ts --name "ProjectX-v1"
+npx tsx <SKILL_DIR>/scripts/find-agents.ts --name "ProjectX-v1"
 ```
 
 **Search agents by name (fuzzy):**
 ```bash
-npx ts-node scripts/find-agents.ts --query "project"
+npx tsx <SKILL_DIR>/scripts/find-agents.ts --query "project"
 ```
 
 **Find only Letta Code agents:**
 ```bash
-npx ts-node scripts/find-agents.ts --tags "origin:letta-code"
+npx tsx <SKILL_DIR>/scripts/find-agents.ts --tags "origin:letta-code"
 ```
 
 **Find agents with multiple tags:**
 ```bash
-npx ts-node scripts/find-agents.ts --tags "frontend,production" --match-all-tags
+npx tsx <SKILL_DIR>/scripts/find-agents.ts --tags "frontend,production" --match-all-tags
 ```
 
 **Include memory blocks in results:**
 ```bash
-npx ts-node scripts/find-agents.ts --query "project" --include-blocks
+npx tsx <SKILL_DIR>/scripts/find-agents.ts --query "project" --include-blocks
 ```
 
 ## Output

package/skills/finding-agents/scripts/find-agents.ts

@@ -1,9 +1,12 @@
-#!/usr/bin/env npx ts-node
+#!/usr/bin/env npx tsx
 /**
  * Find Agents - Search for agents with various filters
  *
+ * This script is standalone and can be run outside the CLI process.
+ * It reads auth from LETTA_API_KEY env var or ~/.letta/settings.json.
+ *
  * Usage:
- *   npx ts-node find-agents.ts [options]
+ *   npx tsx find-agents.ts [options]
  *
  * Options:
  *   --name <name>         Exact name match
@@ -17,9 +20,17 @@
  *   Raw API response from GET /v1/agents
  */
 
-import type Letta from "@letta-ai/letta-client";
-import { getClient } from "../../../../agent/client";
-import { settingsManager } from "../../../../settings-manager";
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+// Use createRequire for @letta-ai/letta-client so NODE_PATH is respected
+// (ES module imports don't respect NODE_PATH, but require does)
+const require = createRequire(import.meta.url);
+const Letta = require("@letta-ai/letta-client")
+  .default as typeof import("@letta-ai/letta-client").default;
+type LettaClient = InstanceType<typeof Letta>;
 
 interface FindAgentsOptions {
   name?: string;
@@ -30,6 +41,38 @@ interface FindAgentsOptions {
   limit?: number;
 }
 
+/**
+ * Get API key from env var or settings file
+ */
+function getApiKey(): string {
+  // First check env var (set by CLI's getShellEnv)
+  if (process.env.LETTA_API_KEY) {
+    return process.env.LETTA_API_KEY;
+  }
+
+  // Fall back to settings file
+  const settingsPath = join(homedir(), ".letta", "settings.json");
+  try {
+    const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+    if (settings.env?.LETTA_API_KEY) {
+      return settings.env.LETTA_API_KEY;
+    }
+  } catch {
+    // Settings file doesn't exist or is invalid
+  }
+
+  throw new Error(
+    "No LETTA_API_KEY found. Set the env var or run the Letta CLI to authenticate.",
+  );
+}
+
+/**
+ * Create a Letta client with auth from env/settings
+ */
+function createClient(): LettaClient {
+  return new Letta({ apiKey: getApiKey() });
+}
+
 /**
  * Find agents matching the given criteria
  * @param client - Letta client instance
@@ -37,7 +80,7 @@ interface FindAgentsOptions {
  * @returns Array of agent objects from the API
  */
 export async function findAgents(
-  client: Letta,
+  client: LettaClient,
   options: FindAgentsOptions = {},
 ): Promise<Awaited<ReturnType<typeof client.agents.list>>> {
   const params: Parameters<typeof client.agents.list>[0] = {
@@ -103,13 +146,13 @@ function parseArgs(args: string[]): FindAgentsOptions {
   return options;
 }
 
-// CLI entry point
-if (require.main === module) {
+// CLI entry point - check if this file is being run directly
+const isMainModule = import.meta.url === `file://${process.argv[1]}`;
+if (isMainModule) {
   (async () => {
     try {
       const options = parseArgs(process.argv.slice(2));
-      await settingsManager.initialize();
-      const client = await getClient();
+      const client = createClient();
       const result = await findAgents(client, options);
       console.log(JSON.stringify(result, null, 2));
     } catch (error) {
@@ -118,7 +161,7 @@ if (require.main === module) {
         error instanceof Error ? error.message : String(error),
       );
       console.error(`
-Usage: npx ts-node find-agents.ts [options]
+Usage: npx tsx find-agents.ts [options]
 
 Options:
   --name <name>         Exact name match

package/skills/migrating-memory/SKILL.md

@@ -60,7 +60,7 @@ Example: "What's the ID of the agent you want to migrate memory from?"
 Inspect what memory blocks the source agent has:
 
 ```bash
-npx ts-node scripts/get-agent-blocks.ts --agent-id <source-agent-id>
+npx tsx <SKILL_DIR>/scripts/get-agent-blocks.ts --agent-id <source-agent-id>
 ```
 
 This shows each block's ID, label, description, and value.
@@ -71,14 +71,14 @@ For each block you want to migrate, choose copy or share:
 
 **To Copy (create independent block):**
 ```bash
-npx ts-node scripts/copy-block.ts --block-id <block-id> [--label <new-label>]
+npx tsx <SKILL_DIR>/scripts/copy-block.ts --block-id <block-id> [--label <new-label>]
 ```
 
 Use `--label` if you already have a block with that label (e.g., `--label project-imported`).
 
 **To Share (attach existing block):**
 ```bash
-npx ts-node scripts/attach-block.ts --block-id <block-id>
+npx tsx <SKILL_DIR>/scripts/attach-block.ts --block-id <block-id>
 ```
 
 Add `--read-only` flag to share to make this agent unable to modify the block.
@@ -113,20 +113,20 @@ Scenario: You're a new agent and want to inherit memory from an existing agent "
 
 2. **List its blocks:**
    ```bash
-   npx ts-node scripts/get-agent-blocks.ts --agent-id agent-abc123
+   npx tsx <SKILL_DIR>/scripts/get-agent-blocks.ts --agent-id agent-abc123
    # Shows: project (block-def456), human (block-ghi789), persona (block-jkl012)
    ```
 
 3. **Copy project knowledge to yourself:**
    ```bash
    # If you don't have a 'project' block yet:
-   npx ts-node scripts/copy-block.ts --block-id block-def456
+   npx tsx <SKILL_DIR>/scripts/copy-block.ts --block-id block-def456
    
    # If you already have 'project', use --label to rename:
-   npx ts-node scripts/copy-block.ts --block-id block-def456 --label project-v1
+   npx tsx <SKILL_DIR>/scripts/copy-block.ts --block-id block-def456 --label project-v1
    ```
 
 4. **Optionally share human preferences (read-only):**
    ```bash
-   npx ts-node scripts/attach-block.ts --block-id block-ghi789 --read-only
+   npx tsx <SKILL_DIR>/scripts/attach-block.ts --block-id block-ghi789 --read-only
    ```

package/skills/migrating-memory/scripts/attach-block.ts

@@ -1,24 +1,79 @@
-#!/usr/bin/env npx ts-node
+#!/usr/bin/env npx tsx
 /**
  * Attach Block - Attaches an existing memory block to an agent (sharing)
  *
+ * This script is standalone and can be run outside the CLI process.
+ * It reads auth from LETTA_API_KEY env var or ~/.letta/settings.json.
+ * It reads agent ID from LETTA_AGENT_ID env var or --agent-id arg.
+ *
  * Usage:
- *   npx ts-node attach-block.ts --block-id <block-id> --target-agent-id <agent-id> [--read-only]
+ *   npx tsx attach-block.ts --block-id <block-id> [--agent-id <agent-id>] [--read-only]
  *
  * This attaches an existing block to another agent, making it shared.
  * Changes to the block will be visible to all agents that have it attached.
  *
  * Options:
- *   --read-only    Target agent can read but not modify the block
+ *   --agent-id   Target agent ID (overrides LETTA_AGENT_ID env var)
+ *   --read-only  Target agent can read but not modify the block
  *
  * Output:
  *   Raw API response from the attach operation
  */
 
-import type Letta from "@letta-ai/letta-client";
-import { getClient } from "../../../../agent/client";
-import { getCurrentAgentId } from "../../../../agent/context";
-import { settingsManager } from "../../../../settings-manager";
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+// Use createRequire for @letta-ai/letta-client so NODE_PATH is respected
+// (ES module imports don't respect NODE_PATH, but require does)
+const require = createRequire(import.meta.url);
+const Letta = require("@letta-ai/letta-client")
+  .default as typeof import("@letta-ai/letta-client").default;
+type LettaClient = InstanceType<typeof Letta>;
+
+/**
+ * Get API key from env var or settings file
+ */
+function getApiKey(): string {
+  if (process.env.LETTA_API_KEY) {
+    return process.env.LETTA_API_KEY;
+  }
+
+  const settingsPath = join(homedir(), ".letta", "settings.json");
+  try {
+    const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+    if (settings.env?.LETTA_API_KEY) {
+      return settings.env.LETTA_API_KEY;
+    }
+  } catch {
+    // Settings file doesn't exist or is invalid
+  }
+
+  throw new Error(
+    "No LETTA_API_KEY found. Set the env var or run the Letta CLI to authenticate.",
+  );
+}
+
+/**
+ * Get agent ID from CLI arg, env var, or throw
+ */
+function getAgentId(cliArg?: string): string {
+  if (cliArg) return cliArg;
+  if (process.env.LETTA_AGENT_ID) {
+    return process.env.LETTA_AGENT_ID;
+  }
+  throw new Error(
+    "No agent ID provided. Use --agent-id or ensure LETTA_AGENT_ID env var is set.",
+  );
+}
+
+/**
+ * Create a Letta client with auth from env/settings
+ */
+function createClient(): LettaClient {
+  return new Letta({ apiKey: getApiKey() });
+}
 
 /**
  * Attach an existing block to the current agent (sharing it)
@@ -29,13 +84,13 @@ import { settingsManager } from "../../../../settings-manager";
  * @returns API response from the attach operation
  */
 export async function attachBlock(
-  client: Letta,
+  client: LettaClient,
   blockId: string,
   readOnly = false,
   targetAgentId?: string,
 ): Promise<Awaited<ReturnType<typeof client.agents.blocks.attach>>> {
   // Get current agent ID (the agent calling this script) or use provided ID
-  const currentAgentId = targetAgentId ?? getCurrentAgentId();
+  const currentAgentId = getAgentId(targetAgentId);
 
   const result = await client.agents.blocks.attach(blockId, {
     agent_id: currentAgentId,
@@ -58,8 +113,10 @@ export async function attachBlock(
 function parseArgs(args: string[]): {
   blockId: string;
   readOnly: boolean;
+  agentId?: string;
 } {
   const blockIdIndex = args.indexOf("--block-id");
+  const agentIdIndex = args.indexOf("--agent-id");
   const readOnly = args.includes("--read-only");
 
   if (blockIdIndex === -1 || blockIdIndex + 1 >= args.length) {
@@ -69,17 +126,21 @@ function parseArgs(args: string[]): {
   return {
     blockId: args[blockIdIndex + 1] as string,
     readOnly,
+    agentId:
+      agentIdIndex !== -1 && agentIdIndex + 1 < args.length
+        ? (args[agentIdIndex + 1] as string)
+        : undefined,
   };
 }
 
-// CLI entry point
-if (require.main === module) {
+// CLI entry point - check if this file is being run directly
+const isMainModule = import.meta.url === `file://${process.argv[1]}`;
+if (isMainModule) {
   (async () => {
     try {
-      const { blockId, readOnly } = parseArgs(process.argv.slice(2));
-      await settingsManager.initialize();
-      const client = await getClient();
-      const result = await attachBlock(client, blockId, readOnly);
+      const { blockId, readOnly, agentId } = parseArgs(process.argv.slice(2));
+      const client = createClient();
+      const result = await attachBlock(client, blockId, readOnly, agentId);
       console.log(JSON.stringify(result, null, 2));
     } catch (error) {
       console.error(
@@ -91,7 +152,7 @@ if (require.main === module) {
         error.message.includes("Missing required argument")
       ) {
         console.error(
-          "\nUsage: npx ts-node attach-block.ts --block-id <block-id> [--read-only]",
+          "\nUsage: npx tsx attach-block.ts --block-id <block-id> [--agent-id <agent-id>] [--read-only]",
         );
       }
       process.exit(1);

package/skills/migrating-memory/scripts/copy-block.ts

@@ -1,12 +1,17 @@
-#!/usr/bin/env npx ts-node
+#!/usr/bin/env npx tsx
 /**
  * Copy Block - Copies a memory block to create a new independent block for the current agent
  *
+ * This script is standalone and can be run outside the CLI process.
+ * It reads auth from LETTA_API_KEY env var or ~/.letta/settings.json.
+ * It reads agent ID from LETTA_AGENT_ID env var or --agent-id arg.
+ *
  * Usage:
- *   npx ts-node copy-block.ts --block-id <block-id> [--label <new-label>]
+ *   npx tsx copy-block.ts --block-id <block-id> [--label <new-label>] [--agent-id <agent-id>]
  *
  * Options:
- *   --label    Override the block label (required if you already have a block with that label)
+ *   --label      Override the block label (required if you already have a block with that label)
+ *   --agent-id   Target agent ID (overrides LETTA_AGENT_ID env var)
  *
  * This creates a new block with the same content as the source block,
  * then attaches it to the current agent. Changes to the new block
@@ -16,17 +21,65 @@
  *   Raw API response from each step (retrieve, create, attach)
  */
 
-import type Letta from "@letta-ai/letta-client";
-import { getClient } from "../../../../agent/client";
-import { getCurrentAgentId } from "../../../../agent/context";
-import { settingsManager } from "../../../../settings-manager";
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+// Use createRequire for @letta-ai/letta-client so NODE_PATH is respected
+// (ES module imports don't respect NODE_PATH, but require does)
+const require = createRequire(import.meta.url);
+const Letta = require("@letta-ai/letta-client")
+  .default as typeof import("@letta-ai/letta-client").default;
+type LettaClient = InstanceType<typeof Letta>;
 
 interface CopyBlockResult {
-  sourceBlock: Awaited<ReturnType<typeof Letta.prototype.blocks.retrieve>>;
-  newBlock: Awaited<ReturnType<typeof Letta.prototype.blocks.create>>;
-  attachResult: Awaited<
-    ReturnType<typeof Letta.prototype.agents.blocks.attach>
-  >;
+  sourceBlock: Awaited<ReturnType<LettaClient["blocks"]["retrieve"]>>;
+  newBlock: Awaited<ReturnType<LettaClient["blocks"]["create"]>>;
+  attachResult: Awaited<ReturnType<LettaClient["agents"]["blocks"]["attach"]>>;
+}
+
+/**
+ * Get API key from env var or settings file
+ */
+function getApiKey(): string {
+  if (process.env.LETTA_API_KEY) {
+    return process.env.LETTA_API_KEY;
+  }
+
+  const settingsPath = join(homedir(), ".letta", "settings.json");
+  try {
+    const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+    if (settings.env?.LETTA_API_KEY) {
+      return settings.env.LETTA_API_KEY;
+    }
+  } catch {
+    // Settings file doesn't exist or is invalid
+  }
+
+  throw new Error(
+    "No LETTA_API_KEY found. Set the env var or run the Letta CLI to authenticate.",
+  );
+}
+
+/**
+ * Get agent ID from CLI arg, env var, or throw
+ */
+function getAgentId(cliArg?: string): string {
+  if (cliArg) return cliArg;
+  if (process.env.LETTA_AGENT_ID) {
+    return process.env.LETTA_AGENT_ID;
+  }
+  throw new Error(
+    "No agent ID provided. Use --agent-id or ensure LETTA_AGENT_ID env var is set.",
+  );
+}
+
+/**
+ * Create a Letta client with auth from env/settings
+ */
+function createClient(): LettaClient {
+  return new Letta({ apiKey: getApiKey() });
 }
 
 /**
@@ -37,12 +90,12 @@ interface CopyBlockResult {
  * @returns Object containing source block, new block, and attach result
  */
 export async function copyBlock(
-  client: Letta,
+  client: LettaClient,
   blockId: string,
   options?: { labelOverride?: string; targetAgentId?: string },
 ): Promise<CopyBlockResult> {
   // Get current agent ID (the agent calling this script) or use provided ID
-  const currentAgentId = options?.targetAgentId ?? getCurrentAgentId();
+  const currentAgentId = getAgentId(options?.targetAgentId);
 
   // 1. Get source block details
   const sourceBlock = await client.blocks.retrieve(blockId);
@@ -63,9 +116,14 @@ export async function copyBlock(
   return { sourceBlock, newBlock, attachResult };
 }
 
-function parseArgs(args: string[]): { blockId: string; label?: string } {
+function parseArgs(args: string[]): {
+  blockId: string;
+  label?: string;
+  agentId?: string;
+} {
   const blockIdIndex = args.indexOf("--block-id");
   const labelIndex = args.indexOf("--label");
+  const agentIdIndex = args.indexOf("--agent-id");
 
   if (blockIdIndex === -1 || blockIdIndex + 1 >= args.length) {
     throw new Error("Missing required argument: --block-id <block-id>");
@@ -77,17 +135,24 @@ function parseArgs(args: string[]): { blockId: string; label?: string } {
       labelIndex !== -1 && labelIndex + 1 < args.length
         ? (args[labelIndex + 1] as string)
         : undefined,
+    agentId:
+      agentIdIndex !== -1 && agentIdIndex + 1 < args.length
+        ? (args[agentIdIndex + 1] as string)
+        : undefined,
   };
 }
 
-// CLI entry point
-if (require.main === module) {
+// CLI entry point - check if this file is being run directly
+const isMainModule = import.meta.url === `file://${process.argv[1]}`;
+if (isMainModule) {
   (async () => {
     try {
-      const { blockId, label } = parseArgs(process.argv.slice(2));
-      await settingsManager.initialize();
-      const client = await getClient();
-      const result = await copyBlock(client, blockId, { labelOverride: label });
+      const { blockId, label, agentId } = parseArgs(process.argv.slice(2));
+      const client = createClient();
+      const result = await copyBlock(client, blockId, {
+        labelOverride: label,
+        targetAgentId: agentId,
+      });
       console.log(JSON.stringify(result, null, 2));
     } catch (error) {
       console.error(
@@ -99,7 +164,7 @@ if (require.main === module) {
         error.message.includes("Missing required argument")
       ) {
         console.error(
-          "\nUsage: npx ts-node copy-block.ts --block-id <block-id> [--label <new-label>]",
+          "\nUsage: npx tsx copy-block.ts --block-id <block-id> [--label <new-label>] [--agent-id <agent-id>]",
         );
       }
       process.exit(1);

package/skills/migrating-memory/scripts/get-agent-blocks.ts

@@ -1,17 +1,58 @@
-#!/usr/bin/env npx ts-node
+#!/usr/bin/env npx tsx
 /**
  * Get Agent Blocks - Retrieves memory blocks from a specific agent
  *
+ * This script is standalone and can be run outside the CLI process.
+ * It reads auth from LETTA_API_KEY env var or ~/.letta/settings.json.
+ *
  * Usage:
- *   npx ts-node get-agent-blocks.ts --agent-id <agent-id>
+ *   npx tsx get-agent-blocks.ts --agent-id <agent-id>
  *
  * Output:
  *   Raw API response from GET /v1/agents/{id}/core-memory/blocks
  */
 
-import type Letta from "@letta-ai/letta-client";
-import { getClient } from "../../../../agent/client";
-import { settingsManager } from "../../../../settings-manager";
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+// Use createRequire for @letta-ai/letta-client so NODE_PATH is respected
+// (ES module imports don't respect NODE_PATH, but require does)
+const require = createRequire(import.meta.url);
+const Letta = require("@letta-ai/letta-client")
+  .default as typeof import("@letta-ai/letta-client").default;
+type LettaClient = InstanceType<typeof Letta>;
+
+/**
+ * Get API key from env var or settings file
+ */
+function getApiKey(): string {
+  if (process.env.LETTA_API_KEY) {
+    return process.env.LETTA_API_KEY;
+  }
+
+  const settingsPath = join(homedir(), ".letta", "settings.json");
+  try {
+    const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+    if (settings.env?.LETTA_API_KEY) {
+      return settings.env.LETTA_API_KEY;
+    }
+  } catch {
+    // Settings file doesn't exist or is invalid
+  }
+
+  throw new Error(
+    "No LETTA_API_KEY found. Set the env var or run the Letta CLI to authenticate.",
+  );
+}
+
+/**
+ * Create a Letta client with auth from env/settings
+ */
+function createClient(): LettaClient {
+  return new Letta({ apiKey: getApiKey() });
+}
 
 /**
  * Get memory blocks for a specific agent
@@ -20,7 +61,7 @@ import { settingsManager } from "../../../../settings-manager";
  * @returns Array of block objects from the API
  */
 export async function getAgentBlocks(
-  client: Letta,
+  client: LettaClient,
   agentId: string,
 ): Promise<Awaited<ReturnType<typeof client.agents.blocks.list>>> {
   return await client.agents.blocks.list(agentId);
@@ -34,13 +75,13 @@ function parseArgs(args: string[]): { agentId: string } {
   return { agentId: args[agentIdIndex + 1] as string };
 }
 
-// CLI entry point
-if (require.main === module) {
+// CLI entry point - check if this file is being run directly
+const isMainModule = import.meta.url === `file://${process.argv[1]}`;
+if (isMainModule) {
   (async () => {
     try {
       const { agentId } = parseArgs(process.argv.slice(2));
-      await settingsManager.initialize();
-      const client = await getClient();
+      const client = createClient();
       const result = await getAgentBlocks(client, agentId);
       console.log(JSON.stringify(result, null, 2));
     } catch (error) {
@@ -53,7 +94,7 @@ if (require.main === module) {
         error.message.includes("Missing required argument")
       ) {
         console.error(
-          "\nUsage: npx ts-node get-agent-blocks.ts --agent-id <agent-id>",
+          "\nUsage: npx tsx get-agent-blocks.ts --agent-id <agent-id>",
         );
       }
       process.exit(1);

package/skills/searching-messages/scripts/get-messages.ts

@@ -26,9 +26,16 @@
  */
 
 import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import Letta from "@letta-ai/letta-client";
+
+// Use createRequire for @letta-ai/letta-client so NODE_PATH is respected
+// (ES module imports don't respect NODE_PATH, but require does)
+const require = createRequire(import.meta.url);
+const Letta = require("@letta-ai/letta-client")
+  .default as typeof import("@letta-ai/letta-client").default;
+type LettaClient = InstanceType<typeof Letta>;
 
 interface GetMessagesOptions {
   startDate?: string;
@@ -85,7 +92,7 @@ function getAgentId(cliArg?: string): string {
 /**
  * Create a Letta client with auth from env/settings
  */
-function createClient(): Letta {
+function createClient(): LettaClient {
   return new Letta({ apiKey: getApiKey() });
 }
 
@@ -96,7 +103,7 @@ function createClient(): Letta {
  * @returns Array of messages in chronological order
  */
 export async function getMessages(
-  client: Letta,
+  client: LettaClient,
   options: GetMessagesOptions = {},
 ): Promise<unknown[]> {
   const agentId = getAgentId(options.agentId);

package/skills/searching-messages/scripts/search-messages.ts

@@ -24,9 +24,16 @@
  */
 
 import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import Letta from "@letta-ai/letta-client";
+
+// Use createRequire for @letta-ai/letta-client so NODE_PATH is respected
+// (ES module imports don't respect NODE_PATH, but require does)
+const require = createRequire(import.meta.url);
+const Letta = require("@letta-ai/letta-client")
+  .default as typeof import("@letta-ai/letta-client").default;
+type LettaClient = InstanceType<typeof Letta>;
 
 interface SearchMessagesOptions {
   query: string;
@@ -83,7 +90,7 @@ function getAgentId(cliArg?: string): string {
 /**
  * Create a Letta client with auth from env/settings
  */
-function createClient(): Letta {
+function createClient(): LettaClient {
   return new Letta({ apiKey: getApiKey() });
 }
 
@@ -94,7 +101,7 @@ function createClient(): Letta {
  * @returns Array of search results with scores
  */
 export async function searchMessages(
-  client: Letta,
+  client: LettaClient,
   options: SearchMessagesOptions,
 ): Promise<Awaited<ReturnType<typeof client.messages.search>>> {
   // Default to current agent unless --all-agents is specified