cloudseeding / mount.ts

import { client } from "./utils/messageAgent.ts";
import { submitAutonomyDeclarationRecord } from "./utils/declaration.ts";
import { blueskyProtocolsValue } from "./memories/blueskyProtocolsValue.ts";

await submitAutonomyDeclarationRecord();

/**
 * Memory block configurations for the Bluesky agent.
 * These blocks will be created if they don't exist, or updated if they do.
 */
const BLUESKY_MEMORY_BLOCKS = [
  {
    label: "bluesky_operational_guide",
    description:
      "Operational rules for Bluesky platform behavior. Contains notification handling protocols, tool usage constraints, and spam prevention rules. Consult before processing any Bluesky notification or initiating platform actions.",
    value: blueskyProtocolsValue,
    limit: 20000,
  },
];

/**
 * Hardcoded tool names that should always be attached to the Bluesky agent.
 * These are tools that already exist in the Letta registry (built-in or previously created).
 */
const REQUIRED_TOOLS: string[] = [
  "archival_memory_insert",
  "archival_memory_search",
  "conversation_search",
  "web_search",
  "fetch_webpage",
  "memory",
];

/**
 * Detects Python package imports in source code.
 * Returns an array of package names that need to be installed.
 */
function detectPipRequirements(sourceCode: string): Array<{ name: string }> {
  const requirements: Array<{ name: string }> = [];

  // Check for atproto import
  if (
    sourceCode.includes("from atproto import") ||
    sourceCode.includes("import atproto")
  ) {
    requirements.push({ name: "atproto" });
  }

  // Add more package detection patterns here as needed
  // Example: if (sourceCode.includes("import requests")) { requirements.push({ name: "requests" }); }

  return requirements;
}

/**
 * Discovers Bluesky tools by scanning the tools/bluesky/ directory.
 * Returns an array of tool names (without the .py extension).
 */
async function discoverBlueskyTools(): Promise<string[]> {
  const toolsDir = "./tools/bluesky";
  const tools: string[] = [];

  try {
    for await (const entry of Deno.readDir(toolsDir)) {
      if (entry.isFile && entry.name.endsWith(".py")) {
        // Extract tool name (remove .py extension)
        const toolName = entry.name.slice(0, -3);
        tools.push(toolName);
      }
    }
  } catch (error) {
    console.warn(
      `Warning: Could not read tools directory (${toolsDir}):`,
      error.message,
    );
  }

  return tools;
}

/**
 * Prepares the Letta agent for Bluesky by ensuring all required memory blocks
 * are present and configured correctly. If blocks exist, their content is updated.
 * If blocks don't exist, they are created and attached to the agent.
 */
export async function mount(): Promise<void> {
  const agentId = Deno.env.get("LETTA_AGENT_ID");
  const agentName = Deno.env.get("LETTA_PROJECT_NAME");

  if (!agentId) {
    console.error(
      "LETTA_AGENT_ID not found in environment variables. make sure to run `Deno task setup` first, then update your `.env` file.",
    );
    throw new Error("LETTA_AGENT_ID is required");
  }

  console.log(`Preparing agent ${agentName} for Bluesky...`);

  try {
    // Get the current agent state
    const agent = await client.agents.retrieve(agentId);
    console.log(`Agent retrieved: ${agent.name}`);

    // Get all existing blocks for this agent
    const existingBlocks = await client.agents.blocks.list(agentId);
    console.log(`Agent has ${existingBlocks.length} existing memory blocks`);

    // Process each required memory block
    for (const blockConfig of BLUESKY_MEMORY_BLOCKS) {
      // Check if a block with this label already exists
      const existingBlock = existingBlocks.find(
        (block: any) => block.label === blockConfig.label,
      );

      if (existingBlock && existingBlock.id) {
        // Block exists - update its content
        console.log(`Updating existing block: ${blockConfig.label}`);
        await client.blocks.modify(existingBlock.id, {
          value: blockConfig.value,
          description: blockConfig.description,
          limit: blockConfig.limit,
        });
        console.log(`✓ Updated block: ${blockConfig.label}`);
      } else {
        // Block doesn't exist - create and attach it
        console.log(`Creating new block: ${blockConfig.label}`);
        const newBlock = await client.blocks.create({
          label: blockConfig.label,
          description: blockConfig.description,
          value: blockConfig.value,
          limit: blockConfig.limit,
        });
        console.log(`Created block with ID: ${newBlock.id}`);

        // Attach the block to the agent
        if (newBlock.id) {
          await client.agents.blocks.attach(agentId, newBlock.id);
          console.log(`✓ Attached block: ${blockConfig.label}`);
        } else {
          throw new Error(`Failed to create block: ${blockConfig.label}`);
        }
      }
    }

    // Configure tool environment variables for Bluesky credentials
    console.log("Configuring tool environment variables...");

    const bskyUsername = Deno.env.get("BSKY_USERNAME");
    const bskyAppPassword = Deno.env.get("BSKY_APP_PASSWORD");
    const bskyServiceUrl = Deno.env.get("BSKY_SERVICE_URL");

    if (!bskyUsername || !bskyAppPassword) {
      console.warn(
        "Warning: BSKY_USERNAME or BSKY_APP_PASSWORD not found in environment variables. " +
          "Bluesky tools may not function properly.",
      );
    }

    // Update agent with tool environment variables
    await client.agents.modify(agentId, {
      toolExecEnvironmentVariables: {
        BSKY_USERNAME: bskyUsername || "",
        BSKY_APP_PASSWORD: bskyAppPassword || "",
        BSKY_SERVICE_URL: bskyServiceUrl || "https://bsky.social",
      },
    });
    console.log("✓ Tool environment variables configured");

    // Configure and attach required Bluesky tools
    console.log("\nConfiguring Bluesky tools...");

    // Discover tools from the filesystem
    const discoveredTools = await discoverBlueskyTools();
    console.log(
      `Discovered ${discoveredTools.length} tool(s) in tools/bluesky/`,
    );
    console.log(`Hardcoded required tools: ${REQUIRED_TOOLS.length}`);

    if (discoveredTools.length === 0 && REQUIRED_TOOLS.length === 0) {
      console.log("No tools configured.");
      console.log(
        "Add .py files to tools/bluesky/ or update REQUIRED_TOOLS array.",
      );
    }

    // Get currently attached tools
    const attachedTools = await client.agents.tools.list(agentId);
    const attachedToolNames = attachedTools.map((tool: any) => tool.name);
    console.log(`Agent has ${attachedTools.length} tools currently attached`);

    let toolsAttached = 0;
    let toolsCreated = 0;
    const missingTools: string[] = [];

    // 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"),
    });

    // First, process hardcoded required tools
    for (const toolName of REQUIRED_TOOLS) {
      try {
        // Check if already attached
        if (attachedToolNames.includes(toolName)) {
          console.log(`✓ Required tool already attached: ${toolName}`);
          continue;
        }

        // Search for the tool in the global registry
        const existingTools = await userLevelClient.tools.list({
          name: toolName,
        });

        if (existingTools.length > 0) {
          const tool = existingTools[0];
          if (tool.id) {
            await client.agents.tools.attach(agentId, tool.id);
            console.log(`✓ Attached required tool: ${toolName}`);
            toolsAttached++;
          }
        } else {
          console.warn(`⚠ Required tool not found in registry: ${toolName}`);
          missingTools.push(toolName);
        }
      } catch (error: any) {
        console.warn(
          `⚠ Error processing required tool ${toolName}:`,
          error.message,
        );
        missingTools.push(toolName);
      }
    }

    // Then, process tools discovered from files
    for (const toolFileName of discoveredTools) {
      const toolFilePath = `./tools/bluesky/${toolFileName}.py`;

      try {
        const toolSource = await Deno.readTextFile(toolFilePath);

        // Detect required pip packages from the source code
        const pipRequirements = detectPipRequirements(toolSource);
        if (pipRequirements.length > 0) {
          console.log(
            `  Detected pip requirements for ${toolFileName}: ${
              pipRequirements.map((r) => r.name).join(", ")
            }`,
          );
        }

        // Try to create or find the tool
        let tool;
        let wasCreated = false;

        try {
          // Attempt to create the tool - Letta will extract the function name from docstring
          const createParams: any = {
            sourceCode: toolSource,
          };

          // Add pip requirements if any were detected
          if (pipRequirements.length > 0) {
            createParams.pipRequirements = pipRequirements;
          }

          tool = await userLevelClient.tools.create(createParams);
          wasCreated = true;
        } catch (createError: any) {
          // Tool might already exist - try to find it
          // The error doesn't give us the tool name, so we'll need to parse it from the source
          const errorBody = typeof createError.body === "string"
            ? createError.body
            : JSON.stringify(createError.body || "");

          if (
            createError.statusCode === 409 ||
            errorBody.includes("already exists")
          ) {
            // Extract function name from Python source using regex
            const funcMatch = toolSource.match(/^def\s+(\w+)\s*\(/m);
            if (funcMatch) {
              const functionName = funcMatch[1];
              const existingTools = await userLevelClient.tools.list({
                name: functionName,
              });
              if (existingTools.length > 0) {
                tool = existingTools[0];
              }
            }
          }

          // If we still don't have the tool, rethrow the error
          if (!tool) {
            throw createError;
          }
        }

        const toolName = tool.name || toolFileName;

        // Check if tool is already attached to the agent
        if (attachedToolNames.includes(toolName)) {
          console.log(`✓ Tool already attached: ${toolName}`);
          continue;
        }

        // Attach the tool to the agent
        if (tool.id) {
          await client.agents.tools.attach(agentId, tool.id);
          if (wasCreated) {
            console.log(
              `✓ Created and attached tool: ${toolName} (from ${toolFileName}.py)`,
            );
            toolsCreated++;
          } else {
            console.log(
              `✓ Attached existing tool: ${toolName} (from ${toolFileName}.py)`,
            );
            toolsAttached++;
          }
        }
      } catch (error: any) {
        console.warn(`⚠ Error processing tool ${toolFileName}:`, error.message);
        console.warn(`   Attempted path: ${toolFilePath}`);
        missingTools.push(toolFileName);
      }
    }

    // Summary
    console.log("\n=== Tool Configuration Summary ===");
    console.log(`Attached existing tools: ${toolsAttached}`);
    console.log(`Created new tools: ${toolsCreated}`);
    console.log(
      `Total required tools: ${REQUIRED_TOOLS.length + discoveredTools.length}`,
    );

    if (missingTools.length > 0) {
      console.log(`\n⚠ Missing tools:`);
      missingTools.forEach((tool) => {
        if (REQUIRED_TOOLS.includes(tool)) {
          console.log(`  - ${tool} (required tool - not found in registry)`);
        } else {
          console.log(`  - ${tool} (from tools/bluesky/${tool}.py)`);
        }
      });
      console.log(
        "\nFor file-based tools, see tools/README.md for instructions.",
      );
      console.log(
        "For required tools, ensure they exist in your Letta registry.",
      );
    }

    console.log("\n✓ Agent successfully prepared for Bluesky");
    console.log(
      "✓ start checking for notifications with `deno task watch` during development  or `deno task start` in production",
    );
  } catch (error) {
    console.error("Error preparing agent for Bluesky:", error);
    throw error;
  }
}

// Run the function when this file is executed directly
if (import.meta.main) {
  await mount();
}