Update Letta client imports and method names

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)`,