@taico/worker 0.0.3 → 0.0.5

package/README.md

@@ -8,9 +8,10 @@ The worker is a Node.js process that:
 
 1. Connects to the backend via REST API and WebSocket.
 2. Listens for task events that match the agent's status and tag triggers.
-3. When a matching task appears, it clones the project's git repo (if configured) into a clean workspace.
-4. Spins up the appropriate agent harness (Claude, OpenCode, ADK, or GitHub Copilot).
-5. The agent works on the task, posting comments and status updates back to the backend.
+3. Runs a heartbeat reconcile loop that polls recent tasks and re-evaluates readiness.
+4. When a matching task appears, it clones the project's git repo (if configured) into a clean workspace.
+5. Spins up the appropriate agent harness (Claude, OpenCode, ADK, or GitHub Copilot).
+6. The agent works on the task, posting comments and status updates back to the backend.
 
 ## Architecture
 
@@ -60,6 +61,8 @@ AGENT_SLUG="claude"                          # Which agent this worker represent
 BASE_URL="http://localhost:2000"             # URL where the backend is running
 ACCESS_TOKEN="your-token-here"               # Token created in step 2
 WORK_DIR="/absolute/path/to/workspace"       # Folder where work happens (absolute path)
+HEARTBEAT_INTERVAL_MS="60000"                # Optional: heartbeat interval (ms)
+HEARTBEAT_TASK_LIMIT="100"                   # Optional: tasks reconciled per heartbeat
 ```
 
 ### 4. Start the Worker

package/dist/Coordinator.d.ts

@@ -2,9 +2,21 @@ export declare class Coordinator {
     private ready;
     private transport;
     private client;
+    private heartbeatTimer?;
+    private readonly concurrencyStore;
+    private readonly activeTaskIds;
+    private currentAgent?;
     constructor();
     connect(): Promise<boolean>;
     start(): Promise<boolean>;
     private handleEvent;
+    private runHeartbeat;
     private handleTask;
+    private maybeHandleInputRequest;
+    private canRunTaskNormally;
+    private dependenciesAreDone;
+    private getCurrentAgent;
+    private getConcurrencyLimit;
+    private buildPrompt;
+    private executeTask;
 }

package/dist/Coordinator.js

@@ -1,5 +1,5 @@
 import { Taico } from "./Taico.js";
-import { ACCESS_TOKEN, AGENT_SLUG, BASE_URL } from "./helpers/config.js";
+import { ACCESS_TOKEN, AGENT_SLUG, BASE_URL, HEARTBEAT_INTERVAL_MS, HEARTBEAT_TASK_LIMIT, } from "./helpers/config.js";
 import { prepareWorkspace } from "./helpers/prepareWorkspace.js";
 import { getSession, setSession } from "./helpers/sessionStore.js";
 import { ClaudeAgentRunner } from "./runners/ClaudeAgentRunner.js";
@@ -7,10 +7,15 @@ import { SocketIOTasksTransport } from "./SocketIOTasksTransport.js";
 import { OpencodeAgentRunner } from "./runners/OpenCodeAgentRunner.js";
 import { ADKAgentRunner } from "./runners/ADKAgentRunner.js";
 import { GitHubCopilotAgentRunner } from "./runners/GitHubCopilotAgentRunner.js";
+import { AgentConcurrencyStore } from "./helpers/AgentConcurrencyStore.js";
 export class Coordinator {
     ready = false;
     transport;
     client;
+    heartbeatTimer;
+    concurrencyStore = new AgentConcurrencyStore();
+    activeTaskIds = new Set();
+    currentAgent;
     // Make transport
     constructor() {
         this.transport = new SocketIOTasksTransport(BASE_URL, ACCESS_TOKEN, {
@@ -36,11 +41,18 @@ export class Coordinator {
         }
         // Listen
         this.transport.onTaskEvent(this.handleEvent);
+        const heartbeatMs = Number.isFinite(HEARTBEAT_INTERVAL_MS) && HEARTBEAT_INTERVAL_MS > 0
+            ? HEARTBEAT_INTERVAL_MS
+            : 60_000;
+        this.heartbeatTimer = setInterval(() => {
+            void this.runHeartbeat();
+        }, heartbeatMs);
+        void this.runHeartbeat();
         return true;
     }
     handleEvent = async (evt) => {
         // For now just look at create and assign and status change
-        if (evt.type === 'created' || evt.type === 'assigned' || evt.type === 'status_changed') {
+        if (evt.type === 'created' || evt.type === 'assigned' || evt.type === 'status_changed' || evt.type === 'updated') {
             console.log('--------------------------------------------------------');
             console.log('Event received');
             console.log(`- Type: ${evt.type}`);
@@ -53,9 +65,25 @@ export class Coordinator {
                 console.log(`- Update caused by assignee. Ignoring as this is a self event. ❌`);
                 return;
             }
-            this.handleTask(task);
+            await this.maybeHandleInputRequest(task);
+            await this.handleTask(task);
         }
     };
+    async runHeartbeat() {
+        try {
+            const limit = Number.isFinite(HEARTBEAT_TASK_LIMIT) && HEARTBEAT_TASK_LIMIT > 0
+                ? Math.floor(HEARTBEAT_TASK_LIMIT)
+                : 100;
+            const tasks = await this.client.listTasks(1, limit);
+            for (const task of tasks) {
+                await this.maybeHandleInputRequest(task);
+                await this.handleTask(task);
+            }
+        }
+        catch (error) {
+            console.error('[heartbeat] failed to reconcile tasks', error);
+        }
+    }
     async handleTask(task) {
         // Get the agent
         const actor = task.assigneeActor;
@@ -73,6 +101,17 @@ export class Coordinator {
             console.log(`- We only react to @${AGENT_SLUG}. Skipping. ❌`);
             return;
         }
+        if (!(await this.canRunTaskNormally(task))) {
+            return;
+        }
+        if (Array.isArray(agent.tagTriggers) && agent.tagTriggers.length > 0) {
+            const taskTagNames = new Set((task.tags ?? []).map((tag) => tag.name));
+            const matchesTagTrigger = agent.tagTriggers.some((tagTrigger) => taskTagNames.has(tagTrigger));
+            if (!matchesTagTrigger) {
+                console.log(`- Agent @${agent.slug} requires tag trigger and task has none. Skip. ❌`);
+                return;
+            }
+        }
         // Do we have runners for this agent?
         if (agent.type !== "claude" && agent.type !== "opencode" && agent.type !== "adk" && agent.type !== "githubcopilot") {
             console.log(`- Agent @${actor.slug} of type "${agent.type}" not supported. Skipping. ❌`);
@@ -83,99 +122,200 @@ export class Coordinator {
             console.log(`- Agent @${agent.slug} doesn't react to status '${task.status}'. Skip. ❌`);
             return;
         }
-        // Extract project slug from tags and get project repo URL
-        let repoUrl = null;
-        const projectTag = task.tags?.find((tag) => tag.name.startsWith('project:'));
-        if (projectTag) {
-            const projectSlug = projectTag.name.replace('project:', '');
-            console.log(`- Found project tag: ${projectTag.name}, slug: ${projectSlug}`);
-            const project = await this.client.getProjectBySlug(projectSlug);
-            if (project) {
-                console.log(`- Project found: ${project.slug}`);
-                repoUrl = project.repoUrl ?? null;
-                if (repoUrl) {
-                    console.log(`- Using project repo: ${repoUrl}`);
-                }
-                else {
-                    console.log(`- Project has no repoUrl, using default`);
-                }
+        await this.executeTask(task, agent, 'normal');
+    }
+    async maybeHandleInputRequest(task) {
+        const agent = await this.getCurrentAgent();
+        if (!agent) {
+            return;
+        }
+        const unansweredForMe = task.inputRequests.find((inputRequest) => {
+            if (inputRequest.answer != null) {
+                return false;
             }
-            else {
-                console.log(`- Project not found for slug: ${projectSlug}`);
+            if (inputRequest.assignedToActorId !== agent.actorId) {
+                return false;
             }
-        }
-        console.log(`- ✅ Conditions met. @${agent.slug} starting to work on task "${task.name}" 🦄`);
-        // Load session
-        const sessionId = getSession(agent.actorId, task.id);
-        // Prep workspace
-        const workDir = await prepareWorkspace(task.id, agent.actorId, repoUrl);
-        console.log(`- workspace prepped`);
-        const run = await this.client.startRun(task.id);
-        if (!run) {
-            console.error(`Failed to create a run ❌`);
+            return task.assigneeActor?.id !== agent.actorId;
+        });
+        if (!unansweredForMe) {
             return;
         }
-        console.log(`Started Agent Run ID ${run.id}`);
-        // Create agent runner
-        let runner = null;
-        const modelConfig = {
-            providerId: agent.providerId ?? undefined,
-            modelId: agent.modelId ?? undefined,
-        };
-        if (agent.type === 'claude') {
-            runner = new ClaudeAgentRunner(modelConfig);
+        console.log(`- Unanswered input request ${unansweredForMe.id} assigned to @${agent.slug}. Triggering response flow.`);
+        await this.executeTask(task, agent, 'input_request', unansweredForMe);
+    }
+    async canRunTaskNormally(task) {
+        if (!(await this.dependenciesAreDone(task))) {
+            return false;
         }
-        else if (agent.type === 'opencode') {
-            runner = new OpencodeAgentRunner(modelConfig);
+        const unresolvedInputRequests = task.inputRequests.filter((inputRequest) => inputRequest.answer == null);
+        if (unresolvedInputRequests.length > 0) {
+            console.log(`- Task ${task.id} has unresolved input requests. Skip until answered. ❌`);
+            return false;
         }
-        else if (agent.type === 'adk') {
-            runner = new ADKAgentRunner(modelConfig);
+        return true;
+    }
+    async dependenciesAreDone(task) {
+        if (!Array.isArray(task.dependsOnIds) || task.dependsOnIds.length === 0) {
+            return true;
         }
-        else if (agent.type === 'githubcopilot') {
-            runner = new GitHubCopilotAgentRunner(modelConfig);
+        for (const dependencyId of task.dependsOnIds) {
+            const dependencyTask = await this.client.getTask(dependencyId);
+            if (!dependencyTask) {
+                console.log(`- Dependency task ${dependencyId} not found. Skip. ❌`);
+                return false;
+            }
+            if (dependencyTask.status !== 'DONE') {
+                console.log(`- Dependency task ${dependencyId} is ${dependencyTask.status}. Skip. ❌`);
+                return false;
+            }
         }
-        // This shouldn't happen because we checked first, but let's satisfy TypeScript
-        if (!runner) {
-            console.log(`- Agent @${actor.slug} of type "${agent.type}" not supported. Skipping. ❌`);
+        return true;
+    }
+    async getCurrentAgent() {
+        if (this.currentAgent) {
+            return this.currentAgent;
+        }
+        const agent = await this.client.getAgent(AGENT_SLUG);
+        if (!agent) {
+            console.log(`- Agent @${AGENT_SLUG} not found. ❌`);
+            return null;
+        }
+        this.currentAgent = agent;
+        return this.currentAgent;
+    }
+    getConcurrencyLimit(agent) {
+        if (typeof agent.concurrencyLimit === 'number' && Number.isFinite(agent.concurrencyLimit) && agent.concurrencyLimit > 0) {
+            return Math.floor(agent.concurrencyLimit);
+        }
+        return null;
+    }
+    buildPrompt(task, agent, mode, inputRequest) {
+        if (mode === 'input_request' && inputRequest) {
+            return [
+                `You got triggered by an unanswered input request in task "${task.id}".`,
+                'You were asked a question and only need to answer that question.',
+                'Do not go through the normal flow and do not complete the task unless explicitly requested.',
+                '',
+                `Input request id: ${inputRequest.id}`,
+                `Question: ${String(inputRequest.question ?? '')}`,
+                '',
+                'Fetch the task, answer the input request assigned to you, and stop there.',
+            ].join('\n');
+        }
+        return `You got triggered by new activity in task "${task.id}". Fetch the task and proceed according to the following instructions.\n\n\n ${agent.systemPrompt}`;
+    }
+    async executeTask(task, agent, mode, inputRequest) {
+        if (this.activeTaskIds.has(task.id)) {
+            console.log(`- Task ${task.id} is already running in this worker. Skip. ❌`);
             return;
         }
+        const concurrencyLimit = this.getConcurrencyLimit(agent);
+        if (!this.concurrencyStore.tryAcquire(agent.actorId, concurrencyLimit)) {
+            console.log(`- Agent @${agent.slug} reached concurrency limit (${concurrencyLimit ?? 'unlimited'}). Skip. ❌`);
+            return;
+        }
+        this.activeTaskIds.add(task.id);
         try {
-            const results = await runner.run({
-                taskId: task.id,
-                prompt: `You got triggered by new activity in task "${task.id}". Fetch the task and proceed according to the following instructions.\n\n\n ${agent.systemPrompt}`,
-                cwd: workDir,
-                runId: run.id,
-            }, {
-                onEvent: (message) => {
-                    console.log(`[agent message] ⤵️`);
-                    console.log(message);
-                    console.log('[end of agent message] ⤴️');
-                    this.transport.publishActivity({
-                        taskId: task.id,
-                        message,
-                        ts: Date.now(),
-                    });
-                },
-                onSession: (sessionId) => {
-                    if (!sessionId) {
-                        setSession(agent.actorId, task.id, sessionId);
+            // Extract project slug from tags and get project repo URL
+            let repoUrl = null;
+            const projectTag = task.tags?.find((tag) => tag.name.startsWith('project:'));
+            if (projectTag) {
+                const projectSlug = projectTag.name.replace('project:', '');
+                console.log(`- Found project tag: ${projectTag.name}, slug: ${projectSlug}`);
+                const project = await this.client.getProjectBySlug(projectSlug);
+                if (project) {
+                    console.log(`- Project found: ${project.slug}`);
+                    repoUrl = project.repoUrl ?? null;
+                    if (repoUrl) {
+                        console.log(`- Using project repo: ${repoUrl}`);
+                    }
+                    else {
+                        console.log(`- Project has no repoUrl, using default`);
                     }
-                },
-                onError: (error) => {
-                    console.log('Error detected');
-                    console.log('error message:', error.message);
-                    console.log('raw message', error.rawMessage);
-                    // Post error to task as a comment
-                    this.client.addComment(task.id, `⚠️ Error Detected ⚠️\n\n${error.message}\n\n\`\`\`json\nraw message\n${JSON.stringify(error.rawMessage, null, 2)}\n\`\`\``);
                 }
-            });
-            console.log(results);
+                else {
+                    console.log(`- Project not found for slug: ${projectSlug}`);
+                }
+            }
+            console.log(`- ✅ Conditions met. @${agent.slug} starting to work on task "${task.name}" 🦄`);
+            // Load session
+            const sessionId = getSession(agent.actorId, task.id);
+            // Prep workspace
+            const workDir = await prepareWorkspace(task.id, agent.actorId, repoUrl);
+            console.log(`- workspace prepped`);
+            const run = await this.client.startRun(task.id);
+            if (!run) {
+                console.error(`Failed to create a run ❌`);
+                return;
+            }
+            console.log(`Started Agent Run ID ${run.id}`);
+            // Create agent runner
+            let runner = null;
+            const modelConfig = {
+                providerId: agent.providerId ?? undefined,
+                modelId: agent.modelId ?? undefined,
+            };
+            if (agent.type === 'claude') {
+                runner = new ClaudeAgentRunner(modelConfig);
+            }
+            else if (agent.type === 'opencode') {
+                runner = new OpencodeAgentRunner(modelConfig);
+            }
+            else if (agent.type === 'adk') {
+                runner = new ADKAgentRunner(modelConfig);
+            }
+            else if (agent.type === 'githubcopilot') {
+                runner = new GitHubCopilotAgentRunner(modelConfig);
+            }
+            // This shouldn't happen because we checked first, but let's satisfy TypeScript
+            if (!runner) {
+                console.log(`- Agent @${agent.slug} of type "${agent.type}" not supported. Skipping. ❌`);
+                return;
+            }
+            try {
+                const results = await runner.run({
+                    taskId: task.id,
+                    prompt: this.buildPrompt(task, agent, mode, inputRequest),
+                    cwd: workDir,
+                    runId: run.id,
+                    resume: sessionId ?? undefined,
+                }, {
+                    onEvent: (message) => {
+                        console.log(`[agent message] ⤵️`);
+                        console.log(message);
+                        console.log('[end of agent message] ⤴️');
+                        this.transport.publishActivity({
+                            taskId: task.id,
+                            message,
+                            ts: Date.now(),
+                        });
+                    },
+                    onSession: (runnerSessionId) => {
+                        if (runnerSessionId) {
+                            setSession(agent.actorId, task.id, runnerSessionId);
+                        }
+                    },
+                    onError: (error) => {
+                        console.log('Error detected');
+                        console.log('error message:', error.message);
+                        console.log('raw message', error.rawMessage);
+                        // Post error to task as a comment
+                        this.client.addComment(task.id, `⚠️ Error Detected ⚠️\n\n${error.message}\n\n\`\`\`json\nraw message\n${JSON.stringify(error.rawMessage, null, 2)}\n\`\`\``);
+                    }
+                });
+                console.log(results);
+            }
+            catch (error) {
+                console.error(`Error running task`);
+                console.error(error);
+                // Force a comment
+                this.client.addComment(task.id, `❌ Something went wrong ❌\n\n${error}`);
+            }
         }
-        catch (error) {
-            console.error(`Error running task`);
-            console.error(error);
-            // Force a comment
-            this.client.addComment(task.id, `❌ Something went wrong ❌\n\n${error}`);
+        finally {
+            this.activeTaskIds.delete(task.id);
+            this.concurrencyStore.release(agent.actorId);
         }
     }
 }

package/dist/Taico.d.ts

@@ -1,10 +1,12 @@
-import { type AgentResponseDto, type AgentRunResponseDto, type ProjectResponseDto } from "@taico/client";
+import { type AgentResponseDto, type AgentRunResponseDto, type ProjectResponseDto, type TaskResponseDto } from "@taico/client";
 export declare class Taico {
     constructor(baseUrl: string, accessToken: string);
     getAgent(agentSlug: string): Promise<AgentResponseDto | null>;
     getAgentPrompt(agentSlug: string): Promise<string>;
     getAgentStatusTriggers(agentSlug: string): Promise<string[]>;
     addComment(taskId: string, comment: string): Promise<void>;
+    listTasks(page?: number, limit?: number): Promise<TaskResponseDto[]>;
+    getTask(taskId: string): Promise<TaskResponseDto | null>;
     getProjectBySlug(slug: string): Promise<ProjectResponseDto | null>;
     startRun(taskId: string): Promise<AgentRunResponseDto | null>;
 }

package/dist/Taico.js

@@ -44,6 +44,21 @@ export class Taico {
             console.error(`Failed to post comment to task ${taskId}:`, error);
         }
     }
+    async listTasks(page = 1, limit = 100) {
+        const response = await TaskService.tasksControllerListTasks(undefined, undefined, undefined, page, limit);
+        return response.items;
+    }
+    async getTask(taskId) {
+        try {
+            return await TaskService.tasksControllerGetTask(taskId);
+        }
+        catch (error) {
+            if (isApiError(error) && error.status === 404) {
+                return null;
+            }
+            throw error;
+        }
+    }
     async getProjectBySlug(slug) {
         try {
             return await MetaProjectsService.projectsControllerGetProjectBySlug(slug);

package/dist/helpers/AgentConcurrencyStore.d.ts

@@ -0,0 +1,6 @@
+export declare class AgentConcurrencyStore {
+    private readonly counts;
+    tryAcquire(actorId: string, limit: number | null): boolean;
+    release(actorId: string): void;
+    getCount(actorId: string): number;
+}

package/dist/helpers/AgentConcurrencyStore.js

@@ -0,0 +1,40 @@
+export class AgentConcurrencyStore {
+    counts = new Map();
+    tryAcquire(actorId, limit) {
+        try {
+            if (!actorId)
+                return false;
+            if (typeof limit === 'number' && limit > 0) {
+                const current = this.counts.get(actorId) ?? 0;
+                if (current >= limit) {
+                    return false;
+                }
+            }
+            const current = this.counts.get(actorId) ?? 0;
+            this.counts.set(actorId, current + 1);
+            return true;
+        }
+        catch (error) {
+            console.error('[concurrency] failed to acquire slot', error);
+            return false;
+        }
+    }
+    release(actorId) {
+        try {
+            if (!actorId)
+                return;
+            const current = this.counts.get(actorId) ?? 0;
+            if (current <= 1) {
+                this.counts.delete(actorId);
+                return;
+            }
+            this.counts.set(actorId, current - 1);
+        }
+        catch (error) {
+            console.error('[concurrency] failed to release slot', error);
+        }
+    }
+    getCount(actorId) {
+        return this.counts.get(actorId) ?? 0;
+    }
+}

package/dist/helpers/config.d.ts

@@ -2,4 +2,6 @@ export declare const ACCESS_TOKEN: string;
 export declare const BASE_URL: string;
 export declare const WORK_DIR: string;
 export declare const AGENT_SLUG: string;
+export declare const HEARTBEAT_INTERVAL_MS: number;
+export declare const HEARTBEAT_TASK_LIMIT: number;
 export declare const RUN_ID_HEADER = "x-taico-run-id";

package/dist/helpers/config.js

@@ -2,6 +2,8 @@ export const ACCESS_TOKEN = process.env.ACCESS_TOKEN || '';
 export const BASE_URL = process.env.BASE_URL || '';
 export const WORK_DIR = process.env.WORK_DIR || '';
 export const AGENT_SLUG = process.env.AGENT_SLUG || '';
+export const HEARTBEAT_INTERVAL_MS = Number(process.env.HEARTBEAT_INTERVAL_MS || 60_000);
+export const HEARTBEAT_TASK_LIMIT = Number(process.env.HEARTBEAT_TASK_LIMIT || 100);
 export const RUN_ID_HEADER = 'x-taico-run-id';
 if (!ACCESS_TOKEN) {
     console.error('env ACCESS_TOKEN not available');

package/dist/runners/ADKAgentRunner.js

@@ -1,8 +1,45 @@
 // ADKAgentRunner.ts
 import { BaseAgentRunner } from "./BaseAgentRunner.js";
-import { LlmAgent, Runner, InMemorySessionService, MCPToolset } from "@google/adk";
+import { LlmAgent, Runner, InMemorySessionService, MCPToolset, BaseTool, } from "@google/adk";
 import { ADKMessageFormatter } from "../formatters/ADKMessageFormatter.js";
 import { ACCESS_TOKEN, BASE_URL, RUN_ID_HEADER } from "../helpers/config.js";
+class NamespacedTool extends BaseTool {
+    wrappedTool;
+    namespacedName;
+    constructor(wrappedTool, namespacedName) {
+        super({
+            name: namespacedName,
+            description: wrappedTool.description,
+            isLongRunning: wrappedTool.isLongRunning,
+        });
+        this.wrappedTool = wrappedTool;
+        this.namespacedName = namespacedName;
+    }
+    _getDeclaration() {
+        const declaration = this.wrappedTool._getDeclaration();
+        if (!declaration) {
+            return declaration;
+        }
+        return {
+            ...declaration,
+            name: this.namespacedName,
+        };
+    }
+    async runAsync(request) {
+        return this.wrappedTool.runAsync(request);
+    }
+}
+class NamespacedMCPToolset extends MCPToolset {
+    serverName;
+    constructor(connectionParams, serverName) {
+        super(connectionParams);
+        this.serverName = serverName;
+    }
+    async getTools(context) {
+        const tools = await super.getTools(context);
+        return tools.map((tool) => new NamespacedTool(tool, `mcp__${this.serverName}__${tool.name}`));
+    }
+}
 export class ADKAgentRunner extends BaseAgentRunner {
     kind = 'adk';
     formatter = new ADKMessageFormatter();
@@ -26,14 +63,22 @@ export class ADKAgentRunner extends BaseAgentRunner {
             description: '',
             instruction: '',
             tools: [
-                new MCPToolset({
+                new NamespacedMCPToolset({
                     type: 'StreamableHTTPConnectionParams',
                     url: `${BASE_URL}/api/v1/tasks/tasks/mcp`,
                     header: {
                         Authorization: `Bearer ${ACCESS_TOKEN}`,
                         [RUN_ID_HEADER]: ctx.runId,
                     },
-                })
+                }, 'tasks'),
+                new NamespacedMCPToolset({
+                    type: 'StreamableHTTPConnectionParams',
+                    url: `${BASE_URL}/api/v1/context/blocks/mcp`,
+                    header: {
+                        Authorization: `Bearer ${ACCESS_TOKEN}`,
+                        [RUN_ID_HEADER]: ctx.runId,
+                    },
+                }, 'context')
             ]
         });
         const runner = new Runner({

package/dist/runners/ClaudeAgentRunner.js

@@ -27,10 +27,19 @@ export class ClaudeAgentRunner extends BaseAgentRunner {
                             Authorization: `Bearer ${ACCESS_TOKEN}`,
                             [RUN_ID_HEADER]: ctx.runId,
                         },
+                    },
+                    context: {
+                        type: "http",
+                        url: `${BASE_URL}/api/v1/context/blocks/mcp`,
+                        headers: {
+                            Authorization: `Bearer ${ACCESS_TOKEN}`,
+                            [RUN_ID_HEADER]: ctx.runId,
+                        },
                     }
                 },
                 allowedTools: [
                     'mcp__tasks__*',
+                    'mcp__context__*',
                     'SlashCommand',
                     'Bash',
                     'Read',

package/dist/runners/GitHubCopilotAgentRunner.js

@@ -26,11 +26,21 @@ export class GitHubCopilotAgentRunner extends BaseAgentRunner {
                     },
                     tools: ["*"],
                 };
+                const contextMcpServer = {
+                    type: "http",
+                    url: `${BASE_URL}/api/v1/context/blocks/mcp`,
+                    headers: {
+                        Authorization: `Bearer ${ACCESS_TOKEN}`,
+                        [RUN_ID_HEADER]: ctx.runId,
+                    },
+                    tools: ["*"],
+                };
                 // Create a session for this work
                 const session = await this.client.createSession({
                     model: this.model,
                     mcpServers: {
                         tasks: taskMcpServer,
+                        context: contextMcpServer,
                     },
                 });
                 if (session?.sessionId) {

package/dist/runners/OpenCodeAgentRunner.js

@@ -79,6 +79,15 @@ export class OpencodeAgentRunner extends BaseAgentRunner {
                                     [RUN_ID_HEADER]: runId,
                                 },
                                 enabled: true,
+                            },
+                            context: {
+                                type: "remote",
+                                url: `${BASE_URL}/api/v1/context/blocks/mcp`,
+                                headers: {
+                                    Authorization: `Bearer ${ACCESS_TOKEN}`,
+                                    [RUN_ID_HEADER]: runId,
+                                },
+                                enabled: true,
                             }
                         }
                     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taico/worker",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "type": "module",
   "private": false,
   "license": "MIT",