Merge pull request #9 from taurean/letta-sdk-upgrade

Letta sdk upgrade

deno.json

···
     "@js-temporal/polyfill": "npm:@js-temporal/polyfill",
     "@atproto/api": "npm:@atproto/api",
     "@atproto/lexicon": "npm:@atproto/lexicon",
-    "@letta-ai/letta-client": "npm:@letta-ai/letta-client",
+    "@letta-ai/letta-client": "npm:@letta-ai/letta-client@1.0.0",
     "@voyager/autonomy-lexicon": "jsr:@voyager/autonomy-lexicon@^0.1.1"
   }
 }

deno.lock

···
     "npm:@atproto/api@*": "0.17.2",
     "npm:@atproto/lexicon@*": "0.5.1",
     "npm:@js-temporal/polyfill@*": "0.5.1",
-    "npm:@letta-ai/letta-client@*": "0.0.68664"
+    "npm:@letta-ai/letta-client@1.0.0": "1.0.0"
   },
   "jsr": {
     "@std/assert@1.0.15": {
···
         "jsbi"
       ]
     },
-    "@letta-ai/letta-client@0.0.68664": {
-      "integrity": "sha512-/0g8dV3IIX0WfnOUDY1EEgnhj/747m73zhTmbLhldEMjCk/RzKyjvUeZbHiukiGoCf/u1nxRgcRUn66MKMYB2A==",
-      "dependencies": [
-        "form-data",
-        "form-data-encoder",
-        "formdata-node",
-        "node-fetch",
-        "qs",
-        "readable-stream",
-        "url-join"
-      ]
-    },
-    "abort-controller@3.0.0": {
-      "integrity": "sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg==",
-      "dependencies": [
-        "event-target-shim"
-      ]
-    },
-    "asynckit@0.4.0": {
-      "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q=="
+    "@letta-ai/letta-client@1.0.0": {
+      "integrity": "sha512-owR/gcLVFlv89CtJsb1m4xvYJcApooyEvrzqWLgf6bnfJuog65YXPUdwZIsA2YBk9a3u+l3wvYsDuk0uj5PCtA=="
     },
     "await-lock@2.2.2": {
       "integrity": "sha512-aDczADvlvTGajTDjcjpJMqRkOF6Qdz3YbPZm/PyW6tKPkx2hlYBzxMhEywM/tU72HrVZjgl5VCdRuMlA7pZ8Gw=="
     },
-    "base64-js@1.5.1": {
-      "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA=="
-    },
-    "buffer@6.0.3": {
-      "integrity": "sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA==",
-      "dependencies": [
-        "base64-js",
-        "ieee754"
-      ]
-    },
-    "call-bind-apply-helpers@1.0.2": {
-      "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
-      "dependencies": [
-        "es-errors",
-        "function-bind"
-      ]
-    },
-    "call-bound@1.0.4": {
-      "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==",
-      "dependencies": [
-        "call-bind-apply-helpers",
-        "get-intrinsic"
-      ]
-    },
-    "combined-stream@1.0.8": {
-      "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
-      "dependencies": [
-        "delayed-stream"
-      ]
-    },
-    "delayed-stream@1.0.0": {
-      "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ=="
-    },
-    "dunder-proto@1.0.1": {
-      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
-      "dependencies": [
-        "call-bind-apply-helpers",
-        "es-errors",
-        "gopd"
-      ]
-    },
-    "es-define-property@1.0.1": {
-      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g=="
-    },
-    "es-errors@1.3.0": {
-      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw=="
-    },
-    "es-object-atoms@1.1.1": {
-      "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
-      "dependencies": [
-        "es-errors"
-      ]
-    },
-    "es-set-tostringtag@2.1.0": {
-      "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
-      "dependencies": [
-        "es-errors",
-        "get-intrinsic",
-        "has-tostringtag",
-        "hasown"
-      ]
-    },
-    "event-target-shim@5.0.1": {
-      "integrity": "sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ=="
-    },
-    "events@3.3.0": {
-      "integrity": "sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q=="
-    },
-    "form-data-encoder@4.1.0": {
-      "integrity": "sha512-G6NsmEW15s0Uw9XnCg+33H3ViYRyiM0hMrMhhqQOR8NFc5GhYrI+6I3u7OTw7b91J2g8rtvMBZJDbcGb2YUniw=="
-    },
-    "form-data@4.0.4": {
-      "integrity": "sha512-KrGhL9Q4zjj0kiUt5OO4Mr/A/jlI2jDYs5eHBpYHPcBEVSiipAvn2Ko2HnPe20rmcuuvMHNdZFp+4IlGTMF0Ow==",
-      "dependencies": [
-        "asynckit",
-        "combined-stream",
-        "es-set-tostringtag",
-        "hasown",
-        "mime-types"
-      ]
-    },
-    "formdata-node@6.0.3": {
-      "integrity": "sha512-8e1++BCiTzUno9v5IZ2J6bv4RU+3UKDmqWUQD0MIMVCd9AdhWkO1gw57oo1mNEX1dMq2EGI+FbWz4B92pscSQg=="
-    },
-    "function-bind@1.1.2": {
-      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA=="
-    },
-    "get-intrinsic@1.3.0": {
-      "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
-      "dependencies": [
-        "call-bind-apply-helpers",
-        "es-define-property",
-        "es-errors",
-        "es-object-atoms",
-        "function-bind",
-        "get-proto",
-        "gopd",
-        "has-symbols",
-        "hasown",
-        "math-intrinsics"
-      ]
-    },
-    "get-proto@1.0.1": {
-      "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
-      "dependencies": [
-        "dunder-proto",
-        "es-object-atoms"
-      ]
-    },
-    "gopd@1.2.0": {
-      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg=="
-    },
     "graphemer@1.4.0": {
       "integrity": "sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag=="
     },
-    "has-symbols@1.1.0": {
-      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ=="
-    },
-    "has-tostringtag@1.0.2": {
-      "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
-      "dependencies": [
-        "has-symbols"
-      ]
-    },
-    "hasown@2.0.2": {
-      "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
-      "dependencies": [
-        "function-bind"
-      ]
-    },
-    "ieee754@1.2.1": {
-      "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA=="
-    },
     "iso-datestring-validator@2.2.2": {
       "integrity": "sha512-yLEMkBbLZTlVQqOnQ4FiMujR6T4DEcCb1xizmvXS+OxuhwcbtynoosRzdMA69zZCShCNAbi+gJ71FxZBBXx1SA=="
     },
     "jsbi@4.3.2": {
       "integrity": "sha512-9fqMSQbhJykSeii05nxKl4m6Eqn2P6rOlYiS+C5Dr/HPIU/7yZxu5qzbs40tgaFORiw2Amd0mirjxatXYMkIew=="
     },
-    "math-intrinsics@1.1.0": {
-      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g=="
-    },
-    "mime-db@1.52.0": {
-      "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg=="
-    },
-    "mime-types@2.1.35": {
-      "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
-      "dependencies": [
-        "mime-db"
-      ]
-    },
     "multiformats@9.9.0": {
       "integrity": "sha512-HoMUjhH9T8DDBNT+6xzkrd9ga/XiBI4xLr58LJACwK6G3HTOPeMz4nB4KJs33L2BelrIJa7P0VuNaVF3hMYfjg=="
     },
-    "node-fetch@2.7.0": {
-      "integrity": "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==",
-      "dependencies": [
-        "whatwg-url"
-      ]
-    },
-    "object-inspect@1.13.4": {
-      "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew=="
-    },
-    "process@0.11.10": {
-      "integrity": "sha512-cdGef/drWFoydD1JsMzuFf8100nZl+GT+yacc2bEced5f9Rjk4z+WtFUTBu9PhOi9j/jfmBPu0mMEY4wIdAF8A=="
-    },
-    "qs@6.14.0": {
-      "integrity": "sha512-YWWTjgABSKcvs/nWBi9PycY/JiPJqOD4JA6o9Sej2AtvSGarXxKC3OQSk4pAarbdQlKAh5D4FCQkJNkW+GAn3w==",
-      "dependencies": [
-        "side-channel"
-      ]
-    },
-    "readable-stream@4.7.0": {
-      "integrity": "sha512-oIGGmcpTLwPga8Bn6/Z75SVaH1z5dUut2ibSyAMVhmUggWpmDn2dapB0n7f8nwaSiRtepAsfJyfXIO5DCVAODg==",
-      "dependencies": [
-        "abort-controller",
-        "buffer",
-        "events",
-        "process",
-        "string_decoder"
-      ]
-    },
-    "safe-buffer@5.2.1": {
-      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ=="
-    },
-    "side-channel-list@1.0.0": {
-      "integrity": "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==",
-      "dependencies": [
-        "es-errors",
-        "object-inspect"
-      ]
-    },
-    "side-channel-map@1.0.1": {
-      "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==",
-      "dependencies": [
-        "call-bound",
-        "es-errors",
-        "get-intrinsic",
-        "object-inspect"
-      ]
-    },
-    "side-channel-weakmap@1.0.2": {
-      "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==",
-      "dependencies": [
-        "call-bound",
-        "es-errors",
-        "get-intrinsic",
-        "object-inspect",
-        "side-channel-map"
-      ]
-    },
-    "side-channel@1.1.0": {
-      "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==",
-      "dependencies": [
-        "es-errors",
-        "object-inspect",
-        "side-channel-list",
-        "side-channel-map",
-        "side-channel-weakmap"
-      ]
-    },
-    "string_decoder@1.3.0": {
-      "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==",
-      "dependencies": [
-        "safe-buffer"
-      ]
-    },
     "tlds@1.260.0": {
       "integrity": "sha512-78+28EWBhCEE7qlyaHA9OR3IPvbCLiDh3Ckla593TksfFc9vfTsgvH7eS+dr3o9qr31gwGbogcI16yN91PoRjQ==",
       "bin": true
     },
-    "tr46@0.0.3": {
-      "integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw=="
-    },
     "uint8arrays@3.0.0": {
       "integrity": "sha512-HRCx0q6O9Bfbp+HHSfQQKD7wU70+lydKVt4EghkdOvlK/NlrF90z+eXV34mUd48rNvVJXwkrMSPpCATkct8fJA==",
       "dependencies": [
         "multiformats"
       ]
     },
-    "url-join@4.0.1": {
-      "integrity": "sha512-jk1+QP6ZJqyOiuEI9AEWQfju/nB2Pw466kbA0LEZljHwKeMgd9WrAEgEGxjPDD2+TNbbb37rTyhEfrCXfuKXnA=="
-    },
-    "webidl-conversions@3.0.1": {
-      "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ=="
-    },
-    "whatwg-url@5.0.0": {
-      "integrity": "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==",
-      "dependencies": [
-        "tr46",
-        "webidl-conversions"
-      ]
-    },
     "zod@3.25.76": {
       "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="
     }
···
       "npm:@atproto/api@*",
       "npm:@atproto/lexicon@*",
       "npm:@js-temporal/polyfill@*",
-      "npm:@letta-ai/letta-client@*"
+      "npm:@letta-ai/letta-client@1.0.0"
     ]
   }
 }

mount.ts

···
  */
 export async function mount(): Promise<void> {
   const agentId = Deno.env.get("LETTA_AGENT_ID");
-  const agentName = Deno.env.get("LETTA_PROJECT_NAME");
+  const agentName = Deno.env.get("LETTA_PROJECT_ID");
 
   if (!agentId) {
     console.error(
···
     console.log(`Agent retrieved: ${agent.name}`);
 
     // Get all existing blocks for this agent
-    const existingBlocks = await client.agents.blocks.list(agentId);
+    const existingBlocksPage = await client.agents.blocks.list(agentId);
+    const existingBlocks = existingBlocksPage.items;
     console.log(`Agent has ${existingBlocks.length} existing memory blocks`);
 
     // Build dynamic memory blocks array based on configuration
···
           );
         } else {
           console.log(`Updating existing block: ${blockConfig.label}`);
-          await client.blocks.modify(existingBlock.id, {
+          await client.blocks.update(existingBlock.id, {
             value: blockConfig.value,
             description: blockConfig.description,
             limit: blockConfig.limit,
···
 
         // Attach the block to the agent
         if (newBlock.id) {
-          await client.agents.blocks.attach(agentId, newBlock.id);
+          await client.agents.blocks.attach(newBlock.id, { agent_id: agentId });
           console.log(`✓ Attached block: ${blockConfig.label}`);
         } else {
           throw new Error(`Failed to create block: ${blockConfig.label}`);
···
     }
 
     // Update agent with tool environment variables
-    await client.agents.modify(agentId, {
-      toolExecEnvironmentVariables: {
+    await client.agents.update(agentId, {
+      secrets: {
         BSKY_USERNAME: bskyUsername || "",
         BSKY_APP_PASSWORD: bskyAppPassword || "",
         BSKY_SERVICE_URL: bskyServiceUrl || "https://bsky.social",
···
     }
 
     // Get currently attached tools
-    const attachedTools = await client.agents.tools.list(agentId);
+    const attachedToolsPage = await client.agents.tools.list(agentId);
+    const attachedTools = attachedToolsPage.items;
     const attachedToolNames = attachedTools.map((tool: any) => tool.name);
     console.log(`Agent has ${attachedTools.length} tools currently attached`);
 
···
 
     // Create a user-level client for tool operations
     // Tools are user-level resources, not project-scoped
-    const { LettaClient } = await import("@letta-ai/letta-client");
-    const userLevelClient = new LettaClient({
-      token: Deno.env.get("LETTA_API_KEY"),
+    const { default: Letta } = await import("@letta-ai/letta-client");
+    const userLevelClient = new Letta({
+      apiKey: Deno.env.get("LETTA_API_KEY"),
     });
 
     // First, process hardcoded required tools
···
         }
 
         // Search for the tool in the global registry
-        const existingTools = await userLevelClient.tools.list({
+        const existingToolsPage = await userLevelClient.tools.list({
           name: toolName,
         });
+        const existingTools = existingToolsPage.items;
 
         if (existingTools.length > 0) {
           const tool = existingTools[0];
           if (tool.id) {
-            await client.agents.tools.attach(agentId, tool.id);
+            await client.agents.tools.attach(tool.id, { agent_id: agentId });
             console.log(`✓ Attached required tool: ${toolName}`);
             toolsAttached++;
           }
···
         try {
           // Attempt to create the tool - Letta will extract the function name from docstring
           const createParams: any = {
-            sourceCode: toolSource,
+            source_code: toolSource,
           };
 
           // Add pip requirements if any were detected
           if (pipRequirements.length > 0) {
-            createParams.pipRequirements = pipRequirements;
+            createParams.pip_requirements = pipRequirements;
           }
 
           tool = await userLevelClient.tools.create(createParams);
···
             const funcMatch = toolSource.match(/^def\s+(\w+)\s*\(/m);
             if (funcMatch) {
               const functionName = funcMatch[1];
-              const existingTools = await userLevelClient.tools.list({
+              const existingToolsPage = await userLevelClient.tools.list({
                 name: functionName,
               });
+              const existingTools = existingToolsPage.items;
               if (existingTools.length > 0) {
                 tool = existingTools[0];
               }
···
 
         // Attach the tool to the agent
         if (tool.id) {
-          await client.agents.tools.attach(agentId, tool.id);
+          await client.agents.tools.attach(tool.id, { agent_id: agentId });
           if (wasCreated) {
             console.log(
               `✓ Created and attached tool: ${toolName} (from ${toolFileName}.py)`,

utils/agentContext.ts

···
   return value;
 };
 
-export const getLettaProjectName = (): string => {
-  const value = Deno.env.get("LETTA_PROJECT_NAME")?.trim();
+const getLettaProjectID = (): string => {
+  const value = Deno.env.get("LETTA_PROJECT_ID")?.trim();
 
   if (!value?.length) {
     throw Error(
-      "Letta Project Name not provided in `.env`. add variable `LETTA_PROJECT_NAME=`.",
+      "Letta Project ID not provided in `.env`. add variable `LETTA_PROJECT_ID=`.",
+    );
+  } else if (!value.includes("-")) {
+    throw Error(
+      "Letta Project ID is not formed correctly, check variable `LETTA_PROJECT_ID`",
     );
   }
 
   return value;
 };
-
-//
-// temporarily commenting out until switch to letta SDK 1.0
-//
-// const getLettaProjectID = (): string => {
-//   const value = Deno.env.get("LETTA_PROJECT_ID")?.trim();
-
-//   if (!value?.length) {
-//     throw Error(
-//       "Letta Project ID not provided in `.env`. add variable `LETTA_PROJECT_ID=`.",
-//     );
-//   } else if (!value.includes("-")) {
-//     throw Error(
-//       "Letta Project ID is not formed correctly, check variable `LETTA_PROJECT_ID`",
-//     );
-//   }
-
-//   return value;
-// };
 
 const getAgentBskyHandle = (): string => {
   const value = Deno.env.get("BSKY_USERNAME")?.trim();
···
     replyCount: 0,
     quoteCount: 0,
     // required with manual variables
-    lettaProjectIdentifier: getLettaProjectName(),
+    lettaProjectIdentifier: getLettaProjectID(),
     agentBskyHandle: getAgentBskyHandle(),
     agentBskyName: await getAgentBskyName(),
     agentBskyDID: setAgentBskyDID(),

utils/messageAgent.ts

···
-import { LettaClient } from "@letta-ai/letta-client";
+import Letta from "@letta-ai/letta-client";
 import { agentContext } from "./agentContext.ts";
 // Helper function to format tool arguments as inline key-value pairs
 const formatArgsInline = (args: unknown): string => {
···
   return `${str.slice(0, maxLength)}... (truncated, ${str.length} total chars)`;
 };
 
-export const client = new LettaClient({
-  token: Deno.env.get("LETTA_API_KEY"),
-  project: Deno.env.get("LETTA_PROJECT_NAME"),
+export const client = new Letta({
+  apiKey: Deno.env.get("LETTA_API_KEY"),
+  // @ts-ignore: Letta SDK type definition might be slightly off or expecting different casing
+  projectId: Deno.env.get("LETTA_PROJECT_ID"),
 });
 
 export const messageAgent = async (prompt: string) => {
   const agent = Deno.env.get("LETTA_AGENT_ID");
 
   if (agent) {
-    const reachAgent = await client.agents.messages.createStream(agent, {
+    const reachAgent = await client.agents.messages.stream(agent, {
       messages: [
         {
-          role: "user",
-          content: [
-            {
-              type: "text",
-              text: prompt,
-            },
-          ],
+          role: "system",
+          content: prompt,
         },
       ],
-      streamTokens: true,
+      stream_tokens: true,
     });
 
     for await (const response of reachAgent) {
-      if (response.messageType === "reasoning_message") {
+      if (response.message_type === "reasoning_message") {
         // console.log(`💭 reasoning…`);
-      } else if (response.messageType === "assistant_message") {
+      } else if (response.message_type === "assistant_message") {
         console.log(`💬 ${agentContext.agentBskyName}: ${response.content}`);
-      } else if (response.messageType === "tool_call_message") {
-        const formattedArgs = formatArgsInline(response.toolCall.arguments);
-        console.log(
-          `🗜️  tool called: ${response.toolCall.name} with args: ${formattedArgs}`,
-        );
-      } else if (response.messageType === "tool_return_message") {
-        const toolReturn = response.toolReturn;
+      } else if (response.message_type === "tool_call_message") {
+        if (
+          Array.isArray(response.tool_calls) && response.tool_calls.length > 0
+        ) {
+          const toolCall = response.tool_calls[0];
+          const formattedArgs = formatArgsInline(toolCall.arguments);
+          console.log(
+            `🗜️  tool called: ${toolCall.name} with args: ${formattedArgs}`,
+          );
+        }
+      } else if (response.message_type === "tool_return_message") {
+        const toolReturn = response.tool_returns;
         const returnStr = typeof toolReturn === "string"
           ? toolReturn
           : JSON.stringify(toolReturn);
         console.log(`🔧 tool response: ${truncateString(returnStr)}`);
-      } else if (response.messageType === "usage_statistics") {
-        console.log(`🔢 total steps: ${response.stepCount}`);
-      } else if (response.messageType === "hidden_reasoning_message") {
+      } else if (response.message_type === "usage_statistics") {
+        console.log(`🔢 total steps: ${response.step_count}`);
+      } else if (response.message_type === "hidden_reasoning_message") {
         console.log(`hidden reasoning…`);
       }
     }