Merge pull request #10 from taurean/create-post-subsequent-filter

Create post subsequent filter

.env.example

···
 LETTA_API_KEY=
 LETTA_AGENT_ID=
-LETTA_PROJECT_NAME=
+LETTA_PROJECT_ID=
 BSKY_USERNAME=
 BSKY_APP_PASSWORD=
 RESPONSIBLE_PARTY_NAME=

tasks/checkNotifications.ts

···
       // marks all notifications that were processed as seen
       // based on time from when retrieved instead of finished
       await bsky.updateSeenNotifications(startedProcessingTime);
-
+      console.log(
+        `🔹 done processing ${unreadNotifications.length} notification${
+          unreadNotifications.length > 1 ? "s" : ""
+        }…`,
+      );
       // increases counter for notification processing session
       agentContext.processingCount++;
     } else {

tools/bluesky/create_bluesky_post.py

···
 
 
 def _check_is_self(agent_did: str, target_did: str) -> bool:
-    """Check 1: Self-Post Check (Free)."""
+    """Check 2: Self-Post Check (Free)."""
     return agent_did == target_did
 
 
···
         raise
 
 
+def _check_already_replied(client, agent_did: str, agent_handle: str, reply_to_uri: str) -> None:
+    """
+    Check 1: Duplicate Reply Prevention (Cheap - 1 API call).
+
+    Prevents agents from replying multiple times to the same message.
+    This check runs FIRST to block duplicates in ALL scenarios, including:
+    - Replies to the agent's own posts
+    - Replies to posts that mention the agent
+    - Any other reply scenario
+
+    Only checks direct replies, not deeper thread responses.
+
+    When duplicates are found, provides detailed information about existing
+    replies including URIs and content to help agents continue the conversation
+    appropriately.
+
+    Args:
+        client: Authenticated Bluesky client
+        agent_did: The agent's DID
+        agent_handle: The agent's handle (username)
+        reply_to_uri: URI of the post being replied to
+
+    Raises:
+        Exception: If agent has already replied directly to this message,
+                   with details about the existing reply(ies)
+    """
+    try:
+        # Fetch post with only direct replies (depth=1)
+        response = client.app.bsky.feed.get_post_thread({
+            'uri': reply_to_uri,
+            'depth': 1,          # Only direct replies
+            'parentHeight': 0    # Don't fetch parents (not needed)
+        })
+
+        # Validate response structure
+        if not hasattr(response, 'thread'):
+            return  # Can't verify, proceed
+
+        thread = response.thread
+        if not hasattr(thread, 'replies') or not thread.replies:
+            return  # No replies yet, proceed
+
+        # Collect all replies by this agent
+        agent_replies = []
+        for reply in thread.replies:
+            # Validate reply structure
+            if not hasattr(reply, 'post'):
+                continue
+            if not hasattr(reply.post, 'author'):
+                continue
+
+            # Found agent's reply
+            if reply.post.author.did == agent_did:
+                agent_replies.append(reply)
+
+        # If no duplicates found, proceed
+        if not agent_replies:
+            return
+
+        # Get the most recent reply (last in list)
+        # Note: Agents may have multiple replies if this issue happened before
+        most_recent = agent_replies[-1]
+        reply_post = most_recent.post
+        reply_text = reply_post.record.text if hasattr(reply_post.record, 'text') else "[text unavailable]"
+        reply_uri = reply_post.uri
+
+        # Extract rkey from URI for web URL
+        # URI format: at://did:plc:xyz/app.bsky.feed.post/rkey
+        rkey = reply_uri.split('/')[-1]
+        reply_url = f"https://bsky.app/profile/{agent_handle}/post/{rkey}"
+
+        # Handle multiple replies case
+        count_msg = ""
+        if len(agent_replies) > 1:
+            count_msg = f"\n\nNote: You have {len(agent_replies)} direct replies to this message. The most recent one is shown above."
+
+        # Construct detailed error message
+        error_msg = (
+            f"Message not sent: You have already replied directly to this message.{count_msg}\n\n"
+            f"Your previous reply:\n\"{reply_text}\"\n\n"
+            f"Reply URI: {reply_uri}\n"
+            f"Web link: {reply_url}\n\n"
+            f"Suggestions:\n"
+            f"1. If you want to add more to your existing reply, use the URI above to continue that thread.\n"
+            f"2. Make sure you're not repeating yourself - check what you already said before adding more.\n"
+            f"3. Consider replying to one of the responses to your reply instead.\n"
+            f"4. If you have something new to say, start a new top-level message with additional context."
+        )
+
+        raise Exception(error_msg)
+
+    except Exception as e:
+        # If it's our duplicate reply exception, raise it
+        if "already replied" in str(e):
+            raise e
+        # For other errors, re-raise to be caught by main error handler
+        raise
+
+
 def _check_thread_participation(client, agent_did: str, agent_handle: str, reply_to_uri: str) -> bool:
-    """Check 3 & 4: Thread Participation and Mention Check (Expensive)."""
+    """Check 5: Thread Participation and Mention Check (Expensive)."""
     try:
         # Fetch the thread
         # depth=100 should be sufficient for most contexts, or we can walk up manually if needed.
···
     Raises Exception with specific message if consent denied or verification fails.
     """
     try:
-        # Check 1: Self-Post
+        # Check 1: Duplicate Reply Prevention
+        # This check must run BEFORE any early returns to prevent duplicates in all scenarios
+        _check_already_replied(client, agent_did, agent_handle, reply_to_uri)
+
+        # Check 2: Self-Post
         if _check_is_self(agent_did, target_did):
             return True
 
-        # Check 2: Mention Check (Free/Cheap)
+        # Check 3: Mention Check (Free/Cheap)
         # If the post we are replying to mentions us, we can reply.
         if parent_post_record:
             # Check facets for mention
···
                     for feature in facet.features:
                         if hasattr(feature, 'did') and feature.did == agent_did:
                             return True
-            
+
             # Fallback: Check text for handle
             if hasattr(parent_post_record, 'text') and f"@{agent_handle}" in parent_post_record.text:
                 return True
 
-        # Check 3: Follow Check
+        # Check 4: Follow Check
         # Rule: Target must follow agent.
-        # Rule 3B: If root author is different from target, Root must ALSO follow agent.
+        # Rule 4B: If root author is different from target, Root must ALSO follow agent.
         
         target_follows = _check_follows(client, agent_did, target_did)
         
···
                     )
             return True
 
-        # Check 4: Thread Participation
+        # Check 5: Thread Participation
         # This requires fetching the thread (Expensive)
         if _check_thread_participation(client, agent_did, agent_handle, reply_to_uri):
             return True

utils/messageAgent.ts

···
 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 => {
+const formatArgsInline = (args: unknown, maxValueLength = 30): string => {
   try {
     const parsed = typeof args === "string" ? JSON.parse(args) : args;
     if (typeof parsed !== "object" || parsed === null) {
···
     }
     return Object.entries(parsed)
       .map(([key, value]) => {
-        const valueStr = typeof value === "object"
+        let valueStr = typeof value === "object"
           ? JSON.stringify(value)
           : String(value);
+        // Truncate long values
+        if (valueStr.length > maxValueLength) {
+          valueStr = valueStr.slice(0, maxValueLength) + "...";
+        }
         return `${key}=${valueStr}`;
       })
       .join(", ");
···
   return `${str.slice(0, maxLength)}... (truncated, ${str.length} total chars)`;
 };
 
+// Helper function to extract tool return value from wrapper structure
+const extractToolReturn = (toolReturns: unknown): string => {
+  try {
+    // If it's already a string, return it
+    if (typeof toolReturns === "string") {
+      return toolReturns;
+    }
+
+    // If it's an array, extract the tool_return from first element
+    if (Array.isArray(toolReturns) && toolReturns.length > 0) {
+      const firstReturn = toolReturns[0];
+      if (
+        typeof firstReturn === "object" &&
+        firstReturn !== null &&
+        "tool_return" in firstReturn
+      ) {
+        const toolReturn = firstReturn.tool_return;
+        // If tool_return is already a string, return it
+        if (typeof toolReturn === "string") {
+          return toolReturn;
+        }
+        // Otherwise stringify it
+        return JSON.stringify(toolReturn);
+      }
+    }
+
+    // Fallback: return stringified version of the whole thing
+    return JSON.stringify(toolReturns);
+  } catch {
+    return String(toolReturns);
+  }
+};
+
+// Helper function to format tool response for logging
+const formatToolResponse = (returnValue: string): string => {
+  try {
+    // Try to parse as JSON - handle both JSON and Python dict syntax
+    let parsed;
+    try {
+      // First try standard JSON
+      parsed = JSON.parse(returnValue);
+    } catch {
+      // Try to parse Python-style dict (with single quotes and None/True/False)
+      const pythonToJson = returnValue
+        .replace(/'/g, '"')
+        .replace(/\bNone\b/g, "null")
+        .replace(/\bTrue\b/g, "true")
+        .replace(/\bFalse\b/g, "false");
+      parsed = JSON.parse(pythonToJson);
+    }
+
+    // If parsed successfully and it's an object, format as key=value pairs
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      return `(${formatArgsInline(parsed, 30)})`;
+    }
+
+    // If it's an array or primitive, return the original string
+    return returnValue;
+  } catch {
+    // If parsing fails, return as-is (it's a simple string)
+    return returnValue;
+  }
+};
+
 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
···
       stream_tokens: true,
     });
 
+    let lastToolName = "";
+
     for await (const response of reachAgent) {
       if (response.message_type === "reasoning_message") {
         // console.log(`💭 reasoning…`);
       } else if (response.message_type === "assistant_message") {
         console.log(`💬 ${agentContext.agentBskyName}: ${response.content}`);
       } 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];
+        // Use tool_call (singular) or tool_calls (both are objects, not arrays)
+        const toolCall = response.tool_call || response.tool_calls;
+        if (toolCall && toolCall.name) {
+          lastToolName = toolCall.name;
           const formattedArgs = formatArgsInline(toolCall.arguments);
-          console.log(
-            `🗜️  tool called: ${toolCall.name} with args: ${formattedArgs}`,
-          );
+          console.log(`🔧 tool called: ${toolCall.name} (${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)}`);
+        const extractedReturn = extractToolReturn(response.tool_returns);
+        const formattedResponse = formatToolResponse(extractedReturn);
+
+        // Determine separator based on format
+        const separator = formattedResponse.startsWith("(") ? " " : ": ";
+        const logMessage = `↩️ tool response: ${lastToolName}${separator}${formattedResponse}`;
+
+        console.log(truncateString(logMessage, 80));
       } else if (response.message_type === "usage_statistics") {
         console.log(`🔢 total steps: ${response.step_count}`);
       } else if (response.message_type === "hidden_reasoning_message") {

utils/processNotification.ts

···
 } as const;
 
 export const processNotification = async (notification: Notification) => {
-  const agentProject = Deno.env.get("LETTA_PROJECT_NAME");
+  const agentName = agentContext.agentBskyName;
   const kind = notification.reason;
   const author = `@${notification.author.handle}`;
   const handler = notificationHandlers[kind];
···
     const prompt = await handler.promptFn(notification);
     await messageAgent(prompt);
     console.log(
-      `🔹 sent ${kind} notification from ${author} to ${agentProject}. moving on…`,
+      `🔹 sent ${kind} notification from ${author} to ${agentName}. moving on…`,
     );
   } catch (error) {
     console.log(