Enhance thread context retrieval with configurable max posts

prompts/quotePrompt.ts

···
 import { Notification } from "../utils/types.ts";
 import { doesUserFollowTarget } from "../utils/doesUserFollow.ts";
 import { agentContext } from "../utils/agentContext.ts";
-import { getCleanThread } from "../utils/getCleanThread.ts";
+import { getCleanThread, isThreadPost } from "../utils/getCleanThread.ts";
 
 export const quotePrompt = async (notification: Notification) => {
   const isUserFollower = await doesUserFollowTarget(
···
       quotes: undefined,
     }];
 
+  // Get the last post from each thread (last item is always a post, never a system message)
+  const lastOriginalPost = originalThread[originalThread.length - 1] as any;
+  const lastQuotePost = quotePostThread[quotePostThread.length - 1] as any;
+
   return `
 # NOTIFICATION: Someone quoted your post
 
···
 
 ## Your Original Post
 \`\`\`
-${originalThread[originalThread.length - 1].message}
+${lastOriginalPost.message}
 \`\`\`
 
 ## The Quote Post from @${notification.author.handle}
 \`\`\`
-${quotePostThread[quotePostThread.length - 1].message}
+${lastQuotePost.message}
 \`\`\`
 
 ## Quote Post Engagement
-• **Likes:** ${quotePostThread[quotePostThread.length - 1].likes}
-• **Replies:** ${quotePostThread[quotePostThread.length - 1].replies}
-• **Reposts:** ${quotePostThread[quotePostThread.length - 1].reposts}
-• **Quotes:** ${quotePostThread[quotePostThread.length - 1].quotes}
+• **Likes:** ${lastQuotePost.likes}
+• **Replies:** ${lastQuotePost.replies}
+• **Reposts:** ${lastQuotePost.reposts}
+• **Quotes:** ${lastQuotePost.quotes}
 
 ${
     originalThread

tasks/checkNotifications.ts

···
   claimTaskThread,
   releaseTaskThread,
 } from "../utils/agentContext.ts";
-import {
-  msFrom,
-  msRandomOffset,
-  msUntilNextWakeWindow,
-} from "../utils/time.ts";
+import { msFrom, msUntilNextWakeWindow } from "../utils/time.ts";
 import { bsky } from "../utils/bsky.ts";
 import { processNotification } from "../utils/processNotification.ts";
 

utils/agentContext.ts

···
   return (value / 100) + 1;
 };
 
+const getMaxThreadPosts = (): number => {
+  const value = Number(Deno.env.get("MAX_THREAD_POSTS"));
+
+  if (isNaN(value) || value < 5 || value > 250) {
+    return 2;
+  }
+
+  return Math.round(value);
+};
+
 const getReflectionDelayMinimum = (): number => {
   const value = msFrom.parse(Deno.env.get("REFLECTION_DELAY_MINIMUM"));
 
···
     timeZone: getTimeZone(),
     responsiblePartyType: getResponsiblePartyType(),
     preserveAgentMemory: getPreserveMemoryBlocks(),
+    maxThreadPosts: getMaxThreadPosts(),
     reflectionEnabled: setReflectionEnabled(),
     proactiveEnabled: setProactiveEnabled(),
     sleepEnabled: setSleepEnabled(),

utils/getCleanThread.ts

···
 import { bsky } from "./bsky.ts";
+import { agentContext } from "./agentContext.ts";
 
 type threadPost = {
   authorHandle: string;
···
   quotes: number;
 };
 
-export const getCleanThread = async (uri: string): Promise<threadPost[]> => {
+type threadTruncationIndicator = {
+  message: string;
+};
+
+type threadItem = threadPost | threadTruncationIndicator;
+
+export const getCleanThread = async (uri: string): Promise<threadItem[]> => {
   const res = await bsky.getPostThread({ uri: uri });
   const { thread } = res.data;
 
-  const postsThread: threadPost[] = [];
+  const postsThread: threadItem[] = [];
 
   // Type guard to check if thread is a ThreadViewPost
   if (thread && "post" in thread) {
···
     // Now traverse the parent chain
     if ("parent" in thread) {
       let current = thread.parent;
+      let postCount = 1; // Start at 1 for the main post
+      let wasTruncated = false;
 
-      while (current && "post" in current) {
+      // Collect up to configured limit of posts
+      while (current && "post" in current && postCount < agentContext.maxThreadPosts) {
         postsThread.push({
           authorHandle: `@${current.post.author.handle}`,
           message: (current.post.record as { text: string }).text,
···
           likes: current.post.likeCount ?? 0,
           quotes: current.post.quoteCount ?? 0,
         });
+        postCount++;
         current = "parent" in current ? current.parent : undefined;
       }
+
+      // Check if we stopped early (thread is longer than configured limit)
+      if (current && "post" in current) {
+        wasTruncated = true;
+
+        // Continue traversing to find the root post without collecting
+        while (current && "parent" in current) {
+          current = current.parent;
+        }
+
+        // Extract the root post
+        if (current && "post" in current) {
+          postsThread.push({
+            authorHandle: `@${current.post.author.handle}`,
+            message: (current.post.record as { text: string }).text,
+            uri: current.post.uri,
+            authorDID: current.post.author.did,
+            postedDateTime: (current.post.record as { createdAt: string }).createdAt,
+            bookmarks: current.post.bookmarkCount ?? 0,
+            replies: current.post.replyCount ?? 0,
+            reposts: current.post.repostCount ?? 0,
+            likes: current.post.likeCount ?? 0,
+            quotes: current.post.quoteCount ?? 0,
+          });
+        }
+      }
+
+      // Reverse and insert truncation indicator if needed
       postsThread.reverse();
+
+      if (wasTruncated) {
+        const limit = agentContext.maxThreadPosts;
+        const truncationIndicator: threadTruncationIndicator = {
+          message: `This thread exceeded ${limit} posts. This includes the ${limit} most recent posts and the root post that started the thread.`,
+        };
+        postsThread.splice(1, 0, truncationIndicator);
+      }
     }
   }
 
   return postsThread;
 };
+
+export const isThreadPost = (item: threadItem): item is threadPost => {
+  return "authorHandle" in item;
+};

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, maxValueLength = 30): string => {
+const formatArgsInline = (args: unknown, maxValueLength = 50): string => {
   try {
     const parsed = typeof args === "string" ? JSON.parse(args) : args;
     if (typeof parsed !== "object" || parsed === null) {
···
         let valueStr = typeof value === "object"
           ? JSON.stringify(value)
           : String(value);
-        // Truncate long values
+        // Truncate long values at word boundaries
         if (valueStr.length > maxValueLength) {
-          valueStr = valueStr.slice(0, maxValueLength) + "...";
+          const truncated = valueStr.slice(0, maxValueLength);
+          const lastSpace = truncated.lastIndexOf(" ");
+          // If we found a space in the last 30% of the truncated string, use it
+          valueStr = lastSpace > maxValueLength * 0.7
+            ? truncated.slice(0, lastSpace) + "..."
+            : truncated + "...";
         }
         return `${key}=${valueStr}`;
       })
···
   }
 };
 
+// Helper function to select important params for logging
+const selectImportantParams = (args: unknown): unknown => {
+  try {
+    const parsed = typeof args === "string" ? JSON.parse(args) : args;
+    if (typeof parsed !== "object" || parsed === null) {
+      return parsed;
+    }
+
+    const entries = Object.entries(parsed);
+
+    // Filter out URIs/DIDs and very long values
+    const filtered = entries.filter(([key, value]) => {
+      const str = String(value);
+      // Skip AT URIs and DIDs
+      if (str.includes("at://") || str.includes("did:plc:")) return false;
+      // Skip very long values
+      if (str.length > 60) return false;
+      return true;
+    });
+
+    // Take first 3, or first entry if none pass filters
+    const selected = filtered.length > 0
+      ? filtered.slice(0, 3)
+      : entries.slice(0, 1);
+
+    return Object.fromEntries(selected);
+  } catch {
+    return args;
+  }
+};
+
 // Helper function to format tool response for logging
 const formatToolResponse = (returnValue: string): string => {
   try {
···
       parsed = JSON.parse(pythonToJson);
     }
 
+    // Handle arrays - show count and sample first item
+    if (Array.isArray(parsed)) {
+      const count = parsed.length;
+      if (count === 0) return "[]";
+
+      const firstItem = parsed[0];
+      if (typeof firstItem === "object" && firstItem !== null) {
+        // Format first item's key fields (use 30 for samples to keep concise)
+        const sample = formatArgsInline(firstItem, 30);
+        return `[${count} items] ${sample}`;
+      }
+      return `[${count} items]`;
+    }
+
     // 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 (typeof parsed === "object" && parsed !== null) {
+      return `(${formatArgsInline(parsed, 50)})`;
     }
 
-    // If it's an array or primitive, return the original string
+    // If it's a primitive, return the original string
     return returnValue;
   } catch {
     // If parsing fails, return as-is (it's a simple string)
···
         const toolCall = response.tool_call || response.tool_calls;
         if (toolCall && toolCall.name) {
           lastToolName = toolCall.name;
-          const formattedArgs = formatArgsInline(toolCall.arguments);
+          const importantParams = selectImportantParams(toolCall.arguments);
+          const formattedArgs = formatArgsInline(importantParams);
           console.log(`🔧 tool called: ${toolCall.name} (${formattedArgs})`);
         }
       } else if (response.message_type === "tool_return_message") {
···
         const separator = formattedResponse.startsWith("(") ? " " : ": ";
         const logMessage = `↩️ tool response: ${lastToolName}${separator}${formattedResponse}`;
 
-        console.log(truncateString(logMessage, 80));
+        console.log(truncateString(logMessage, 300));
       } else if (response.message_type === "usage_statistics") {
         console.log(`🔢 total steps: ${response.step_count}`);
       } else if (response.message_type === "hidden_reasoning_message") {

utils/types.ts

···
   timeZone: string;
   responsiblePartyType: string; // person / organization
   preserveAgentMemory: boolean; // if true, mount won't update existing memory blocks
+  maxThreadPosts: number; // maximum number of posts to include in thread context
   // set automatically
   agentBskyDID: string;
   reflectionEnabled: boolean;