@taico/worker 0.0.1

package/README.md

@@ -0,0 +1,63 @@
+# Taico Agent Worker
+
+This is the agent worker process. It connects to the Taico backend, listens for task events, and executes AI agents in isolated workspaces.
+
+## How It Works
+
+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.
+
+## Architecture
+
+The worker is intentionally decoupled from the backend. You can run workers anywhere — same machine, a different server, or in Kubernetes. Each worker represents one agent. To run multiple agents, start multiple worker processes.
+
+The worker has access to whatever the host machine has access to. If you have Claude Code installed and authenticated, the Claude runner can use it. Same for OpenCode and GitHub Copilot.
+
+## Setup
+
+### 1. Create an Agent
+
+In the Taico UI, go to **Agents** and create one (or use a pre-populated agent). Configure its system prompt, agent type, and status/tag triggers.
+
+### 2. Create an Access Token
+
+From the agent's page in the UI, create an access token. The token needs at least these scopes: `task:*`, `meta:*`, `context:*`, `agents:read`, `mcp:use`.
+
+> **Note:** Token-based auth is a temporary solution. Eventually, workers will securely impersonate agents automatically — no manual token management needed. The UI is intentionally minimal because this flow will be replaced.
+
+### 3. Configure the Worker
+
+Create a `.env` file in this directory (one per agent). See `.env.example`:
+
+```env
+AGENT_SLUG="claude"                          # Which agent this worker represents
+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)
+```
+
+### 4. Start the Worker
+
+```bash
+npm -w apps/worker run start
+```
+
+To run multiple agents, create separate `.env` files (e.g., `.env.claude`, `.env.reviewer`) and start each worker with the appropriate env file loaded.
+
+## Supported Agent Types
+
+| Type | Harness | Requirements |
+|---|---|---|
+| `claude` | Claude Agent SDK | Claude Code installed and authenticated |
+| `opencode` | OpenCode SDK | OpenCode installed |
+| `adk` | Google ADK | None (runs in-process). No tools — suited for general tasks like reading the board. |
+| `githubcopilot` | GitHub Copilot SDK | GitHub Copilot set up on the machine |
+
+## MCP Integration
+
+Each agent run gets access to a Taico MCP server at the backend's `/api/v1/tasks/tasks/mcp` endpoint. This gives agents tools to interact with Taico — reading tasks, posting comments, creating subtasks, etc. Authentication is handled automatically via the access token and a per-run ID header.

package/dist/Coordinator.d.ts

@@ -0,0 +1,10 @@
+export declare class Coordinator {
+    private ready;
+    private transport;
+    private client;
+    constructor();
+    connect(): Promise<boolean>;
+    start(): Promise<boolean>;
+    private handleEvent;
+    private handleTask;
+}

package/dist/Coordinator.js

@@ -0,0 +1,183 @@
+import { Taico } from "./Taico.js";
+import { ACCESS_TOKEN, AGENT_SLUG, BASE_URL } from "./helpers/config.js";
+import { prepareWorkspace } from "./helpers/prepareWorkspace.js";
+import { getSession, setSession } from "./helpers/sessionStore.js";
+import { ClaudeAgentRunner } from "./runners/ClaudeAgentRunner.js";
+import { SocketIOTasksTransport } from "./SocketIOTasksTransport.js";
+import { OpencodeAgentRunner } from "./runners/OpenCodeAgentRunner.js";
+import { ADKAgentRunner } from "./runners/ADKAgentRunner.js";
+import { GitHubCopilotAgentRunner } from "./runners/GitHubCopilotAgentRunner.js";
+export class Coordinator {
+    ready = false;
+    transport;
+    client;
+    // Make transport
+    constructor() {
+        this.transport = new SocketIOTasksTransport(BASE_URL, ACCESS_TOKEN, {
+            namespace: '/tasks',
+            // debug: true,
+        });
+        this.client = new Taico(BASE_URL, ACCESS_TOKEN);
+    }
+    async connect() {
+        try {
+            await this.transport.start();
+            this.ready = true;
+        }
+        catch {
+            this.ready = false;
+        }
+        return this.ready;
+    }
+    async start() {
+        // Connect
+        if (!(await this.connect())) {
+            return false;
+        }
+        // Listen
+        this.transport.onTaskEvent(this.handleEvent);
+        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') {
+            console.log('--------------------------------------------------------');
+            console.log('Event received');
+            console.log(`- Type: ${evt.type}`);
+            console.log(`- Task: ${evt.task.name}`);
+            console.log(`- Actor: ${evt.actorId}`);
+            console.log(`- Task status: ${evt.task.status}`);
+            console.log(`- Task assignee: ${evt.task.assigneeActor?.id}`);
+            const task = evt.task;
+            if (task.assigneeActor?.id === evt.actorId) {
+                console.log(`- Update caused by assignee. Ignoring as this is a self event. ❌`);
+                return;
+            }
+            this.handleTask(task);
+        }
+    };
+    async handleTask(task) {
+        // Get the agent
+        const actor = task.assigneeActor;
+        if (!actor?.slug) {
+            console.log(`- Task ${task.id} not assigned or missing actor slug. Skipping. ❌`);
+            return;
+        }
+        const agent = await this.client.getAgent(actor.slug);
+        if (!agent) {
+            console.log(`- Agent @${actor.slug} not found. Skipping. ❌`);
+            return;
+        }
+        console.log(`- Agent: @${agent.slug}`);
+        if (agent.slug != AGENT_SLUG) {
+            console.log(`- We only react to @${AGENT_SLUG}. Skipping. ❌`);
+            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. ❌`);
+            return;
+        }
+        // Does the agent respond to this status?
+        if (!agent.statusTriggers.includes(task.status)) {
+            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`);
+                }
+            }
+            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 @${actor.slug} of type "${agent.type}" not supported. Skipping. ❌`);
+            return;
+        }
+        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);
+                    }
+                },
+                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);
+            // Force a comment
+            this.client.addComment(task.id, `Finished.\n\n${results.result}`);
+        }
+        catch (error) {
+            console.error(`Error running task`);
+            console.error(error);
+            // Force a comment
+            this.client.addComment(task.id, `❌ Something went wrong ❌\n\n${error}`);
+        }
+    }
+}

package/dist/SocketIOTasksTransport.d.ts

@@ -0,0 +1,68 @@
+import { TaskWirePayload, CommentWirePayload } from "@taico/events";
+export type TaskEvent = {
+    type: "created";
+    actorId: string;
+    task: TaskWirePayload;
+} | {
+    type: "updated";
+    actorId: string;
+    task: TaskWirePayload;
+} | {
+    type: "deleted";
+    actorId: string;
+    taskId: string;
+} | {
+    type: "assigned";
+    actorId: string;
+    task: TaskWirePayload;
+} | {
+    type: "status_changed";
+    actorId: string;
+    task: TaskWirePayload;
+} | {
+    type: "commented";
+    actorId: string;
+    comment: CommentWirePayload;
+};
+export type TaskActivity = {
+    taskId: string;
+    kind?: string;
+    message: string;
+    ts: number;
+};
+export interface TasksTransport {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    onTaskEvent(handler: (evt: TaskEvent) => void): void;
+    publishActivity(activity: TaskActivity): void;
+}
+export declare class SocketIOTasksTransport implements TasksTransport {
+    private readonly baseUrl;
+    private readonly accessToken;
+    private readonly options?;
+    private socket?;
+    private handlers;
+    private started;
+    private reconnectAttempts;
+    private subscribeAckTimer?;
+    private awaitingSubscribeAck;
+    constructor(baseUrl: string, accessToken: string, options?: {
+        namespace?: string;
+        transports?: Array<"websocket" | "polling">;
+        autoSubscribe?: boolean;
+        debug?: boolean;
+        reconnection?: boolean;
+        reconnectionAttempts?: number;
+        reconnectionDelay?: number;
+        reconnectionDelayMax?: number;
+        randomizationFactor?: number;
+        subscribeAckTimeout?: number;
+    } | undefined);
+    onTaskEvent(handler: (evt: TaskEvent) => void): void;
+    publishActivity(activity: TaskActivity): void;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private requestSubscribeAck;
+    private clearSubscribeAckTimer;
+    private emit;
+}

package/dist/SocketIOTasksTransport.js

@@ -0,0 +1,183 @@
+/*
+Socket.IO transport for task events + activity publishing.
+
+Goal: keep Socket.IO specifics here, expose a clean TasksTransport interface.
+*/
+import { io } from "socket.io-client";
+import { TaskWireEvents, } from "@taico/events";
+export class SocketIOTasksTransport {
+    baseUrl;
+    accessToken;
+    options;
+    socket;
+    handlers = [];
+    started = false;
+    reconnectAttempts = 0;
+    subscribeAckTimer;
+    awaitingSubscribeAck = false;
+    constructor(baseUrl, accessToken, options) {
+        this.baseUrl = baseUrl;
+        this.accessToken = accessToken;
+        this.options = options;
+    }
+    onTaskEvent(handler) {
+        this.handlers.push(handler);
+    }
+    publishActivity(activity) {
+        if (!this.socket || !this.socket.connected) {
+            if (this.options?.debug) {
+                console.warn("[tasks] publishActivity called while disconnected", activity);
+            }
+            return;
+        }
+        this.socket.emit(TaskWireEvents.TASK_ACTIVITY_POST, activity, (ack) => this.options?.debug && console.log(`[${TaskWireEvents.TASK_ACTIVITY_POST}] ack:`, ack));
+    }
+    async start() {
+        if (this.started)
+            return;
+        this.started = true;
+        const namespace = this.options?.namespace ?? "/tasks";
+        const transports = this.options?.transports ?? ["websocket"];
+        const autoSubscribe = this.options?.autoSubscribe ?? true;
+        const reconnection = this.options?.reconnection ?? true;
+        const reconnectionAttempts = this.options?.reconnectionAttempts ?? Infinity;
+        const reconnectionDelay = this.options?.reconnectionDelay ?? 1000;
+        const reconnectionDelayMax = this.options?.reconnectionDelayMax ?? 5000;
+        const randomizationFactor = this.options?.randomizationFactor ?? 0.5;
+        const url = `${this.baseUrl}${namespace}`;
+        if (this.options?.debug)
+            console.log(`[tasks] connecting to ${url}`);
+        this.socket = io(url, {
+            transports,
+            auth: { token: this.accessToken },
+            reconnection,
+            reconnectionAttempts,
+            reconnectionDelay,
+            reconnectionDelayMax,
+            randomizationFactor,
+        });
+        // ----- lifecycle -----
+        this.socket.on("connect", () => {
+            if (this.reconnectAttempts > 0) {
+                console.log(`[tasks] reconnected after ${this.reconnectAttempts} attempts:`, this.socket?.id);
+            }
+            else {
+                if (this.options?.debug)
+                    console.log("[tasks] connected:", this.socket?.id);
+            }
+            // Reset reconnect attempts on successful connection
+            this.reconnectAttempts = 0;
+            if (autoSubscribe) {
+                this.requestSubscribeAck();
+            }
+        });
+        this.socket.on("disconnect", (reason) => {
+            if (this.options?.debug)
+                console.log("[tasks] disconnected:", reason);
+            this.clearSubscribeAckTimer();
+            this.awaitingSubscribeAck = false;
+            // Only log reconnection info if we're going to try reconnecting
+            if (reconnection && reason !== "io client disconnect") {
+                console.log("[tasks] will attempt to reconnect...");
+            }
+        });
+        this.socket.on("connect_error", (err) => {
+            this.reconnectAttempts++;
+            console.error(`[tasks] connect_error (attempt ${this.reconnectAttempts}):`, err?.message ?? err);
+            if (this.options?.debug)
+                console.error(err);
+            this.clearSubscribeAckTimer();
+            this.awaitingSubscribeAck = false;
+        });
+        this.socket.on("reconnect_attempt", (attemptNumber) => {
+            if (this.options?.debug)
+                console.log(`[tasks] reconnect_attempt ${attemptNumber}`);
+        });
+        this.socket.on("reconnect_failed", () => {
+            console.error("[tasks] reconnect_failed: max reconnection attempts reached");
+        });
+        // ----- events we care about -----
+        // Using shared wire event types from @taico/events
+        // These types ensure consistency between backend emission and frontend/agent reception
+        this.socket.on(TaskWireEvents.TASK_CREATED, (event) => this.emit({ type: "created", actorId: event.actor.id, task: event.payload }));
+        this.socket.on(TaskWireEvents.TASK_ASSIGNED, (event) => this.emit({ type: "assigned", actorId: event.actor.id, task: event.payload }));
+        this.socket.on(TaskWireEvents.TASK_STATUS_CHANGED, (event) => this.emit({ type: "status_changed", actorId: event.actor.id, task: event.payload }));
+        this.socket.on(TaskWireEvents.TASK_UPDATED, (event) => this.emit({ type: "updated", actorId: event.actor.id, task: event.payload }));
+        this.socket.on(TaskWireEvents.TASK_DELETED, (event) => this.emit({ type: "deleted", actorId: event.actor.id, taskId: event.payload.taskId }));
+        this.socket.on(TaskWireEvents.TASK_COMMENTED, (event) => this.emit({ type: "commented", actorId: event.actor.id, comment: event.payload }));
+        // Wait until first connect or error so callers can await start()
+        await new Promise((resolve, reject) => {
+            const onConnect = () => {
+                cleanup();
+                resolve();
+            };
+            const onErr = (e) => {
+                cleanup();
+                // don't permanently kill the transport; just reject start()
+                reject(e);
+            };
+            const cleanup = () => {
+                this.socket?.off("connect", onConnect);
+                this.socket?.off("connect_error", onErr);
+            };
+            this.socket?.once("connect", onConnect);
+            this.socket?.once("connect_error", onErr);
+        });
+    }
+    async stop() {
+        this.started = false;
+        if (!this.socket)
+            return;
+        const s = this.socket;
+        this.socket = undefined;
+        // remove listeners to avoid leaks if restarted
+        s.removeAllListeners();
+        s.disconnect();
+        this.clearSubscribeAckTimer();
+        this.awaitingSubscribeAck = false;
+    }
+    requestSubscribeAck() {
+        if (!this.socket)
+            return;
+        const timeoutMs = this.options?.subscribeAckTimeout ?? 5000;
+        const socket = this.socket;
+        this.clearSubscribeAckTimer();
+        this.awaitingSubscribeAck = true;
+        socket.emit("tasks.subscribe", {}, (ack) => {
+            if (this.socket !== socket)
+                return;
+            this.awaitingSubscribeAck = false;
+            this.clearSubscribeAckTimer();
+            if (this.options?.debug)
+                console.log("[tasks] subscribed:", ack);
+        });
+        this.subscribeAckTimer = setTimeout(() => {
+            if (!this.socket || this.socket !== socket)
+                return;
+            if (!this.awaitingSubscribeAck)
+                return;
+            this.awaitingSubscribeAck = false;
+            if (this.options?.debug) {
+                console.warn("[tasks] subscribe ack timeout; forcing reconnect");
+            }
+            this.socket.disconnect();
+            this.socket.connect();
+        }, timeoutMs);
+    }
+    clearSubscribeAckTimer() {
+        if (this.subscribeAckTimer) {
+            clearTimeout(this.subscribeAckTimer);
+            this.subscribeAckTimer = undefined;
+        }
+    }
+    emit(evt) {
+        for (const h of this.handlers) {
+            try {
+                h(evt);
+            }
+            catch (err) {
+                console.error("[tasks] handler error:", err);
+            }
+        }
+    }
+}

package/dist/Taico.d.ts

@@ -0,0 +1,10 @@
+import { type AgentResponseDto, type AgentRunResponseDto, type ProjectResponseDto } 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>;
+    getProjectBySlug(slug: string): Promise<ProjectResponseDto | null>;
+    startRun(taskId: string): Promise<AgentRunResponseDto | null>;
+}

package/dist/Taico.js

@@ -0,0 +1,69 @@
+// Taico.ts - API client wrapper using generated services
+import { OpenAPI, ApiError, AgentService, TaskService, MetaProjectsService, AgentRunService, } from "@taico/client";
+function isApiError(error) {
+    return error instanceof ApiError;
+}
+export class Taico {
+    constructor(baseUrl, accessToken) {
+        // Configure the generated client
+        OpenAPI.BASE = baseUrl;
+        OpenAPI.TOKEN = accessToken;
+    }
+    async getAgent(agentSlug) {
+        try {
+            return await AgentService.agentsControllerGetAgentBySlug(agentSlug);
+        }
+        catch (error) {
+            if (isApiError(error) && error.status === 404) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async getAgentPrompt(agentSlug) {
+        const agent = await this.getAgent(agentSlug);
+        const prompt = agent?.systemPrompt;
+        if (typeof prompt !== "string" || prompt.trim() === "") {
+            throw new Error(`[Taico] Agent @${agentSlug} has no systemPrompt.`);
+        }
+        return prompt;
+    }
+    async getAgentStatusTriggers(agentSlug) {
+        const agent = await this.getAgent(agentSlug);
+        const triggers = agent?.statusTriggers;
+        if (!Array.isArray(triggers) || triggers.some((t) => typeof t !== "string")) {
+            throw new Error(`[Taico] Agent @${agentSlug} has invalid statusTriggers (expected string[]).`);
+        }
+        return triggers;
+    }
+    async addComment(taskId, comment) {
+        try {
+            await TaskService.tasksControllerAddComment(taskId, { content: comment });
+        }
+        catch (error) {
+            console.error(`Failed to post comment to task ${taskId}:`, error);
+        }
+    }
+    async getProjectBySlug(slug) {
+        try {
+            return await MetaProjectsService.projectsControllerGetProjectBySlug(slug);
+        }
+        catch (error) {
+            if (isApiError(error) && error.status === 404) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async startRun(taskId) {
+        try {
+            return await AgentRunService.agentRunsControllerCreateAgentRun({
+                parentTaskId: taskId,
+            });
+        }
+        catch (error) {
+            console.error(`Failed to start run for task ${taskId}:`, error);
+            return null;
+        }
+    }
+}

package/dist/dev.d.ts

@@ -0,0 +1 @@
+import 'dotenv/config';

package/dist/dev.js

@@ -0,0 +1,29 @@
+import 'dotenv/config';
+import { OpencodeAgentRunner } from "./runners/OpenCodeAgentRunner.js";
+async function dev() {
+    const modelConfig = {
+        providerId: 'spark-qwen3-coder-next-fp8',
+        modelId: 'Qwen/Qwen3-Coder-Next-FP8',
+    };
+    const taskId = '123';
+    const runId = 'xzy';
+    const runner = new OpencodeAgentRunner(modelConfig);
+    const ctx = {
+        taskId,
+        prompt: "Run pwd and tell me what you see",
+        cwd: `/Users/franciscogalarza/github/ai-monorepo/apps/worker/temp/asds`,
+        runId,
+    };
+    const callbacks = {
+        onEvent: (message) => {
+            console.log(message);
+        },
+        onError: (err) => {
+            console.error(err.message);
+            console.error(err.rawMessage);
+        }
+    };
+    await runner.run(ctx, callbacks);
+    return;
+}
+dev();

package/dist/formatters/ADKMessageFormatter.d.ts

@@ -0,0 +1,4 @@
+import { Event } from "@google/adk";
+export declare class ADKMessageFormatter {
+    format(message: Event): Array<string>;
+}

package/dist/formatters/ADKMessageFormatter.js

@@ -0,0 +1,32 @@
+export class ADKMessageFormatter {
+    format(message) {
+        const content = message.content;
+        if (!content) {
+            return [];
+        }
+        const parts = content.parts;
+        if (!parts) {
+            return [];
+        }
+        const partMessages = parts.map(part => {
+            // Think
+            if (part.thought) {
+                return `💬 Thinking...`;
+            }
+            // Tool call
+            if (part.functionCall) {
+                return `🔧 Tool call: ${part.functionCall.name}`;
+            }
+            // Tool response
+            if (part.functionResponse) {
+                return `🔧 Tool response: ${part.functionResponse.name}`;
+            }
+            // Text
+            if (part.text) {
+                return `💬 Assistant: ${part.text}`;
+            }
+            return null;
+        }).filter(p => p != null);
+        return partMessages;
+    }
+}

package/dist/formatters/ClaudeMessageFormatter.d.ts

@@ -0,0 +1,11 @@
+import { SDKMessage } from "@anthropic-ai/claude-agent-sdk";
+export declare class ClaudeMessageFormatter {
+    format(message: SDKMessage): string | null;
+    private formatAssistant;
+    private formatUser;
+    private formatResult;
+    private formatSystem;
+    private formatStreamEvent;
+    private formatToolProgress;
+    private formatAuthStatus;
+}