@crewx/sdk 0.8.0-rc.72 → 0.8.0-rc.74

package/dist/{core/parallel → parallel}/index.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runExecutesParallel = exports.runQueriesParallel = exports.createDefaultParallelRunner = exports.ParallelRunnerTimeoutError = exports.ParallelRunner = void 0;
+exports.AgentRuntime = exports.runExecutesParallel = exports.runQueriesParallel = exports.ParallelRunnerTimeoutError = exports.ParallelRunner = void 0;
 var parallel_runner_1 = require("./parallel-runner");
 Object.defineProperty(exports, "ParallelRunner", { enumerable: true, get: function () { return parallel_runner_1.ParallelRunner; } });
-Object.defineProperty(exports, "ParallelRunnerTimeoutError", { enumerable: true, get: function () { return parallel_runner_1.ParallelRunnerTimeoutError; } });
-Object.defineProperty(exports, "createDefaultParallelRunner", { enumerable: true, get: function () { return parallel_runner_1.createDefaultParallelRunner; } });
+var parallel_runner_2 = require("./parallel-runner");
+Object.defineProperty(exports, "ParallelRunnerTimeoutError", { enumerable: true, get: function () { return parallel_runner_2.ParallelRunnerTimeoutError; } });
 var helpers_1 = require("./helpers");
 Object.defineProperty(exports, "runQueriesParallel", { enumerable: true, get: function () { return helpers_1.runQueriesParallel; } });
 Object.defineProperty(exports, "runExecutesParallel", { enumerable: true, get: function () { return helpers_1.runExecutesParallel; } });
+var agent_runtime_1 = require("./agent-runtime");
+Object.defineProperty(exports, "AgentRuntime", { enumerable: true, get: function () { return agent_runtime_1.AgentRuntime; } });
 //# sourceMappingURL=index.js.map

package/dist/{core/parallel → parallel}/parallel-runner.d.ts

@@ -1,9 +1,16 @@
 import type { ParallelRunnerMetrics, ParallelRunnerOptions, Task, TaskResult } from './types';
+/**
+ * Error raised when a task exceeds the configured per-task timeout.
+ */
 export declare class ParallelRunnerTimeoutError extends Error {
     readonly taskId: string;
     readonly timeoutMs: number;
     constructor(taskId: string, timeoutMs: number);
 }
+/**
+ * Executes tasks with bounded concurrency and cooperative cancellation support.
+ * Framework-agnostic — usable from CLI, SDK, or any consumer.
+ */
 export declare class ParallelRunner {
     private readonly defaults;
     private metrics;
@@ -13,4 +20,4 @@ export declare class ParallelRunner {
     private mergeOptions;
     private mergeCallbacks;
 }
-export declare const createDefaultParallelRunner: () => ParallelRunner;
+//# sourceMappingURL=parallel-runner.d.ts.map

package/dist/{core/parallel → parallel}/parallel-runner.js

@@ -1,8 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDefaultParallelRunner = exports.ParallelRunner = exports.ParallelRunnerTimeoutError = void 0;
+exports.ParallelRunner = exports.ParallelRunnerTimeoutError = void 0;
 const node_perf_hooks_1 = require("node:perf_hooks");
+/**
+ * Error raised when a task exceeds the configured per-task timeout.
+ */
 class ParallelRunnerTimeoutError extends Error {
+    taskId;
+    timeoutMs;
     constructor(taskId, timeoutMs) {
         super(`Task ${taskId} timed out after ${timeoutMs}ms`);
         this.taskId = taskId;
@@ -11,19 +16,24 @@ class ParallelRunnerTimeoutError extends Error {
     }
 }
 exports.ParallelRunnerTimeoutError = ParallelRunnerTimeoutError;
+/**
+ * Executes tasks with bounded concurrency and cooperative cancellation support.
+ * Framework-agnostic — usable from CLI, SDK, or any consumer.
+ */
 class ParallelRunner {
+    defaults;
+    metrics = {
+        totalTasks: 0,
+        startedTasks: 0,
+        completedTasks: 0,
+        successCount: 0,
+        failureCount: 0,
+        totalDurationMs: 0,
+        averageDurationMs: 0,
+        throughput: 0,
+    };
     constructor(defaults = {}) {
         this.defaults = defaults;
-        this.metrics = {
-            totalTasks: 0,
-            startedTasks: 0,
-            completedTasks: 0,
-            successCount: 0,
-            failureCount: 0,
-            totalDurationMs: 0,
-            averageDurationMs: 0,
-            throughput: 0,
-        };
     }
     async run(tasks, options = {}) {
         if (!Array.isArray(tasks)) {
@@ -67,29 +77,29 @@ class ParallelRunner {
             if (typeof timeoutMs === 'number' && Number.isFinite(timeoutMs) && timeoutMs > 0) {
                 timeoutPromise = new Promise((_, reject) => {
                     timeoutId = setTimeout(() => {
-                        const timeoutError = new ParallelRunnerTimeoutError(task.id, timeoutMs);
-                        controller.abort(timeoutError);
-                        reject(timeoutError);
+                        const err = new ParallelRunnerTimeoutError(task.id, timeoutMs);
+                        controller.abort(err);
+                        reject(err);
                     }, timeoutMs);
                 });
             }
-            const startedAtTask = node_perf_hooks_1.performance.now();
+            const taskStartedAt = node_perf_hooks_1.performance.now();
             const runPromise = task.run(context);
             const combinedPromise = timeoutPromise
                 ? Promise.race([runPromise, timeoutPromise])
                 : runPromise;
             try {
                 const value = await combinedPromise;
-                const finishedAtTask = node_perf_hooks_1.performance.now();
-                const durationMs = finishedAtTask - startedAtTask;
+                const taskFinishedAt = node_perf_hooks_1.performance.now();
+                const durationMs = taskFinishedAt - taskStartedAt;
                 const success = evaluateTaskSuccess(value, task);
                 const result = {
                     taskId: task.id,
                     success,
                     value,
                     durationMs,
-                    startedAt: startedAtTask,
-                    finishedAt: finishedAtTask,
+                    startedAt: taskStartedAt,
+                    finishedAt: taskFinishedAt,
                     metadata: task.metadata,
                     aborted: false,
                 };
@@ -103,16 +113,16 @@ class ParallelRunner {
                 }
             }
             catch (rawError) {
-                const finishedAtTask = node_perf_hooks_1.performance.now();
-                const durationMs = finishedAtTask - startedAtTask;
+                const taskFinishedAt = node_perf_hooks_1.performance.now();
+                const durationMs = taskFinishedAt - taskStartedAt;
                 const error = rawError instanceof Error ? rawError : new Error(String(rawError));
                 const result = {
                     taskId: task.id,
                     success: false,
                     error,
                     durationMs,
-                    startedAt: startedAtTask,
-                    finishedAt: finishedAtTask,
+                    startedAt: taskStartedAt,
+                    finishedAt: taskFinishedAt,
                     metadata: task.metadata,
                     aborted: controller.signal.aborted,
                 };
@@ -126,47 +136,42 @@ class ParallelRunner {
                 }
             }
             finally {
-                if (timeoutId) {
+                if (timeoutId)
                     clearTimeout(timeoutId);
-                }
-                if (timeoutPromise) {
+                // Prevent unhandled rejections if timeout fired before task finished
+                if (timeoutPromise)
                     runPromise.catch(() => undefined);
-                }
             }
         };
         const worker = async () => {
             while (true) {
-                if (aborted) {
+                if (aborted)
                     break;
-                }
-                const currentIndex = cursor;
-                if (currentIndex >= tasks.length) {
+                const index = cursor;
+                if (index >= tasks.length)
                     break;
-                }
                 cursor += 1;
-                const task = tasks[currentIndex];
-                if (!task) {
+                const task = tasks[index];
+                if (!task)
                     break;
-                }
                 await executeTask(task);
-                if (aborted) {
+                if (aborted)
                     break;
-                }
             }
         };
-        const workers = [];
         const workerCount = Math.min(maxConcurrency, tasks.length);
-        for (let i = 0; i < workerCount; i += 1) {
+        const workers = [];
+        for (let i = 0; i < workerCount; i++) {
             workers.push(worker());
         }
         await Promise.all(workers);
         const finishedAt = node_perf_hooks_1.performance.now();
         const totalDurationMs = finishedAt - startedAt;
         const averageDurationMs = results.length
-            ? results.reduce((sum, item) => sum + item.durationMs, 0) / results.length
+            ? results.reduce((sum, r) => sum + r.durationMs, 0) / results.length
             : 0;
         const throughput = totalDurationMs > 0
-            ? (results.length / (totalDurationMs / 1000))
+            ? results.length / (totalDurationMs / 1000)
             : results.length;
         this.metrics = {
             totalTasks: tasks.length,
@@ -193,38 +198,29 @@ class ParallelRunner {
         };
     }
     mergeCallbacks(base, override) {
-        if (!base && !override) {
+        if (!base && !override)
             return undefined;
-        }
         return {
             onTaskStart: async (task) => {
-                if (base?.onTaskStart) {
+                if (base?.onTaskStart)
                     await base.onTaskStart(task);
-                }
-                if (override?.onTaskStart) {
+                if (override?.onTaskStart)
                     await override.onTaskStart(task);
-                }
             },
             onTaskComplete: async (result) => {
-                if (base?.onTaskComplete) {
+                if (base?.onTaskComplete)
                     await base.onTaskComplete(result);
-                }
-                if (override?.onTaskComplete) {
+                if (override?.onTaskComplete)
                     await override.onTaskComplete(result);
-                }
             },
             onError: async (task, error, durationMs) => {
-                if (base?.onError) {
+                if (base?.onError)
                     await base.onError(task, error, durationMs);
-                }
-                if (override?.onError) {
+                if (override?.onError)
                     await override.onError(task, error, durationMs);
-                }
             },
         };
     }
 }
 exports.ParallelRunner = ParallelRunner;
-const createDefaultParallelRunner = () => new ParallelRunner();
-exports.createDefaultParallelRunner = createDefaultParallelRunner;
 //# sourceMappingURL=parallel-runner.js.map

package/dist/parallel/types.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Types for the parallel execution module.
+ */
+/** A unit of work that can be executed by the ParallelRunner. */
+export interface Task<T> {
+    /** Unique identifier for the task. Used for logging and metrics. */
+    id: string;
+    /** Optional metadata associated with the task. */
+    metadata?: Record<string, unknown>;
+    /** Perform the actual work, respecting the provided execution context. */
+    run: (context: TaskExecutionContext) => Promise<T>;
+}
+/** Context information passed to each task during execution. */
+export interface TaskExecutionContext {
+    /** AbortSignal triggered on timeout or cooperative cancellation. */
+    signal: AbortSignal;
+}
+/** Result produced by the ParallelRunner for each executed task. */
+export interface TaskResult<T> {
+    taskId: string;
+    success: boolean;
+    value?: T;
+    error?: Error;
+    /** Milliseconds spent executing the task. */
+    durationMs: number;
+    /** performance.now() timestamp when the task started. */
+    startedAt: number;
+    /** performance.now() timestamp when the task finished. */
+    finishedAt: number;
+    /** Metadata forwarded from the original task definition. */
+    metadata?: Record<string, unknown>;
+    /** Whether the failure was caused by an abort/timeout event. */
+    aborted?: boolean;
+}
+/** Callback hooks for task lifecycle instrumentation. */
+export interface TaskCallbacks<T> {
+    onTaskStart?: (task: Task<T>) => void | Promise<void>;
+    onTaskComplete?: (result: TaskResult<T>) => void | Promise<void>;
+    onError?: (task: Task<T>, error: Error, durationMs: number) => void | Promise<void>;
+}
+/** Execution options for the ParallelRunner. */
+export interface ParallelRunnerOptions<T = unknown> {
+    /** Maximum concurrent tasks. Defaults to 5. */
+    maxConcurrency?: number;
+    /** Per-task timeout in milliseconds. Undefined disables timeout. */
+    timeoutMs?: number;
+    /** Stop scheduling new tasks after any failure. */
+    failFast?: boolean;
+    /** Lifecycle callback hooks. */
+    callbacks?: TaskCallbacks<T>;
+    /** Determine whether a resolved value is considered successful. Defaults to always true. */
+    evaluateTaskSuccess?: (value: T, task: Task<T>) => boolean;
+}
+/** Metrics summary produced after a ParallelRunner.run() call. */
+export interface ParallelRunnerMetrics {
+    totalTasks: number;
+    startedTasks: number;
+    completedTasks: number;
+    successCount: number;
+    failureCount: number;
+    totalDurationMs: number;
+    averageDurationMs: number;
+    throughput: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/parallel/types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Types for the parallel execution module.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/parsers/agent-call.util.d.ts

@@ -1,3 +1,6 @@
 import type { TaskLogEntry } from '../types/task-log.types';
+/** Detect crewx execute/x command pattern */
 export declare function isAgentCallCommand(command: string): boolean;
+/** Extract agent_call entry from crewx x "@agent ..." command */
 export declare function parseAgentCall(timestamp: string, command: string): TaskLogEntry;
+//# sourceMappingURL=agent-call.util.d.ts.map

package/dist/parsers/agent-call.util.js

@@ -2,9 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isAgentCallCommand = isAgentCallCommand;
 exports.parseAgentCall = parseAgentCall;
+/** Detect crewx execute/x command pattern */
 function isAgentCallCommand(command) {
     return /crewx\s+(x|execute)\s/.test(command);
 }
+/** Extract agent_call entry from crewx x "@agent ..." command */
 function parseAgentCall(timestamp, command) {
     const agentMatch = command.match(/@(\S+)/);
     return {

package/dist/parsers/api.parser.d.ts

@@ -0,0 +1,10 @@
+import type { TaskLogEntry } from '../types/task-log.types';
+/**
+ * Parse API provider (Vercel AI SDK) structured JSONL events into TaskLogEntry[].
+ *
+ * API events:
+ * - { type: "api_tool_call", toolCallId: "...", toolName: "...", toolInput: "..." }
+ * - { type: "api_tool_result", toolCallId: "...", toolName: "...", result: "..." }
+ */
+export declare function parseApiEvent(timestamp: string, parsed: Record<string, unknown>): TaskLogEntry[];
+//# sourceMappingURL=api.parser.d.ts.map

package/dist/parsers/api.parser.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseApiEvent = parseApiEvent;
+/**
+ * Parse API provider (Vercel AI SDK) structured JSONL events into TaskLogEntry[].
+ *
+ * API events:
+ * - { type: "api_tool_call", toolCallId: "...", toolName: "...", toolInput: "..." }
+ * - { type: "api_tool_result", toolCallId: "...", toolName: "...", result: "..." }
+ */
+function parseApiEvent(timestamp, parsed) {
+    const type = parsed.type;
+    if (type === 'api_tool_call') {
+        const toolName = String(parsed.toolName || '');
+        const toolUseId = parsed.toolCallId;
+        const toolInput = String(parsed.toolInput || '{}');
+        return [{ timestamp, type: 'tool_use', toolName, toolUseId, toolInput }];
+    }
+    if (type === 'api_tool_result') {
+        const toolUseId = parsed.toolCallId;
+        const resultPreview = String(parsed.result || '');
+        return [{ timestamp, type: 'tool_result', toolUseId, resultPreview, isError: false }];
+    }
+    return [];
+}
+//# sourceMappingURL=api.parser.js.map

package/dist/parsers/claude.parser.d.ts

@@ -1,2 +1,10 @@
 import type { TaskLogEntry } from '../types/task-log.types';
+/**
+ * Parse Claude stream-json events into TaskLogEntry[].
+ *
+ * Claude events:
+ * - { type: "assistant", message: { content: [{ type: "text"|"tool_use", ... }] } }
+ * - { type: "user", message: { content: [{ type: "tool_result", ... }] } }
+ */
 export declare function parseClaudeEvent(timestamp: string, parsed: Record<string, unknown>): TaskLogEntry[];
+//# sourceMappingURL=claude.parser.d.ts.map

package/dist/parsers/claude.parser.js

@@ -2,6 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseClaudeEvent = parseClaudeEvent;
 const agent_call_util_1 = require("./agent-call.util");
+/**
+ * Parse Claude stream-json events into TaskLogEntry[].
+ *
+ * Claude events:
+ * - { type: "assistant", message: { content: [{ type: "text"|"tool_use", ... }] } }
+ * - { type: "user", message: { content: [{ type: "tool_result", ... }] } }
+ */
 function parseClaudeEvent(timestamp, parsed) {
     const msg = parsed.message;
     const content = msg?.content;
@@ -38,7 +45,21 @@ function parseClaudeBlock(timestamp, block) {
     if (blockType === 'tool_result') {
         const isError = Boolean(block.is_error);
         const toolUseId = block.tool_use_id;
-        const output = String(block.output || block.content || '');
+        const raw = block.output ?? block.content ?? '';
+        let output;
+        if (typeof raw === 'string') {
+            output = raw;
+        }
+        else if (Array.isArray(raw)) {
+            // Claude tool_result content can be [{ type: "text", text: "..." }, ...]
+            output = raw
+                .filter(c => c.type === 'text' && typeof c.text === 'string')
+                .map(c => c.text)
+                .join('\n');
+        }
+        else {
+            output = JSON.stringify(raw);
+        }
         return { timestamp, type: 'tool_result', toolUseId, resultPreview: output, isError };
     }
     return null;

package/dist/parsers/codex.parser.d.ts

@@ -1,2 +1,10 @@
 import type { TaskLogEntry } from '../types/task-log.types';
+/**
+ * Parse Codex experimental-json events into TaskLogEntry[].
+ *
+ * Codex events:
+ * - { type: "item.started", item: { type: "command_execution", command } }
+ * - { type: "item.completed", item: { type: "command_execution"|"message"|"text"|"reasoning"|"tool_use"|"tool_result", ... } }
+ */
 export declare function parseCodexEvent(timestamp: string, parsed: Record<string, unknown>): TaskLogEntry[];
+//# sourceMappingURL=codex.parser.d.ts.map

package/dist/parsers/codex.parser.js

@@ -2,6 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseCodexEvent = parseCodexEvent;
 const agent_call_util_1 = require("./agent-call.util");
+/**
+ * Parse Codex experimental-json events into TaskLogEntry[].
+ *
+ * Codex events:
+ * - { type: "item.started", item: { type: "command_execution", command } }
+ * - { type: "item.completed", item: { type: "command_execution"|"message"|"text"|"reasoning"|"tool_use"|"tool_result", ... } }
+ */
 function parseCodexEvent(timestamp, parsed) {
     const type = parsed.type;
     const item = parsed.item;
@@ -29,6 +36,7 @@ function parseItemStarted(timestamp, item) {
 }
 function parseItemCompleted(timestamp, item) {
     const itemType = item.type;
+    // assistant_message / message / text
     if (itemType === 'message' || itemType === 'text') {
         const content = item.content;
         if (Array.isArray(content)) {
@@ -45,11 +53,13 @@ function parseItemCompleted(timestamp, item) {
     if (itemType === 'reasoning') {
         return { timestamp, type: 'text', content: String(item.text || '') };
     }
+    // command_execution completed → tool_result (with error support)
     if (itemType === 'command_execution') {
         const output = String(item.aggregated_output || item.output || '');
         const isError = Boolean(item.is_error);
         return { timestamp, type: 'tool_result', resultPreview: output, isError };
     }
+    // tool_use from Codex item.completed
     if (itemType === 'tool_use') {
         const toolName = String(item.name || item.tool_name || '');
         const input = item.input;
@@ -61,6 +71,7 @@ function parseItemCompleted(timestamp, item) {
         }
         return { timestamp, type: 'tool_use', toolName, toolInput: inputStr };
     }
+    // tool_result from Codex item.completed
     if (itemType === 'tool_result') {
         const isError = Boolean(item.is_error);
         const output = String(item.output || item.content || '');

package/dist/parsers/copilot.parser.d.ts

@@ -1,2 +1,11 @@
 import type { TaskLogEntry } from '../types/task-log.types';
+/**
+ * Parse Copilot json events into TaskLogEntry[].
+ *
+ * Copilot events:
+ * - { type: "tool.execution_start", data: { toolName, arguments } }
+ * - { type: "tool.execution_complete", data: { result?: { content }, error?: { message } } }
+ * - { type: "assistant.message", data: { content } }
+ */
 export declare function parseCopilotEvent(timestamp: string, parsed: Record<string, unknown>): TaskLogEntry[];
+//# sourceMappingURL=copilot.parser.d.ts.map

package/dist/parsers/copilot.parser.js

@@ -2,6 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseCopilotEvent = parseCopilotEvent;
 const agent_call_util_1 = require("./agent-call.util");
+/**
+ * Parse Copilot json events into TaskLogEntry[].
+ *
+ * Copilot events:
+ * - { type: "tool.execution_start", data: { toolName, arguments } }
+ * - { type: "tool.execution_complete", data: { result?: { content }, error?: { message } } }
+ * - { type: "assistant.message", data: { content } }
+ */
 function parseCopilotEvent(timestamp, parsed) {
     const type = parsed.type;
     const data = parsed.data;

package/dist/parsers/gemini.parser.d.ts

@@ -1,2 +1,12 @@
 import type { TaskLogEntry } from '../types/task-log.types';
+/**
+ * Parse Gemini stream-json events into TaskLogEntry[].
+ *
+ * Gemini events:
+ * - { type: "message", role: "assistant", delta: true, content: "..." }
+ * - { type: "init", ... } (ignored)
+ * - { type: "tool_use", tool_name, tool_id, parameters }
+ * - { type: "tool_result", tool_id, status, output }
+ */
 export declare function parseGeminiEvent(timestamp: string, parsed: Record<string, unknown>): TaskLogEntry[];
+//# sourceMappingURL=gemini.parser.d.ts.map

package/dist/parsers/gemini.parser.js

@@ -2,6 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseGeminiEvent = parseGeminiEvent;
 const agent_call_util_1 = require("./agent-call.util");
+/**
+ * Parse Gemini stream-json events into TaskLogEntry[].
+ *
+ * Gemini events:
+ * - { type: "message", role: "assistant", delta: true, content: "..." }
+ * - { type: "init", ... } (ignored)
+ * - { type: "tool_use", tool_name, tool_id, parameters }
+ * - { type: "tool_result", tool_id, status, output }
+ */
 function parseGeminiEvent(timestamp, parsed) {
     const type = parsed.type;
     if (type === 'message') {
@@ -31,6 +40,7 @@ function parseGeminiEvent(timestamp, parsed) {
         const isError = parsed.status !== 'success';
         return [{ timestamp, type: 'tool_result', toolUseId, resultPreview: output, isError }];
     }
+    // init and other events: skip
     return [];
 }
 //# sourceMappingURL=gemini.parser.js.map

package/dist/parsers/opencode.parser.d.ts

@@ -0,0 +1,12 @@
+import type { TaskLogEntry } from '../types/task-log.types';
+/**
+ * Parse OpenCode stream-json events (--format json) into TaskLogEntry[].
+ *
+ * OpenCode events:
+ * - { type: "step_start", sessionID: "ses_...", part: { type: "step-start" } }
+ * - { type: "text", part: { type: "text", text: "..." } }
+ * - { type: "step_finish", part: { reason: "stop", tokens: { total, input, output, reasoning, cache: { write, read } }, cost: 0 } }
+ * - { type: "tool_use", part: { type: "tool", tool: "bash"|"write"|..., callID: "...", state: { status, input, output } } }
+ */
+export declare function parseOpencodeEvent(timestamp: string, parsed: Record<string, unknown>): TaskLogEntry[];
+//# sourceMappingURL=opencode.parser.d.ts.map

package/dist/parsers/opencode.parser.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseOpencodeEvent = parseOpencodeEvent;
+/**
+ * Parse OpenCode stream-json events (--format json) into TaskLogEntry[].
+ *
+ * OpenCode events:
+ * - { type: "step_start", sessionID: "ses_...", part: { type: "step-start" } }
+ * - { type: "text", part: { type: "text", text: "..." } }
+ * - { type: "step_finish", part: { reason: "stop", tokens: { total, input, output, reasoning, cache: { write, read } }, cost: 0 } }
+ * - { type: "tool_use", part: { type: "tool", tool: "bash"|"write"|..., callID: "...", state: { status, input, output } } }
+ */
+function parseOpencodeEvent(timestamp, parsed) {
+    const type = parsed.type;
+    if (type === 'text') {
+        const part = parsed.part;
+        const text = part?.text;
+        if (!text)
+            return [];
+        return [{ timestamp, type: 'text', content: text }];
+    }
+    if (type === 'tool_use') {
+        const part = parsed.part;
+        if (!part)
+            return [];
+        const tool = String(part.tool || '');
+        const toolUseId = String(part.callID || '');
+        const state = part.state;
+        const status = String(state?.status || '');
+        const input = state?.input;
+        const inputStr = extractToolInput(input);
+        const entries = [
+            { timestamp, type: 'tool_use', toolName: tool, toolUseId, toolInput: inputStr },
+        ];
+        if (status === 'completed' && state?.output !== undefined) {
+            const output = state.output;
+            const outputStr = typeof output === 'string' ? output : JSON.stringify(output);
+            entries.push({ timestamp, type: 'tool_result', toolUseId, resultPreview: outputStr, isError: false });
+        }
+        else if (status === 'error') {
+            entries.push({
+                timestamp,
+                type: 'tool_result',
+                toolUseId,
+                resultPreview: String(state?.error || 'tool error'),
+                isError: true,
+            });
+        }
+        return entries;
+    }
+    // step_start, step_finish: skip (usage is extracted by parse-usage.ts)
+    return [];
+}
+/**
+ * Extract a human-friendly string from OpenCode tool input.
+ *
+ * Matches Claude/Gemini parser behaviour:
+ *  - bash-like  → input.command   ("mkdir -p /tmp/foo")
+ *  - file tools → input.filePath  ("/tmp/foo/bar.ts")
+ *  - otherwise  → JSON.stringify fallback
+ */
+function extractToolInput(input) {
+    if (typeof input === 'string')
+        return input;
+    if (!input || typeof input !== 'object')
+        return JSON.stringify(input ?? {});
+    const obj = input;
+    if (obj.command)
+        return String(obj.command);
+    if (obj.filePath)
+        return String(obj.filePath);
+    if (obj.pattern)
+        return String(obj.pattern);
+    return JSON.stringify(obj);
+}
+//# sourceMappingURL=opencode.parser.js.map

package/dist/parsers/router.d.ts

@@ -0,0 +1,7 @@
+/**
+ * parseStdoutEvent — routes a single stdout JSONL event to the appropriate provider parser.
+ * Returns TaskLogEntry[] (may be empty if event is not recognized or irrelevant).
+ */
+import type { TaskLogEntry } from '../types/task-log.types';
+export declare function parseStdoutEvent(timestamp: string, message: string): TaskLogEntry[];
+//# sourceMappingURL=router.d.ts.map