agentfeed 0.1.8 → 0.1.11

package/dist/mcp-server.js

@@ -71,6 +71,17 @@ const TOOLS = [
             required: ["post_id", "content"],
         },
     },
+    {
+        name: "agentfeed_download_file",
+        description: "Download a file from AgentFeed uploads. For images, returns the image so you can see it. Use this when content contains image URLs like ![name](/api/uploads/up_xxx.png)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                url: { type: "string", description: "File URL (e.g. /api/uploads/up_xxx.png or full URL)" },
+            },
+            required: ["url"],
+        },
+    },
     {
         name: "agentfeed_set_status",
         description: "Report agent status (thinking/idle)",
@@ -147,6 +158,32 @@ async function handleToolCall(name, args, ctx) {
             const comment = await res.json();
             return { content: [{ type: "text", text: `Comment posted: ${comment.id}` }] };
         }
+        case "agentfeed_download_file": {
+            const { url } = args;
+            // Resolve relative URLs to absolute
+            const fullUrl = url.startsWith("/") ? `${serverUrl}${url}` : url;
+            const fileRes = await fetch(fullUrl);
+            if (!fileRes.ok)
+                throw new Error(`Failed to download file: ${fileRes.status}`);
+            const contentType = fileRes.headers.get("content-type") || "application/octet-stream";
+            const isImage = contentType.startsWith("image/");
+            if (isImage) {
+                const buffer = await fileRes.arrayBuffer();
+                const base64 = Buffer.from(buffer).toString("base64");
+                return {
+                    content: [
+                        { type: "image", data: base64, mimeType: contentType },
+                    ],
+                };
+            }
+            // Non-image files: return metadata
+            const size = fileRes.headers.get("content-length") || "unknown";
+            return {
+                content: [
+                    { type: "text", text: `File downloaded: ${url}\nType: ${contentType}\nSize: ${size} bytes\n(Non-image files cannot be displayed inline)` },
+                ],
+            };
+        }
         case "agentfeed_set_status": {
             const { status, feed_id, post_id } = args;
             await client.setAgentStatus({ status, feed_id, post_id });

package/dist/post-session-store.d.ts

@@ -1,10 +1,20 @@
 import { PersistentStore } from "./persistent-store.js";
+import type { BackendType } from "./types.js";
+export interface PostSessionInfo {
+    backendType: BackendType;
+    sessionName: string;
+}
 export declare class PostSessionStore extends PersistentStore {
     private map;
     constructor(filePath?: string);
     protected serialize(): string;
     protected deserialize(raw: string): void;
+    /** Get raw sessionName (legacy compat — for callers that don't need backendType) */
     get(postId: string): string | undefined;
-    set(postId: string, sessionName: string): void;
+    /** Get both backendType and sessionName. Legacy values without colon default to claude. */
+    getWithType(postId: string): PostSessionInfo | undefined;
+    private static readonly MAX_SIZE;
+    /** Store as "backendType:sessionName" */
+    set(postId: string, backendType: BackendType, sessionName: string): void;
     removeBySessionName(sessionName: string): void;
 }

package/dist/post-session-store.js

@@ -14,16 +14,53 @@ export class PostSessionStore extends PersistentStore {
             this.map.set(k, v);
         }
     }
+    /** Get raw sessionName (legacy compat — for callers that don't need backendType) */
     get(postId) {
-        return this.map.get(postId);
+        const raw = this.map.get(postId);
+        if (!raw)
+            return undefined;
+        // Parse "backendType:sessionName" or plain "sessionName"
+        const colonIdx = raw.indexOf(":");
+        return colonIdx >= 0 ? raw.slice(colonIdx + 1) : raw;
     }
-    set(postId, sessionName) {
-        this.map.set(postId, sessionName);
+    /** Get both backendType and sessionName. Legacy values without colon default to claude. */
+    getWithType(postId) {
+        const raw = this.map.get(postId);
+        if (!raw)
+            return undefined;
+        const colonIdx = raw.indexOf(":");
+        if (colonIdx >= 0) {
+            return {
+                backendType: raw.slice(0, colonIdx),
+                sessionName: raw.slice(colonIdx + 1),
+            };
+        }
+        // Legacy: no colon → assume claude
+        return { backendType: "claude", sessionName: raw };
+    }
+    static MAX_SIZE = 1000;
+    /** Store as "backendType:sessionName" */
+    set(postId, backendType, sessionName) {
+        this.map.set(postId, `${backendType}:${sessionName}`);
+        // Evict oldest entries if over limit
+        if (this.map.size > PostSessionStore.MAX_SIZE) {
+            const iter = this.map.keys();
+            while (this.map.size > PostSessionStore.MAX_SIZE) {
+                const oldest = iter.next().value;
+                if (oldest !== undefined)
+                    this.map.delete(oldest);
+                else
+                    break;
+            }
+        }
         this.save();
     }
     removeBySessionName(sessionName) {
         let changed = false;
-        for (const [postId, name] of this.map) {
+        for (const [postId, raw] of this.map) {
+            // Match both "backendType:sessionName" and legacy "sessionName"
+            const colonIdx = raw.indexOf(":");
+            const name = colonIdx >= 0 ? raw.slice(colonIdx + 1) : raw;
             if (name === sessionName) {
                 this.map.delete(postId);
                 changed = true;

package/dist/processor.d.ts

@@ -0,0 +1,21 @@
+import { AgentFeedClient } from "./api-client.js";
+import { FollowStore } from "./follow-store.js";
+import { QueueStore } from "./queue-store.js";
+import { PostSessionStore } from "./post-session-store.js";
+import { AgentRegistryStore } from "./agent-registry-store.js";
+import type { TriggerContext, PermissionMode, BackendType, BackendAgent } from "./types.js";
+export interface ProcessorDeps {
+    client: AgentFeedClient;
+    apiKey: string;
+    serverUrl: string;
+    permissionMode: PermissionMode;
+    extraAllowedTools: string[];
+    backendAgentMap: Map<BackendType, BackendAgent>;
+    backendAgents: BackendAgent[];
+    followStore: FollowStore;
+    queueStore: QueueStore;
+    postSessionStore: PostSessionStore;
+    agentRegistry: AgentRegistryStore;
+    ensureSessionAgent: (sessionName: string, agentName: string, backendType: BackendType) => Promise<string>;
+}
+export declare function handleTriggers(triggers: TriggerContext[], deps: ProcessorDeps): void;

package/dist/processor.js

@@ -0,0 +1,170 @@
+import { invokeAgent } from "./invoker.js";
+import { scanUnprocessed } from "./scanner.js";
+const MAX_WAKE_ATTEMPTS = 3;
+const MAX_CRASH_RETRIES = 3;
+const AGENT_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
+const MAX_CONCURRENT = 5;
+const MAX_BOT_MENTIONS_PER_POST = 4;
+const wakeAttempts = new Map();
+const botMentionCounts = new Map();
+const runningKeys = new Set();
+// Periodic cleanup to prevent memory growth
+setInterval(() => { wakeAttempts.clear(); botMentionCounts.clear(); }, 10 * 60 * 1000);
+function triggerKey(t) {
+    return `${t.backendType}:${t.sessionName}`;
+}
+export function handleTriggers(triggers, deps) {
+    for (const t of triggers) {
+        // Prevent bot-to-bot mention loops
+        if (t.authorIsBot && t.triggerType === "mention") {
+            const count = botMentionCounts.get(t.postId) ?? 0;
+            if (count >= MAX_BOT_MENTIONS_PER_POST) {
+                console.log(`Skipping bot mention on ${t.postId}: loop limit (${MAX_BOT_MENTIONS_PER_POST}) reached`);
+                continue;
+            }
+            botMentionCounts.set(t.postId, count + 1);
+        }
+        deps.queueStore.push(t);
+        console.log(`Queued trigger: ${t.triggerType} on ${t.postId} [${t.backendType}] (queue size: ${deps.queueStore.size})`);
+    }
+    scheduleQueue(deps);
+}
+function scheduleQueue(deps) {
+    const queued = deps.queueStore.drain();
+    if (queued.length === 0)
+        return;
+    const toRun = [];
+    for (const t of queued) {
+        const attempts = wakeAttempts.get(t.eventId) ?? 0;
+        if (attempts >= MAX_WAKE_ATTEMPTS) {
+            console.log(`Skipping ${t.eventId}: max wake attempts reached`);
+            continue;
+        }
+        const key = triggerKey(t);
+        if (runningKeys.size >= MAX_CONCURRENT || runningKeys.has(key)) {
+            // Same backend+session already running — re-queue
+            deps.queueStore.push(t);
+        }
+        else {
+            toRun.push(t);
+            runningKeys.add(key);
+        }
+    }
+    for (const trigger of toRun) {
+        processItem(trigger, deps).catch((err) => {
+            console.error(`Error processing ${trigger.postId}:`, err);
+        });
+    }
+}
+async function processItem(trigger, deps) {
+    const key = triggerKey(trigger);
+    wakeAttempts.set(trigger.eventId, (wakeAttempts.get(trigger.eventId) ?? 0) + 1);
+    const ba = deps.backendAgentMap.get(trigger.backendType);
+    if (!ba) {
+        console.warn(`No backend for ${trigger.backendType}, skipping`);
+        runningKeys.delete(key);
+        scheduleQueue(deps);
+        return;
+    }
+    try {
+        // Auto-follow thread on mention
+        if (trigger.triggerType === "mention") {
+            deps.followStore.add(trigger.postId);
+            console.log(`Following thread: ${trigger.postId}`);
+        }
+        const sessionAgentId = await deps.ensureSessionAgent(trigger.sessionName, ba.agent.name, ba.backendType);
+        const recentContext = await fetchContext(trigger, deps);
+        console.log(`Waking agent for: ${trigger.triggerType} on ${trigger.postId} [${trigger.backendType}] (session: ${trigger.sessionName}, agentId: ${sessionAgentId})`);
+        await deps.client.setAgentStatus({
+            status: "thinking",
+            feed_id: trigger.feedId,
+            post_id: trigger.postId,
+        }, sessionAgentId);
+        // Server config overrides CLI args
+        const effectivePermission = ba.config?.permission_mode ?? deps.permissionMode;
+        const effectiveTools = ba.config?.allowed_tools?.length
+            ? ba.config.allowed_tools
+            : deps.extraAllowedTools;
+        const effectiveModel = ba.config?.model;
+        let retries = 0;
+        let success = false;
+        try {
+            while (retries < MAX_CRASH_RETRIES) {
+                try {
+                    const result = await invokeAgent(ba.backend, {
+                        agent: ba.agent,
+                        trigger,
+                        apiKey: deps.apiKey,
+                        serverUrl: deps.serverUrl,
+                        recentContext,
+                        permissionMode: effectivePermission,
+                        extraAllowedTools: effectiveTools,
+                        model: effectiveModel ?? undefined,
+                        sessionId: ba.sessionStore.get(trigger.sessionName),
+                        agentId: sessionAgentId,
+                        timeoutMs: AGENT_TIMEOUT_MS,
+                    });
+                    if (result.sessionId) {
+                        ba.sessionStore.set(trigger.sessionName, result.sessionId);
+                        deps.postSessionStore.set(trigger.postId, trigger.backendType, trigger.sessionName);
+                        await deps.client.reportSession(trigger.sessionName, result.sessionId, sessionAgentId).catch((err) => {
+                            console.warn("Failed to report session:", err);
+                        });
+                    }
+                    if (result.exitCode === 0) {
+                        success = true;
+                        break;
+                    }
+                    if (result.exitCode !== 0 && ba.sessionStore.get(trigger.sessionName)) {
+                        console.log("Session may be stale, clearing and retrying as new session...");
+                        ba.sessionStore.delete(trigger.sessionName);
+                    }
+                    console.error(`Agent exited with code ${result.exitCode}, retry ${retries + 1}/${MAX_CRASH_RETRIES}`);
+                }
+                catch (err) {
+                    console.error("Agent invocation error:", err);
+                }
+                retries++;
+            }
+            if (!success) {
+                console.error(`Agent failed after ${MAX_CRASH_RETRIES} retries`);
+            }
+        }
+        finally {
+            await deps.client.setAgentStatus({
+                status: "idle",
+                feed_id: trigger.feedId,
+                post_id: trigger.postId,
+            }, sessionAgentId);
+        }
+    }
+    finally {
+        runningKeys.delete(key);
+        // Post-completion: re-scan for items that arrived during execution
+        try {
+            const currentOwnIds = deps.agentRegistry.getAllIds();
+            const newUnprocessed = await scanUnprocessed(deps.client, deps.backendAgents, deps.followStore, deps.postSessionStore, currentOwnIds);
+            for (const t of newUnprocessed) {
+                deps.queueStore.push(t);
+            }
+            if (newUnprocessed.length > 0) {
+                console.log(`Post-completion scan: ${newUnprocessed.length} item(s) added to queue`);
+            }
+        }
+        catch (err) {
+            console.error("Post-completion scan error:", err);
+        }
+        scheduleQueue(deps);
+    }
+}
+async function fetchContext(trigger, deps) {
+    try {
+        const comments = await deps.client.getPostComments(trigger.postId, { limit: 10 });
+        return comments.data
+            .map((c) => `[${c.author_type}${c.author_name ? ` (${c.author_name})` : ""}] ${c.content}`)
+            .join("\n");
+    }
+    catch {
+        return "";
+    }
+}

package/dist/queue-store.js

@@ -15,8 +15,8 @@ export class QueueStore extends PersistentStore {
         // Deduplicate by eventId
         if (this.queue.some((t) => t.eventId === trigger.eventId))
             return;
-        // Deduplicate by postId — keep only the latest trigger per post
-        this.queue = this.queue.filter((t) => t.postId !== trigger.postId);
+        // Deduplicate by (postId, backendType) — keep only the latest trigger per post per backend
+        this.queue = this.queue.filter((t) => !(t.postId === trigger.postId && t.backendType === trigger.backendType));
         this.queue.push(trigger);
         this.save();
     }

package/dist/scanner.d.ts

@@ -1,5 +1,5 @@
-import type { AgentInfo, TriggerContext } from "./types.js";
+import type { TriggerContext, BackendAgent } from "./types.js";
 import type { AgentFeedClient } from "./api-client.js";
 import type { FollowStore } from "./follow-store.js";
 import type { PostSessionStore } from "./post-session-store.js";
-export declare function scanUnprocessed(client: AgentFeedClient, agent: AgentInfo, followStore?: FollowStore, postSessionStore?: PostSessionStore): Promise<TriggerContext[]>;
+export declare function scanUnprocessed(client: AgentFeedClient, backendAgents: BackendAgent[], followStore?: FollowStore, postSessionStore?: PostSessionStore, ownAgentIds?: Set<string>): Promise<TriggerContext[]>;

package/dist/scanner.js

@@ -1,8 +1,10 @@
 import { parseMention, isBotAuthor } from "./utils.js";
-export async function scanUnprocessed(client, agent, followStore, postSessionStore) {
+export async function scanUnprocessed(client, backendAgents, followStore, postSessionStore, ownAgentIds) {
     const triggers = [];
     const feeds = await client.getFeeds();
     const processedPostIds = new Set();
+    const isOwnAgent = (id) => id !== null && (ownAgentIds ? ownAgentIds.has(id) : false);
+    const defaultBackendType = backendAgents[0]?.backendType ?? "claude";
     for (const feed of feeds) {
         // --- Scan comments (existing logic) ---
         const comments = await client.getFeedComments(feed.id, {
@@ -21,27 +23,35 @@ export async function scanUnprocessed(client, agent, followStore, postSessionSto
             let bestTriggerType = null;
             let bestComment = null;
             let bestSessionName = "default";
+            let bestBackendType = defaultBackendType;
             for (const comment of postComments) {
-                // Check for @mentions (highest priority)
-                const mention = parseMention(comment.content, agent.name);
-                if (mention.mentioned) {
-                    bestTriggerType = "mention";
-                    bestComment = comment;
-                    bestSessionName = mention.sessionName;
+                // Check for @mentions across all backend agents (highest priority)
+                for (const ba of backendAgents) {
+                    const mention = parseMention(comment.content, ba.agent.name);
+                    if (mention.mentioned) {
+                        bestTriggerType = "mention";
+                        bestComment = comment;
+                        bestSessionName = mention.sessionName;
+                        bestBackendType = ba.backendType;
+                    }
                 }
                 // Check if this is on an agent-owned post
-                if (!bestTriggerType && comment.post_created_by === agent.id) {
+                if (!bestTriggerType && isOwnAgent(comment.post_created_by)) {
+                    const postSession = postSessionStore?.getWithType(postId);
                     bestTriggerType = "own_post_comment";
                     bestComment = comment;
-                    bestSessionName = postSessionStore?.get(postId) ?? "default";
+                    bestSessionName = postSession?.sessionName ?? "default";
+                    bestBackendType = postSession?.backendType ?? defaultBackendType;
                 }
             }
             // Check if this is in a followed thread
             if (!bestTriggerType && followStore?.has(postId)) {
+                const postSession = postSessionStore?.getWithType(postId);
                 bestTriggerType = "thread_follow_up";
                 // Use the last human comment as the trigger
                 bestComment = postComments[postComments.length - 1] ?? null;
-                bestSessionName = postSessionStore?.get(postId) ?? "default";
+                bestSessionName = postSession?.sessionName ?? "default";
+                bestBackendType = postSession?.backendType ?? defaultBackendType;
             }
             if (!bestTriggerType || !bestComment)
                 continue;
@@ -61,7 +71,9 @@ export async function scanUnprocessed(client, agent, followStore, postSessionSto
                     postId,
                     content: bestComment.content,
                     authorName: bestComment.author_name,
+                    authorIsBot: false,
                     sessionName: bestSessionName,
+                    backendType: bestBackendType,
                 });
                 processedPostIds.add(postId);
             }
@@ -78,25 +90,31 @@ export async function scanUnprocessed(client, agent, followStore, postSessionSto
             // Skip posts without content
             if (!post.content)
                 continue;
-            const mention = parseMention(post.content, agent.name);
-            if (!mention.mentioned)
-                continue;
-            // Check if there's any bot reply on this post
-            const botReplies = await client.getPostComments(post.id, {
-                author_type: "bot",
-                limit: 1,
-            });
-            if (botReplies.data.length === 0) {
-                triggers.push({
-                    triggerType: "mention",
-                    eventId: post.id,
-                    feedId: feed.id,
-                    feedName: feed.name,
-                    postId: post.id,
-                    content: post.content,
-                    authorName: post.author_name,
-                    sessionName: mention.sessionName,
+            // Try mentions across all backend agents
+            for (const ba of backendAgents) {
+                const mention = parseMention(post.content, ba.agent.name);
+                if (!mention.mentioned)
+                    continue;
+                // Check if there's any bot reply on this post
+                const botReplies = await client.getPostComments(post.id, {
+                    author_type: "bot",
+                    limit: 1,
                 });
+                if (botReplies.data.length === 0) {
+                    triggers.push({
+                        triggerType: "mention",
+                        eventId: post.id,
+                        feedId: feed.id,
+                        feedName: feed.name,
+                        postId: post.id,
+                        content: post.content,
+                        authorName: post.author_name,
+                        authorIsBot: false,
+                        sessionName: mention.sessionName,
+                        backendType: ba.backendType,
+                    });
+                }
+                break; // First matching backend wins for this post
             }
         }
     }

package/dist/session-store.d.ts

@@ -7,4 +7,5 @@ export declare class SessionStore extends PersistentStore {
     get(postId: string): string | undefined;
     set(postId: string, sessionId: string): void;
     delete(postId: string): void;
+    keys(): string[];
 }

package/dist/session-store.js

@@ -25,4 +25,7 @@ export class SessionStore extends PersistentStore {
         this.map.delete(postId);
         this.save();
     }
+    keys() {
+        return Array.from(this.map.keys());
+    }
 }

package/dist/sse-client.d.ts

@@ -6,4 +6,4 @@ export interface SSEEvent {
 export interface SSEConnection {
     close: () => void;
 }
-export declare function connectSSE(url: string, apiKey: string, agentId: string | undefined, onEvent: (event: SSEEvent) => void, onError: (error: Error) => void): SSEConnection;
+export declare function connectSSE(url: string, apiKey: string, agentIds: string[], onEvent: (event: SSEEvent) => void, onError: (error: Error) => void): SSEConnection;

package/dist/sse-client.js

@@ -3,7 +3,7 @@ const EVENT_TYPES = ["heartbeat", "post_created", "comment_created", "session_de
 const BACKOFF_INITIAL_MS = 1_000;
 const BACKOFF_MAX_MS = 60_000;
 const BACKOFF_RESET_AFTER_MS = 30_000;
-export function connectSSE(url, apiKey, agentId, onEvent, onError) {
+export function connectSSE(url, apiKey, agentIds, onEvent, onError) {
     let closed = false;
     let currentEs = null;
     let backoffMs = BACKOFF_INITIAL_MS;
@@ -14,13 +14,17 @@ export function connectSSE(url, apiKey, agentId, onEvent, onError) {
     function connect() {
         if (closed)
             return;
-        const es = new EventSource(url, {
+        // Pass all agent IDs as query parameter for multi-agent online tracking
+        const connectUrl = new URL(url);
+        if (agentIds.length > 0) {
+            connectUrl.searchParams.set("agents", agentIds.join(","));
+        }
+        const es = new EventSource(connectUrl.toString(), {
             fetch: (input, init) => fetch(input, {
                 ...init,
                 headers: {
                     ...init.headers,
                     Authorization: `Bearer ${apiKey}`,
-                    ...(agentId ? { "X-Agent-Id": agentId } : {}),
                 },
             }),
         });

package/dist/trigger.d.ts

@@ -1,4 +1,4 @@
 import type { FollowStore } from "./follow-store.js";
 import type { PostSessionStore } from "./post-session-store.js";
-import type { GlobalEvent, TriggerContext, AgentInfo } from "./types.js";
-export declare function detectTrigger(event: GlobalEvent, agent: AgentInfo, followStore?: FollowStore, postSessionStore?: PostSessionStore): TriggerContext | null;
+import type { GlobalEvent, TriggerContext, BackendAgent } from "./types.js";
+export declare function detectTriggers(event: GlobalEvent, backendAgents: BackendAgent[], followStore?: FollowStore, postSessionStore?: PostSessionStore, ownAgentIds?: Set<string>): TriggerContext[];