@taico/worker 0.0.6 → 0.0.7

package/dist/Coordinator.d.ts

@@ -17,6 +17,7 @@ export declare class Coordinator {
     private dependenciesAreDone;
     private getCurrentAgent;
     private getConcurrencyLimit;
+    private buildThreadContextInstructions;
     private buildPrompt;
     private executeTask;
 }

package/dist/Coordinator.js

@@ -190,7 +190,21 @@ export class Coordinator {
         }
         return null;
     }
-    buildPrompt(task, agent, mode, inputRequest) {
+    buildThreadContextInstructions(task, thread) {
+        return [
+            '',
+            'Thread context:',
+            `- This task belongs to thread "${thread.id}" (${thread.title}).`,
+            `- This task is ${thread.parentTaskId === task.id ? 'the parent task' : 'an attached task'} in that thread.`,
+            `- Read shared thread memory at the start via mcp__context__get_thread_state_memory with threadId "${thread.id}".`,
+            `- Check sibling task status via mcp__tasks__list_tasks_by_thread with threadId "${thread.id}".`,
+            `- Keep decisions aligned with this shared memory and thread-level goal, not only this single task.`,
+        ];
+    }
+    buildPrompt(task, agent, mode, inputRequest, thread) {
+        const threadContextInstructions = thread
+            ? this.buildThreadContextInstructions(task, thread)
+            : [];
         if (mode === 'input_request' && inputRequest) {
             return [
                 `You got triggered by an unanswered input request in task "${task.id}".`,
@@ -200,10 +214,18 @@ export class Coordinator {
                 `Input request id: ${inputRequest.id}`,
                 `Question: ${String(inputRequest.question ?? '')}`,
                 '',
+                ...threadContextInstructions,
+                '',
                 '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}`;
+        return [
+            `You got triggered by new activity in task "${task.id}".`,
+            'Fetch the task and proceed according to the following instructions.',
+            ...threadContextInstructions,
+            '',
+            agent.systemPrompt,
+        ].join('\n');
     }
     async executeTask(task, agent, mode, inputRequest) {
         if (this.activeTaskIds.has(task.id)) {
@@ -244,6 +266,10 @@ export class Coordinator {
             // Prep workspace
             const workDir = await prepareWorkspace(task.id, agent.actorId, repoUrl);
             console.log(`- workspace prepped`);
+            const thread = await this.client.getThreadByTaskId(task.id);
+            if (thread) {
+                console.log(`- Task ${task.id} belongs to thread ${thread.id} (${thread.title})`);
+            }
             const run = await this.client.startRun(task.id);
             if (!run) {
                 console.error(`Failed to create a run ❌`);
@@ -276,10 +302,11 @@ export class Coordinator {
             try {
                 const results = await runner.run({
                     taskId: task.id,
-                    prompt: this.buildPrompt(task, agent, mode, inputRequest),
+                    prompt: this.buildPrompt(task, agent, mode, inputRequest, thread),
                     cwd: workDir,
                     runId: run.id,
                     resume: sessionId ?? undefined,
+                    agentSlug: agent.slug,
                 }, {
                     onEvent: (message) => {
                         console.log(`[agent message] ⤵️`);

package/dist/Taico.d.ts

@@ -1,4 +1,4 @@
-import { type AgentResponseDto, type AgentRunResponseDto, type ProjectResponseDto, type TaskResponseDto } from "@taico/client";
+import { type AgentResponseDto, type AgentRunResponseDto, type ProjectResponseDto, type TaskResponseDto, type ThreadResponseDto } from "@taico/client";
 export declare class Taico {
     constructor(baseUrl: string, accessToken: string);
     getAgent(agentSlug: string): Promise<AgentResponseDto | null>;
@@ -8,5 +8,6 @@ export declare class Taico {
     listTasks(page?: number, limit?: number): Promise<TaskResponseDto[]>;
     getTask(taskId: string): Promise<TaskResponseDto | null>;
     getProjectBySlug(slug: string): Promise<ProjectResponseDto | null>;
+    getThreadByTaskId(taskId: string): Promise<ThreadResponseDto | null>;
     startRun(taskId: string): Promise<AgentRunResponseDto | null>;
 }

package/dist/Taico.js

@@ -1,5 +1,5 @@
 // Taico.ts - API client wrapper using generated services
-import { OpenAPI, ApiError, AgentService, TaskService, MetaProjectsService, AgentRunService, } from "@taico/client";
+import { OpenAPI, ApiError, AgentService, TaskService, ThreadsService, MetaProjectsService, AgentRunService, } from "@taico/client";
 function isApiError(error) {
     return error instanceof ApiError;
 }
@@ -70,6 +70,17 @@ export class Taico {
             throw error;
         }
     }
+    async getThreadByTaskId(taskId) {
+        try {
+            return await ThreadsService.threadsControllerGetThreadByTaskId(taskId);
+        }
+        catch (error) {
+            if (isApiError(error) && error.status === 404) {
+                return null;
+            }
+            throw error;
+        }
+    }
     async startRun(taskId) {
         try {
             return await AgentRunService.agentRunsControllerCreateAgentRun({

package/dist/formatters/ADKMessageFormatter.d.ts

@@ -1,4 +1,6 @@
 import { Event } from "@google/adk";
 export declare class ADKMessageFormatter {
+    private agentSlug?;
+    constructor(agentSlug?: string | undefined);
     format(message: Event): Array<string>;
 }

package/dist/formatters/ADKMessageFormatter.js

@@ -1,5 +1,10 @@
 export class ADKMessageFormatter {
+    agentSlug;
+    constructor(agentSlug) {
+        this.agentSlug = agentSlug;
+    }
     format(message) {
+        const agentLabel = this.agentSlug ? `@${this.agentSlug}` : 'Assistant';
         const content = message.content;
         if (!content) {
             return [];
@@ -11,19 +16,19 @@ export class ADKMessageFormatter {
         const partMessages = parts.map(part => {
             // Think
             if (part.thought) {
-                return `💬 Thinking...`;
+                return `💬 ${agentLabel} Thinking...`;
             }
             // Tool call
             if (part.functionCall) {
-                return `🔧 Tool call: ${part.functionCall.name}`;
+                return `🔧 ${agentLabel} Tool call: ${part.functionCall.name}`;
             }
             // Tool response
             if (part.functionResponse) {
-                return `🔧 Tool response: ${part.functionResponse.name}`;
+                return `🔧 ${agentLabel} Tool response: ${part.functionResponse.name}`;
             }
             // Text
             if (part.text) {
-                return `💬 Assistant: ${part.text}`;
+                return `💬 ${agentLabel}: ${part.text}`;
             }
             return null;
         }).filter(p => p != null);

package/dist/formatters/ClaudeMessageFormatter.d.ts

@@ -1,5 +1,7 @@
 import { SDKMessage } from "@anthropic-ai/claude-agent-sdk";
 export declare class ClaudeMessageFormatter {
+    private agentSlug?;
+    constructor(agentSlug?: string | undefined);
     format(message: SDKMessage): string | null;
     private formatAssistant;
     private formatUser;

package/dist/formatters/ClaudeMessageFormatter.js

@@ -1,4 +1,8 @@
 export class ClaudeMessageFormatter {
+    agentSlug;
+    constructor(agentSlug) {
+        this.agentSlug = agentSlug;
+    }
     format(message) {
         switch (message.type) {
             case 'assistant':
@@ -25,15 +29,16 @@ export class ClaudeMessageFormatter {
         const content = message.message?.content;
         if (!Array.isArray(content))
             return null;
+        const agentLabel = this.agentSlug ? `@${this.agentSlug}` : 'Assistant';
         for (const c of content) {
             if (c.type === 'tool_use') {
-                parts.push(`🔧 Tool call: ${c.name}`);
+                parts.push(`🔧 ${agentLabel} Tool call: ${c.name}`);
             }
             else if (c.type === 'text') {
-                parts.push(`💬 Assistant: ${c.text}`);
+                parts.push(`💬 ${agentLabel}: ${c.text}`);
             }
             else {
-                parts.push(`💬 Assistant (${c.type})`);
+                parts.push(`💬 ${agentLabel} (${c.type})`);
             }
         }
         return parts.length ? parts.join('\n') : null;
@@ -58,20 +63,22 @@ export class ClaudeMessageFormatter {
         return parts.length ? parts.join('\n') : null;
     }
     formatResult(message) {
+        const agentLabel = this.agentSlug ? `@${this.agentSlug}` : 'Assistant';
         if (message.subtype === 'success' &&
             typeof message.result === 'string') {
             return [
-                `--- Agent turn complete ---`,
+                `--- ${agentLabel} turn complete ---`,
                 message.result,
                 `---------------------------`,
             ].join('\n');
         }
-        return `✅ Agent result received`;
+        return `✅ ${agentLabel} result received`;
     }
     formatSystem(message) {
+        const agentLabel = this.agentSlug ? `@${this.agentSlug}` : 'Assistant';
         if (message.subtype === 'init') {
             return [
-                `🧠 Claude initialized`,
+                `🧠 ${agentLabel} Claude initialized`,
                 `- Permissions: ${message.permissionMode}`,
                 `- Tools: ${message.tools.length}`,
                 `- MCP Servers: ${message.mcp_servers.length}`,
@@ -81,7 +88,7 @@ export class ClaudeMessageFormatter {
                 `- Agents: ${message.agents?.length || 0}`,
             ].join('\n');
         }
-        return `⚙️ System message`;
+        return `⚙️ ${agentLabel} System message`;
     }
     formatStreamEvent(_) {
         // usually too noisy — ignore by default
@@ -92,6 +99,7 @@ export class ClaudeMessageFormatter {
         return null;
     }
     formatAuthStatus(_) {
-        return `🔐 Auth status updated`;
+        const agentLabel = this.agentSlug ? `@${this.agentSlug}` : 'Assistant';
+        return `🔐 ${agentLabel} Auth status updated`;
     }
 }

package/dist/formatters/OpencodeMessageFormatter.d.ts

@@ -1,8 +1,12 @@
 import { AssistantMessage, Part, Event } from "@opencode-ai/sdk";
-export declare function opencodePartToText(part: Part): string;
+export declare function opencodePartToText(part: Part, agentSlug?: string): string;
 export declare class OpencodeAsyncMessageFormatter {
+    private agentSlug?;
+    constructor(agentSlug?: string | undefined);
     format(event: Event): string | null;
 }
 export declare class OpencodeSyncMessageFormatter {
+    private agentSlug?;
+    constructor(agentSlug?: string | undefined);
     format(info: AssistantMessage, parts: Array<Part>): Array<string>;
 }

package/dist/formatters/OpencodeMessageFormatter.js

@@ -1,32 +1,37 @@
-export function opencodePartToText(part) {
+export function opencodePartToText(part, agentSlug) {
+    const agentLabel = agentSlug ? `@${agentSlug}` : 'Assistant';
     switch (part.type) {
         case 'text':
-            return `💬 Assistant: ${part.text}`;
+            return `💬 ${agentLabel}: ${part.text}`;
         case 'subtask':
-            return `💬 Assistant: Creating subtask: ${part.description}`;
+            return `💬 ${agentLabel}: Creating subtask: ${part.description}`;
         case 'reasoning':
-            return `💬 Assistant: Thinking...`;
+            return `💬 ${agentLabel}: Thinking...`;
         case 'file':
-            return `📂 File ${part.filename || ''}`;
+            return `📂 ${agentLabel} File ${part.filename || ''}`;
         case 'tool':
-            return `🔧 Tool call: ${part.tool}`;
+            return `🔧 ${agentLabel} Tool call: ${part.tool}`;
         case 'step-start':
-            return `💬 Assistant: Starting step`;
+            return `💬 ${agentLabel}: Starting step`;
         case 'step-finish':
-            return `💬 Assistant: Finish step: ${part.reason}`;
+            return `💬 ${agentLabel}: Finish step: ${part.reason}`;
         case 'snapshot':
-            return `📸 Snapshot: ${part.snapshot}`;
+            return `📸 ${agentLabel} Snapshot: ${part.snapshot}`;
         case 'patch':
-            return `🔧 Patching files: ${part.files}`;
+            return `🔧 ${agentLabel} Patching files: ${part.files}`;
         case 'agent':
-            return `🤖 Agent: ${part.name}`;
+            return `🤖 ${agentLabel} Agent: ${part.name}`;
         case 'retry':
-            return `🔄 Retrying error due to error '${part.error.name}'. Attempt ${part.attempt}...`;
+            return `🔄 ${agentLabel} Retrying error due to error '${part.error.name}'. Attempt ${part.attempt}...`;
         case 'compaction':
-            return `🚜 Compacting`;
+            return `🚜 ${agentLabel} Compacting`;
     }
 }
 export class OpencodeAsyncMessageFormatter {
+    agentSlug;
+    constructor(agentSlug) {
+        this.agentSlug = agentSlug;
+    }
     // Only listen to part update (this is where tool calls and messages happen)
     format(event) {
         if (event.type !== 'message.part.updated') {
@@ -38,19 +43,24 @@ export class OpencodeAsyncMessageFormatter {
         }
         // Parse part into text
         const part = event.properties.part;
-        const message = opencodePartToText(part);
+        const message = opencodePartToText(part, this.agentSlug);
         return message;
     }
 }
 export class OpencodeSyncMessageFormatter {
+    agentSlug;
+    constructor(agentSlug) {
+        this.agentSlug = agentSlug;
+    }
     format(info, parts) {
         const messages = [];
+        const agentLabel = this.agentSlug ? `@${this.agentSlug}` : 'Assistant';
         // Parse info
         if (info.error) {
-            messages.push(`Error ${info.error.name}: ${JSON.stringify(info.error.data)}`);
+            messages.push(`❌ ${agentLabel} Error ${info.error.name}: ${JSON.stringify(info.error.data)}`);
         }
         // Parse parts
-        const partMessages = parts.map(opencodePartToText);
+        const partMessages = parts.map(part => opencodePartToText(part, this.agentSlug));
         return [...messages, ...partMessages];
     }
 }

package/dist/runners/ADKAgentRunner.d.ts

@@ -2,7 +2,6 @@ import { BaseAgentRunner } from "./BaseAgentRunner.js";
 import { AgentModelConfig, AgentRunContext } from "./AgentRunner.js";
 export declare class ADKAgentRunner extends BaseAgentRunner {
     readonly kind = "adk";
-    private formatter;
     private modelId;
     private sessionService;
     constructor(modelConfig?: AgentModelConfig);

package/dist/runners/ADKAgentRunner.js

@@ -42,7 +42,6 @@ class NamespacedMCPToolset extends MCPToolset {
 }
 export class ADKAgentRunner extends BaseAgentRunner {
     kind = 'adk';
-    formatter = new ADKMessageFormatter();
     modelId;
     sessionService = new InMemorySessionService();
     constructor(modelConfig = {}) {
@@ -50,6 +49,7 @@ export class ADKAgentRunner extends BaseAgentRunner {
         this.modelId = modelConfig.modelId ?? 'gemini-2.5-flash';
     }
     async runInternal(ctx, emit, setSession, onError) {
+        const formatter = new ADKMessageFormatter(ctx.agentSlug);
         let finalResult = '';
         // Init a session
         const session = await this.sessionService.createSession({
@@ -100,7 +100,7 @@ export class ADKAgentRunner extends BaseAgentRunner {
         });
         for await (const msg of stream) {
             // map → string
-            const messages = this.formatter.format(msg);
+            const messages = formatter.format(msg);
             messages.forEach(async (message) => {
                 await emit(message);
             });

package/dist/runners/AgentRunner.d.ts

@@ -20,6 +20,8 @@ export type AgentRunContext = {
     /** For backend traceability */
     runId: string;
     model?: Model;
+    /** Agent slug for personalized activity messages */
+    agentSlug?: string;
 };
 export type AgentRunCallbacks = {
     /** Called once when a session/run ID is known */

package/dist/runners/ClaudeAgentRunner.d.ts

@@ -2,7 +2,6 @@ import { BaseAgentRunner } from "./BaseAgentRunner.js";
 import { AgentModelConfig, AgentRunContext } from "./AgentRunner.js";
 export declare class ClaudeAgentRunner extends BaseAgentRunner {
     readonly kind = "claude";
-    private formatter;
     constructor(_modelConfig?: AgentModelConfig);
     protected runInternal(ctx: AgentRunContext, emit: (msg: string) => Promise<void>, setSession: (id: string) => Promise<void>, onError?: (error: {
         message: string;

package/dist/runners/ClaudeAgentRunner.js

@@ -5,11 +5,11 @@ import { ClaudeMessageFormatter } from "../formatters/ClaudeMessageFormatter.js"
 import { ACCESS_TOKEN, BASE_URL, RUN_ID_HEADER } from "../helpers/config.js";
 export class ClaudeAgentRunner extends BaseAgentRunner {
     kind = 'claude';
-    formatter = new ClaudeMessageFormatter();
     constructor(_modelConfig = {}) {
         super();
     }
     async runInternal(ctx, emit, setSession, onError) {
+        const formatter = new ClaudeMessageFormatter(ctx.agentSlug);
         let finalResult = '';
         const stream = query({
             prompt: ctx.prompt,
@@ -56,7 +56,7 @@ export class ClaudeAgentRunner extends BaseAgentRunner {
                 await setSession(msg.session_id);
             }
             // map → string
-            const text = this.formatter.format(msg);
+            const text = formatter.format(msg);
             if (text)
                 await emit(text);
             if (msg.type === 'result' && msg.subtype === 'success') {

package/dist/runners/GitHubCopilotAgentRunner.js

@@ -10,6 +10,7 @@ export class GitHubCopilotAgentRunner extends BaseAgentRunner {
         this.model = modelConfig.modelId ?? 'gpt-5.2-codex';
     }
     async runInternal(ctx, emit, setSession, onError) {
+        const agentLabel = ctx.agentSlug ? `@${ctx.agentSlug}` : 'Assistant';
         return new Promise(async (resolve, reject) => {
             try {
                 // Init client
@@ -57,17 +58,17 @@ export class GitHubCopilotAgentRunner extends BaseAgentRunner {
                     resolve(lastAssistantMessage);
                 });
                 session.on('assistant.reasoning', (reasoning) => {
-                    void emit(`💬 Thinking... ${reasoning.data.content}`);
+                    void emit(`💬 ${agentLabel} Thinking... ${reasoning.data.content}`);
                 });
                 session.on('assistant.message', (message) => {
                     lastAssistantMessage = message.data.content ?? '';
-                    void emit(`💬 Assistant: ${message.data.content}`);
+                    void emit(`💬 ${agentLabel}: ${message.data.content}`);
                 });
                 session.on('tool.execution_start', (toolCall) => {
-                    void emit(`🔧 Tool call: ${toolCall.data.toolName}`);
+                    void emit(`🔧 ${agentLabel} Tool call: ${toolCall.data.toolName}`);
                 });
                 session.on('tool.execution_complete', () => {
-                    void emit(`🔧 Tool response`);
+                    void emit(`🔧 ${agentLabel} Tool response`);
                 });
                 // Fire up the prompt
                 await session.send({

package/dist/runners/OpenCodeAgentRunner.d.ts

@@ -3,7 +3,6 @@ import { AgentModelConfig, AgentRunContext } from "./AgentRunner.js";
 export declare class OpencodeAgentRunner extends BaseAgentRunner {
     readonly kind = "opencode";
     private static chdirLock;
-    private formatter;
     private client;
     private abortController;
     private close;

package/dist/runners/OpenCodeAgentRunner.js

@@ -8,7 +8,6 @@ export class OpencodeAgentRunner extends BaseAgentRunner {
     // Mutex for process.chdir: serializes all instances so only one
     // changes the working directory at a time.
     static chdirLock = Promise.resolve();
-    formatter = new OpencodeAsyncMessageFormatter();
     client = null;
     abortController = new AbortController();
     close = () => { };
@@ -105,6 +104,7 @@ export class OpencodeAgentRunner extends BaseAgentRunner {
         throw new Error(`Failed to start Opencode on ports ${PORT_START}–${PORT_END}: ${String(lastError)}`);
     }
     async runInternal(ctx, emit, setSession, onError) {
+        const formatter = new OpencodeAsyncMessageFormatter(ctx.agentSlug);
         // Start client
         await this.initBullshit({ runId: ctx.runId, cwd: ctx.cwd });
         // await this.init({ runId: ctx.runId });
@@ -157,7 +157,7 @@ export class OpencodeAgentRunner extends BaseAgentRunner {
                     console.log('session.idle');
                     break;
                 }
-                const message = this.formatter.format(event);
+                const message = formatter.format(event);
                 if (message) {
                     emit(message);
                 }

package/package.json

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