agentfeed 0.1.7 → 0.1.10

package/dist/processor.js

@@ -0,0 +1,168 @@
+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;
+        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,
+                        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,4 +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";
-export declare function scanUnprocessed(client: AgentFeedClient, agent: AgentInfo, followStore?: FollowStore): Promise<TriggerContext[]>;
+import type { PostSessionStore } from "./post-session-store.js";
+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 { containsMention } from "./utils.js";
-export async function scanUnprocessed(client, agent, followStore) {
+import { parseMention, isBotAuthor } from "./utils.js";
+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, {
@@ -20,23 +22,36 @@ export async function scanUnprocessed(client, agent, followStore) {
             // Determine the best trigger type for this post
             let bestTriggerType = null;
             let bestComment = null;
+            let bestSessionName = "default";
+            let bestBackendType = defaultBackendType;
             for (const comment of postComments) {
-                // Check for @mentions (highest priority)
-                if (containsMention(comment.content, agent.name)) {
-                    bestTriggerType = "mention";
-                    bestComment = comment;
+                // 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 = 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 = postSession?.sessionName ?? "default";
+                bestBackendType = postSession?.backendType ?? defaultBackendType;
             }
             if (!bestTriggerType || !bestComment)
                 continue;
@@ -56,37 +71,50 @@ export async function scanUnprocessed(client, agent, followStore) {
                     postId,
                     content: bestComment.content,
                     authorName: bestComment.author_name,
+                    authorIsBot: false,
+                    sessionName: bestSessionName,
+                    backendType: bestBackendType,
                 });
                 processedPostIds.add(postId);
             }
         }
-        // --- Scan post bodies for @mentions (new logic) ---
+        // --- Scan post bodies for @mentions ---
         const posts = await client.getFeedPosts(feed.id, { limit: 50 });
         for (const post of posts.data) {
             // Skip posts already handled by comment scan
             if (processedPostIds.has(post.id))
                 continue;
             // Skip bot-authored posts
-            if (post.created_by.startsWith("af_"))
+            if (isBotAuthor(post.created_by))
                 continue;
-            // Skip posts without content or without @mention
-            if (!post.content || !containsMention(post.content, agent.name))
+            // Skip posts without content
+            if (!post.content)
                 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,
+            // 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, 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

@@ -1,9 +1,9 @@
 import { EventSource } from "eventsource";
-const EVENT_TYPES = ["heartbeat", "post_created", "comment_created"];
+const EVENT_TYPES = ["heartbeat", "post_created", "comment_created", "session_deleted"];
 const BACKOFF_INITIAL_MS = 1_000;
 const BACKOFF_MAX_MS = 60_000;
 const BACKOFF_RESET_AFTER_MS = 30_000;
-export function connectSSE(url, apiKey, onEvent, onError) {
+export function connectSSE(url, apiKey, agentIds, onEvent, onError) {
     let closed = false;
     let currentEs = null;
     let backoffMs = BACKOFF_INITIAL_MS;
@@ -14,10 +14,18 @@ export function connectSSE(url, apiKey, 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}` },
+                headers: {
+                    ...init.headers,
+                    Authorization: `Bearer ${apiKey}`,
+                },
             }),
         });
         currentEs = es;

package/dist/trigger.d.ts

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

package/dist/trigger.js

@@ -1,56 +1,91 @@
-import { containsMention } from "./utils.js";
-export function detectTrigger(event, agent, followStore) {
+import { parseMention, isBotAuthor } from "./utils.js";
+export function detectTriggers(event, backendAgents, followStore, postSessionStore, ownAgentIds) {
+    const isOwnAgent = (id) => id !== null && (ownAgentIds ? ownAgentIds.has(id) : false);
+    const defaultBackendType = backendAgents[0]?.backendType ?? "claude";
     if (event.type === "comment_created") {
-        // Trigger 1: Comment on own post
-        if (event.post_created_by === agent.id) {
-            return {
-                triggerType: "own_post_comment",
-                eventId: event.id,
-                feedId: event.feed_id,
-                feedName: "",
-                postId: event.post_id,
-                content: event.content,
-                authorName: event.author_name,
-            };
+        const authorIsOwnBot = isOwnAgent(event.created_by);
+        // Trigger 1: Comment on own post (human-authored only — prevents bot loop)
+        if (!authorIsOwnBot && isOwnAgent(event.post_created_by)) {
+            const postSession = postSessionStore?.getWithType(event.post_id);
+            return [{
+                    triggerType: "own_post_comment",
+                    eventId: event.id,
+                    feedId: event.feed_id,
+                    feedName: "",
+                    postId: event.post_id,
+                    content: event.content,
+                    authorName: event.author_name,
+                    authorIsBot: event.author_type === "bot",
+                    sessionName: postSession?.sessionName ?? "default",
+                    backendType: postSession?.backendType ?? defaultBackendType,
+                }];
         }
-        // Trigger 2: @mention in comment
-        if (containsMention(event.content, agent.name)) {
-            return {
-                triggerType: "mention",
-                eventId: event.id,
-                feedId: event.feed_id,
-                feedName: "",
-                postId: event.post_id,
-                content: event.content,
-                authorName: event.author_name,
-            };
+        // Trigger 2: @mention in comment — collect ALL matching agents
+        const mentions = [];
+        for (const ba of backendAgents) {
+            if (event.created_by === ba.agent.id)
+                continue; // skip self-mention
+            const mention = parseMention(event.content, ba.agent.name);
+            if (mention.mentioned) {
+                mentions.push({
+                    triggerType: "mention",
+                    eventId: `${event.id}:${ba.backendType}`,
+                    feedId: event.feed_id,
+                    feedName: "",
+                    postId: event.post_id,
+                    content: event.content,
+                    authorName: event.author_name,
+                    authorIsBot: event.author_type === "bot",
+                    sessionName: mention.sessionName,
+                    backendType: ba.backendType,
+                });
+            }
         }
-        // Trigger 3: Comment in a followed thread
-        if (followStore?.has(event.post_id)) {
-            return {
-                triggerType: "thread_follow_up",
-                eventId: event.id,
-                feedId: event.feed_id,
-                feedName: "",
-                postId: event.post_id,
-                content: event.content,
-                authorName: event.author_name,
-            };
+        if (mentions.length > 0)
+            return mentions;
+        // Trigger 3: Comment in a followed thread (human-authored only — prevents bot loop)
+        if (!authorIsOwnBot && followStore?.has(event.post_id)) {
+            const postSession = postSessionStore?.getWithType(event.post_id);
+            return [{
+                    triggerType: "thread_follow_up",
+                    eventId: event.id,
+                    feedId: event.feed_id,
+                    feedName: "",
+                    postId: event.post_id,
+                    content: event.content,
+                    authorName: event.author_name,
+                    authorIsBot: event.author_type === "bot",
+                    sessionName: postSession?.sessionName ?? "default",
+                    backendType: postSession?.backendType ?? defaultBackendType,
+                }];
         }
     }
     if (event.type === "post_created") {
-        // @mention in post content
-        if (event.content && containsMention(event.content, agent.name)) {
-            return {
-                triggerType: "mention",
-                eventId: event.id,
-                feedId: event.feed_id,
-                feedName: event.feed_name,
-                postId: event.id,
-                content: event.content,
-                authorName: event.author_name,
-            };
+        // @mention in post content — collect ALL matching agents
+        if (event.content) {
+            const mentions = [];
+            for (const ba of backendAgents) {
+                if (event.created_by === ba.agent.id)
+                    continue;
+                const mention = parseMention(event.content, ba.agent.name);
+                if (mention.mentioned) {
+                    mentions.push({
+                        triggerType: "mention",
+                        eventId: `${event.id}:${ba.backendType}`,
+                        feedId: event.feed_id,
+                        feedName: event.feed_name,
+                        postId: event.id,
+                        content: event.content,
+                        authorName: event.author_name,
+                        authorIsBot: isBotAuthor(event.created_by),
+                        sessionName: mention.sessionName,
+                        backendType: ba.backendType,
+                    });
+                }
+            }
+            if (mentions.length > 0)
+                return mentions;
         }
     }
-    return null;
+    return [];
 }

package/dist/types.d.ts

@@ -1,8 +1,21 @@
+import type { CLIBackend } from "./backends/types.js";
+import type { SessionStore } from "./session-store.js";
 export interface AgentInfo {
     id: string;
     name: string;
     type: string;
 }
+export interface AgentConfig {
+    permission_mode: PermissionMode;
+    allowed_tools: string[];
+}
+export interface BackendAgent {
+    backendType: BackendType;
+    backend: CLIBackend;
+    agent: AgentInfo;
+    sessionStore: SessionStore;
+    config?: AgentConfig;
+}
 export interface GlobalPostEvent {
     type: "post_created";
     id: string;
@@ -25,7 +38,13 @@ export interface GlobalCommentEvent {
     created_at: string;
     post_created_by: string | null;
 }
-export type GlobalEvent = GlobalPostEvent | GlobalCommentEvent;
+export interface GlobalSessionDeletedEvent {
+    type: "session_deleted";
+    agent_id: string;
+    agent_name: string;
+    session_name: string;
+}
+export type GlobalEvent = GlobalPostEvent | GlobalCommentEvent | GlobalSessionDeletedEvent;
 export interface TriggerContext {
     triggerType: "own_post_comment" | "mention" | "thread_follow_up";
     eventId: string;
@@ -34,6 +53,9 @@ export interface TriggerContext {
     postId: string;
     content: string;
     authorName: string | null;
+    authorIsBot: boolean;
+    sessionName: string;
+    backendType: BackendType;
 }
 export interface FeedItem {
     id: string;
@@ -73,3 +95,4 @@ export interface PaginatedResponse<T> {
     has_more: boolean;
 }
 export type PermissionMode = "safe" | "yolo";
+export type BackendType = "claude" | "codex" | "gemini";

package/dist/utils.d.ts

@@ -1 +1,8 @@
+export interface MentionMatch {
+    mentioned: boolean;
+    sessionName: string;
+}
+export declare function parseMention(text: string, agentName: string): MentionMatch;
 export declare function containsMention(text: string, agentName: string): boolean;
+/** Check if created_by belongs to a bot (API key or registered agent) */
+export declare function isBotAuthor(createdBy: string | null | undefined): boolean;

package/dist/utils.js

@@ -1,5 +1,15 @@
-export function containsMention(text, agentName) {
+export function parseMention(text, agentName) {
     const escaped = agentName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const regex = new RegExp(`@${escaped}\\b`, "i");
-    return regex.test(text);
+    const regex = new RegExp(`@${escaped}(?:/([a-zA-Z0-9_-]+))?\\b`, "i");
+    const match = regex.exec(text);
+    if (!match)
+        return { mentioned: false, sessionName: "default" };
+    return { mentioned: true, sessionName: match[1] ?? "default" };
+}
+export function containsMention(text, agentName) {
+    return parseMention(text, agentName).mentioned;
+}
+/** Check if created_by belongs to a bot (API key or registered agent) */
+export function isBotAuthor(createdBy) {
+    return createdBy?.startsWith("af_") === true || createdBy?.startsWith("ag_") === true;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentfeed",
-  "version": "0.1.7",
+  "version": "0.1.10",
   "description": "Worker daemon for AgentFeed - watches feeds and wakes AI agents via claude -p",
   "type": "module",
   "bin": {
@@ -12,7 +12,20 @@
   ],
   "scripts": {
     "build": "tsc",
-    "dev": "tsx src/index.ts"
+    "dev": "tsx --env-file=../../.env.local src/index.ts"
+  },
+  "keywords": [
+    "ai-agent",
+    "feed",
+    "claude",
+    "mcp",
+    "sse"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/daige-st/agentfeed.git",
+    "directory": "packages/worker"
   },
   "engines": {
     "node": ">=18"
@@ -23,6 +36,7 @@
     "typescript": "^5"
   },
   "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.26.0",
     "eventsource": "^4.1.0"
   }
 }