@taico/worker 0.0.1

package/dist/formatters/ClaudeMessageFormatter.js

@@ -0,0 +1,97 @@
+export class ClaudeMessageFormatter {
+    format(message) {
+        switch (message.type) {
+            case 'assistant':
+                return this.formatAssistant(message);
+            case 'user':
+                return this.formatUser(message);
+            case 'result':
+                return this.formatResult(message);
+            case 'system':
+                return this.formatSystem(message);
+            case 'stream_event':
+                return this.formatStreamEvent(message);
+            case 'tool_progress':
+                return this.formatToolProgress(message);
+            case 'auth_status':
+                return this.formatAuthStatus(message);
+            default:
+                return null;
+        }
+    }
+    // ---------------- private helpers ----------------
+    formatAssistant(message) {
+        const parts = [];
+        const content = message.message?.content;
+        if (!Array.isArray(content))
+            return null;
+        for (const c of content) {
+            if (c.type === 'tool_use') {
+                parts.push(`🔧 Tool call: ${c.name}`);
+            }
+            else if (c.type === 'text') {
+                parts.push(`💬 Assistant: ${c.text}`);
+            }
+            else {
+                parts.push(`💬 Assistant (${c.type})`);
+            }
+        }
+        return parts.length ? parts.join('\n') : null;
+    }
+    formatUser(message) {
+        const parts = [];
+        const content = message.message?.content;
+        if (!Array.isArray(content))
+            return null;
+        for (const c of content) {
+            if (c.type === 'tool_result') {
+                // skip or log if you want
+                continue;
+            }
+            else if (c.type === 'text') {
+                parts.push(`👤 User: ${c.text}`);
+            }
+            else {
+                parts.push(`👤 User (${c.type})`);
+            }
+        }
+        return parts.length ? parts.join('\n') : null;
+    }
+    formatResult(message) {
+        if (message.subtype === 'success' &&
+            typeof message.result === 'string') {
+            return [
+                `--- Agent turn complete ---`,
+                message.result,
+                `---------------------------`,
+            ].join('\n');
+        }
+        return `✅ Agent result received`;
+    }
+    formatSystem(message) {
+        if (message.subtype === 'init') {
+            return [
+                `🧠 Claude initialized`,
+                `- Permissions: ${message.permissionMode}`,
+                `- Tools: ${message.tools.length}`,
+                `- MCP Servers: ${message.mcp_servers.length}`,
+                `- Slash commands: ${message.slash_commands.length}`,
+                `- Skills: ${message.skills.length}`,
+                `- Plugins: ${message.plugins.length}`,
+                `- Agents: ${message.agents?.length || 0}`,
+            ].join('\n');
+        }
+        return `⚙️ System message`;
+    }
+    formatStreamEvent(_) {
+        // usually too noisy — ignore by default
+        return null;
+    }
+    formatToolProgress(_) {
+        // ignore for MVP
+        return null;
+    }
+    formatAuthStatus(_) {
+        return `🔐 Auth status updated`;
+    }
+}

package/dist/formatters/OpencodeMessageFormatter.d.ts

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

package/dist/formatters/OpencodeMessageFormatter.js

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

package/dist/helpers/config.d.ts

@@ -0,0 +1,5 @@
+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 RUN_ID_HEADER = "x-taico-run-id";

package/dist/helpers/config.js

@@ -0,0 +1,21 @@
+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 RUN_ID_HEADER = 'x-taico-run-id';
+if (!ACCESS_TOKEN) {
+    console.error('env ACCESS_TOKEN not available');
+    process.exit(1);
+}
+if (!BASE_URL) {
+    console.error('env BASE_URL not available');
+    process.exit(1);
+}
+if (!WORK_DIR) {
+    console.error('env WORK_DIR not available');
+    process.exit(1);
+}
+if (!AGENT_SLUG) {
+    console.error('env AGENT_SLUG not available');
+    process.exit(1);
+}

package/dist/helpers/ensureRepo.d.ts

@@ -0,0 +1 @@
+export declare function ensureRepo(repo: string, dir: string): Promise<void>;

package/dist/helpers/ensureRepo.js

@@ -0,0 +1,27 @@
+// git.ts
+import { exec } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+function sh(cmd) {
+    return new Promise((resolve, reject) => {
+        exec(cmd, (err, stdout, stderr) => {
+            if (err) {
+                reject(new Error(stderr || stdout || err.message));
+            }
+            else {
+                resolve();
+            }
+        });
+    });
+}
+export async function ensureRepo(repo, dir) {
+    const gitDir = join(dir, ".git");
+    if (!existsSync(gitDir)) {
+        console.log(`[git] cloning ${repo}`);
+        await sh(`git clone ${repo} ${dir}`);
+    }
+    else {
+        console.log(`[git] repo exists, fetching`);
+        await sh(`git -C ${dir} fetch --prune`);
+    }
+}

package/dist/helpers/prepareWorkspace.d.ts

@@ -0,0 +1 @@
+export declare function prepareWorkspace(taskId: string, agentId: string, repoUrl?: string | null): Promise<string>;

package/dist/helpers/prepareWorkspace.js

@@ -0,0 +1,23 @@
+// workspace.ts
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { ensureRepo } from "./ensureRepo.js";
+import { WORK_DIR } from "./config.js";
+const BASE_DIR = WORK_DIR;
+export async function prepareWorkspace(taskId, agentId, repoUrl) {
+    console.log(`prepping workspace for agent '${agentId}' to work on task '${taskId}'`);
+    let workDir = join(BASE_DIR, taskId, agentId);
+    // Ensure base directory exists
+    mkdirSync(workDir, { recursive: true });
+    // If no repoUrl provided, just return the base workDir
+    if (!repoUrl) {
+        console.log(`no repo url provided, using base workDir: ${workDir}`);
+        return workDir;
+    }
+    // If repoUrl provided, update workDir to point to the repo path
+    workDir = join(workDir, "repo");
+    console.log(`using repo: ${repoUrl}`);
+    // Ensure repo exists at the workDir location
+    await ensureRepo(repoUrl, workDir);
+    return workDir;
+}

package/dist/helpers/sessionStore.d.ts

@@ -0,0 +1,2 @@
+export declare function getSession(agentId: string, taskId: string): string | null;
+export declare function setSession(agentId: string, taskId: string, sessionId: string): void;

package/dist/helpers/sessionStore.js

@@ -0,0 +1,34 @@
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { join } from "node:path";
+const DB_PATH = join(new URL(".", import.meta.url).pathname, "sessions.json");
+// const DB_PATH = "sessions.json";
+function loadDB() {
+    if (!existsSync(DB_PATH))
+        return [];
+    const raw = readFileSync(DB_PATH, "utf-8").trim();
+    if (!raw)
+        return []; // empty file -> empty db
+    try {
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed : [];
+    }
+    catch {
+        // If it's corrupted/partial, don't crash the whole app.
+        // Optional self-heal:
+        // writeFileSync(DB_PATH, "[]\n");
+        return [];
+    }
+}
+function writeDB(db) {
+    writeFileSync(DB_PATH, JSON.stringify(db, null, 2));
+}
+export function getSession(agentId, taskId) {
+    const db = loadDB();
+    const entry = db.find((e) => e.agentId === agentId && e.taskId === taskId);
+    return entry?.sessionId ?? null;
+}
+export function setSession(agentId, taskId, sessionId) {
+    const db = loadDB();
+    db.push({ agentId, taskId, sessionId });
+    writeDB(db);
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import 'dotenv/config';

package/dist/index.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import 'dotenv/config';
+import { Coordinator } from "./Coordinator.js";
+const coordinator = new Coordinator();
+await coordinator.start();

package/dist/interfaces/AgentRunResult.d.ts

@@ -0,0 +1,5 @@
+export interface AgentRunResult {
+    sessionId: string | null;
+    events: string[];
+    result: string;
+}

package/dist/interfaces/AgentRunResult.js

@@ -0,0 +1,2 @@
+;
+export {};

package/dist/runners/ADKAgentRunner.d.ts

@@ -0,0 +1,13 @@
+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);
+    protected runInternal(ctx: AgentRunContext, emit: (msg: string) => Promise<void>, setSession: (id: string) => Promise<void>, onError?: (error: {
+        message: string;
+        rawMessage?: any;
+    }) => void | Promise<void>): Promise<string>;
+}

package/dist/runners/ADKAgentRunner.js

@@ -0,0 +1,65 @@
+// ADKAgentRunner.ts
+import { BaseAgentRunner } from "./BaseAgentRunner.js";
+import { LlmAgent, Runner, InMemorySessionService, MCPToolset } from "@google/adk";
+import { ADKMessageFormatter } from "../formatters/ADKMessageFormatter.js";
+import { ACCESS_TOKEN, BASE_URL, RUN_ID_HEADER } from "../helpers/config.js";
+export class ADKAgentRunner extends BaseAgentRunner {
+    kind = 'adk';
+    formatter = new ADKMessageFormatter();
+    modelId;
+    sessionService = new InMemorySessionService();
+    constructor(modelConfig = {}) {
+        super();
+        this.modelId = modelConfig.modelId ?? 'gemini-2.5-flash';
+    }
+    async runInternal(ctx, emit, setSession, onError) {
+        let finalResult = '';
+        // Init a session
+        const session = await this.sessionService.createSession({
+            appName: 'app-123',
+            sessionId: 'session-123',
+            userId: 'user-123',
+        });
+        const agent = new LlmAgent({
+            name: 'agent',
+            model: this.modelId,
+            description: '',
+            instruction: '',
+            tools: [
+                new MCPToolset({
+                    type: 'StreamableHTTPConnectionParams',
+                    url: `${BASE_URL}/api/v1/tasks/tasks/mcp`,
+                    header: {
+                        Authorization: `Bearer ${ACCESS_TOKEN}`,
+                        [RUN_ID_HEADER]: ctx.runId,
+                    },
+                })
+            ]
+        });
+        const runner = new Runner({
+            appName: 'app-123',
+            agent: agent,
+            sessionService: this.sessionService,
+        });
+        const stream = runner.runAsync({
+            userId: session.userId,
+            sessionId: session.id,
+            newMessage: {
+                parts: [
+                    {
+                        text: ctx.prompt,
+                    }
+                ],
+                role: 'user',
+            }
+        });
+        for await (const msg of stream) {
+            // map → string
+            const messages = this.formatter.format(msg);
+            messages.forEach(async (message) => {
+                await emit(message);
+            });
+        }
+        return finalResult;
+    }
+}

package/dist/runners/AgentRunner.d.ts

@@ -0,0 +1,43 @@
+export type Model = {
+    providerId: string;
+    modelId: string;
+};
+export type AgentModelConfig = {
+    providerId?: string | null;
+    modelId?: string | null;
+};
+export type AgentRunContext = {
+    /** Task / job identity */
+    taskId: string;
+    /** Initial input */
+    prompt: string;
+    /** Working directory or sandbox */
+    cwd: string;
+    /** Resume a previous run if supported */
+    resume?: string;
+    /** Arbitrary agent-specific config */
+    options?: Record<string, any>;
+    /** For backend traceability */
+    runId: string;
+    model?: Model;
+};
+export type AgentRunCallbacks = {
+    /** Called once when a session/run ID is known */
+    onSession?: (sessionId: string) => void | Promise<void>;
+    /** Called for every human-readable event */
+    onEvent?: (message: string) => void | Promise<void>;
+    /** Called when an error occurs (e.g., quota limit, API errors) */
+    onError?: (error: {
+        message: string;
+        rawMessage?: any;
+    }) => void | Promise<void>;
+};
+export type AgentRunResult = {
+    sessionId: string | null;
+    events: string[];
+    result: string;
+};
+export interface AgentRunner {
+    readonly kind: string;
+    run(ctx: AgentRunContext, cb?: AgentRunCallbacks): Promise<AgentRunResult>;
+}

package/dist/runners/AgentRunner.js

@@ -0,0 +1 @@
+export {};

package/dist/runners/BaseAgentRunner.d.ts

@@ -0,0 +1,13 @@
+import { AgentRunResult, AgentRunCallbacks, AgentRunContext, AgentRunner } from "./AgentRunner.js";
+export declare abstract class BaseAgentRunner implements AgentRunner {
+    abstract readonly kind: string;
+    run(ctx: AgentRunContext, cb?: AgentRunCallbacks): Promise<AgentRunResult>;
+    /**
+     * Implemented per agent.
+     * Must return final result string.
+     */
+    protected abstract runInternal(ctx: AgentRunContext, emit: (msg: string) => Promise<void>, setSession: (id: string) => Promise<void>, onError?: (error: {
+        message: string;
+        rawMessage?: any;
+    }) => void | Promise<void>): Promise<string>;
+}

package/dist/runners/BaseAgentRunner.js

@@ -0,0 +1,27 @@
+export class BaseAgentRunner {
+    async run(ctx, cb = {}) {
+        const events = [];
+        let sessionId = null;
+        let result = '';
+        const emit = async (msg) => {
+            events.push(msg);
+            if (cb.onEvent)
+                await cb.onEvent(msg);
+        };
+        const setSession = async (id) => {
+            if (sessionId == null) {
+                sessionId = id;
+                if (cb.onSession)
+                    await cb.onSession(id);
+            }
+        };
+        const onError = cb.onError;
+        try {
+            result = await this.runInternal(ctx, emit, setSession, onError);
+        }
+        catch (err) {
+            await emit(`❌ Agent error: ${err?.message ?? String(err)}`);
+        }
+        return { sessionId, events, result };
+    }
+}

package/dist/runners/ClaudeAgentRunner.d.ts

@@ -0,0 +1,11 @@
+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;
+        rawMessage?: any;
+    }) => void | Promise<void>): Promise<string>;
+}

package/dist/runners/ClaudeAgentRunner.js

@@ -0,0 +1,68 @@
+// ClaudeAgentRunner.ts
+import { BaseAgentRunner } from "./BaseAgentRunner.js";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+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) {
+        let finalResult = '';
+        const stream = query({
+            prompt: ctx.prompt,
+            options: {
+                cwd: ctx.cwd,
+                // resume: ctx.resume,
+                persistSession: true,
+                settingSources: ['user', 'project', 'local'],
+                ...(ctx.options ?? {}),
+                mcpServers: {
+                    tasks: {
+                        type: "http",
+                        url: `${BASE_URL}/api/v1/tasks/tasks/mcp`,
+                        headers: {
+                            Authorization: `Bearer ${ACCESS_TOKEN}`,
+                            [RUN_ID_HEADER]: ctx.runId,
+                        },
+                    }
+                },
+                allowedTools: [
+                    'mcp__tasks__*',
+                    'SlashCommand',
+                    'Bash',
+                    'Read',
+                    'Write',
+                    'Edit',
+                ],
+            },
+        });
+        for await (const msg of stream) {
+            // session capture
+            if (msg?.type === 'system' &&
+                msg?.subtype === 'init' &&
+                typeof msg.session_id === 'string') {
+                await setSession(msg.session_id);
+            }
+            // map → string
+            const text = this.formatter.format(msg);
+            if (text)
+                await emit(text);
+            if (msg.type === 'result' && msg.subtype === 'success') {
+                // Check if this is an error result (e.g., quota limit)
+                if (msg.is_error === true) {
+                    if (onError) {
+                        await onError({
+                            message: typeof msg.result === 'string' ? msg.result : 'Unknown error',
+                            rawMessage: msg,
+                        });
+                    }
+                }
+                finalResult = msg.result;
+            }
+        }
+        return finalResult;
+    }
+}

package/dist/runners/GitHubCopilotAgentRunner.d.ts

@@ -0,0 +1,12 @@
+import { BaseAgentRunner } from "./BaseAgentRunner.js";
+import { AgentModelConfig, AgentRunContext } from "./AgentRunner.js";
+export declare class GitHubCopilotAgentRunner extends BaseAgentRunner {
+    readonly kind = "githubcopilot";
+    private client;
+    private model;
+    constructor(modelConfig?: AgentModelConfig);
+    protected runInternal(ctx: AgentRunContext, emit: (msg: string) => Promise<void>, setSession: (id: string) => Promise<void>, onError?: (error: {
+        message: string;
+        rawMessage?: any;
+    }) => void | Promise<void>): Promise<string>;
+}

package/dist/runners/GitHubCopilotAgentRunner.js

@@ -0,0 +1,81 @@
+import { BaseAgentRunner } from "./BaseAgentRunner.js";
+import { ACCESS_TOKEN, BASE_URL, RUN_ID_HEADER } from "../helpers/config.js";
+import { CopilotClient } from "@github/copilot-sdk";
+export class GitHubCopilotAgentRunner extends BaseAgentRunner {
+    kind = 'githubcopilot';
+    client = null;
+    model;
+    constructor(modelConfig = {}) {
+        super();
+        this.model = modelConfig.modelId ?? 'gpt-5.2-codex';
+    }
+    async runInternal(ctx, emit, setSession, onError) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                // Init client
+                this.client = new CopilotClient({
+                    cwd: ctx.cwd,
+                });
+                await this.client.start();
+                const taskMcpServer = {
+                    type: "http",
+                    url: `${BASE_URL}/api/v1/tasks/tasks/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,
+                    },
+                });
+                if (session?.sessionId) {
+                    await setSession(session.sessionId);
+                }
+                console.log(`created session ${session.sessionId} in ${session.workspacePath}`);
+                let lastAssistantMessage = '';
+                // Subscribe to events
+                session.on('session.idle', async () => {
+                    console.log('session.idle');
+                    if (this.client) {
+                        await this.client.stop();
+                    }
+                    resolve(lastAssistantMessage);
+                });
+                session.on('assistant.reasoning', (reasoning) => {
+                    void emit(`💬 Thinking... ${reasoning.data.content}`);
+                });
+                session.on('assistant.message', (message) => {
+                    lastAssistantMessage = message.data.content ?? '';
+                    void emit(`💬 Assistant: ${message.data.content}`);
+                });
+                session.on('tool.execution_start', (toolCall) => {
+                    void emit(`🔧 Tool call: ${toolCall.data.toolName}`);
+                });
+                session.on('tool.execution_complete', () => {
+                    void emit(`🔧 Tool response`);
+                });
+                // Fire up the prompt
+                await session.send({
+                    prompt: ctx.prompt,
+                });
+            }
+            catch (err) {
+                if (this.client) {
+                    await this.client.stop();
+                }
+                if (onError) {
+                    await onError({
+                        message: err?.message ?? String(err),
+                        rawMessage: err,
+                    });
+                }
+                reject(err);
+            }
+        });
+    }
+}