@crewx/sdk 0.8.0-rc.80 → 0.8.0-rc.83

package/dist/plugins/file-logger.js

@@ -1,87 +0,0 @@
-"use strict";
-/**
- * FileLoggerPlugin — writes structured log files to .crewx/logs/.
- *
- * Subscribes to task:start and task:end events and writes one log file
- * per task execution. Format mirrors cli-bak TaskManagementService for
- * backward compatibility.
- *
- * File name: {YYYYMMDDTHHmmss}_{traceId}.log
- * e.g. 20260412T145044_tsk_AbCdEfGh.log
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileLoggerPlugin = void 0;
-const fs_1 = require("fs");
-const path_1 = require("path");
-const plugin_1 = require("../plugin");
-const timestamp_1 = require("../utils/timestamp");
-class FileLoggerPlugin extends plugin_1.CrewxPlugin {
-    name = 'file-logger';
-    unsubs = [];
-    logFiles = new Map();
-    logsDir;
-    version;
-    constructor(opts) {
-        super();
-        this.logsDir = (0, path_1.join)(opts?.workspaceRoot ?? process.cwd(), '.crewx', 'logs');
-        this.version = opts?.version ?? 'unknown';
-    }
-    attach(crewx) {
-        this.unsubs.push(crewx.on('task:start', (event) => {
-            try {
-                if (!(0, fs_1.existsSync)(this.logsDir)) {
-                    (0, fs_1.mkdirSync)(this.logsDir, { recursive: true });
-                }
-                const ts = (0, timestamp_1.formatTimestamp)(event.timestamp);
-                const logFile = (0, path_1.join)(this.logsDir, `${ts}_${event.traceId}.log`);
-                this.logFiles.set(event.traceId, logFile);
-                const header = `=== TASK LOG: ${event.traceId} ===\n` +
-                    `CrewX Version: ${this.version}\n` +
-                    `Mode: ${event.mode}\n` +
-                    `Agent: ${event.agentRef}\n` +
-                    `Started: ${event.timestamp.toLocaleString()}\n` +
-                    `Message: ${event.message}\n` +
-                    `\n`;
-                (0, fs_1.writeFileSync)(logFile, header, { encoding: 'utf8', mode: 0o600 });
-            }
-            catch {
-                // Non-fatal: logging must never crash the main process
-            }
-        }), crewx.on('task:output', (event) => {
-            try {
-                const logFile = this.logFiles.get(event.traceId);
-                if (!logFile)
-                    return;
-                const ts = new Date().toISOString();
-                (0, fs_1.appendFileSync)(logFile, `[${ts}] STDOUT: ${event.output}\n`, 'utf8');
-            }
-            catch {
-                // Non-fatal
-            }
-        }), crewx.on('task:end', (event) => {
-            try {
-                const logFile = this.logFiles.get(event.traceId);
-                if (!logFile)
-                    return;
-                const ts = new Date().toLocaleString();
-                const status = event.error
-                    ? `failed: ${event.error.message}`
-                    : 'completed successfully';
-                const completion = `[${ts}] INFO: Task ${status} in ${event.durationMs}ms\n` +
-                    `[${ts}] INFO: Process closed with exit code: ${event.error ? 1 : 0}\n`;
-                (0, fs_1.appendFileSync)(logFile, completion, 'utf8');
-                this.logFiles.delete(event.traceId);
-            }
-            catch {
-                // Non-fatal
-            }
-        }));
-    }
-    detach(_crewx) {
-        this.unsubs.forEach(fn => fn());
-        this.unsubs = [];
-        this.logFiles.clear();
-    }
-}
-exports.FileLoggerPlugin = FileLoggerPlugin;
-//# sourceMappingURL=file-logger.js.map

package/dist/plugins/sqlite-tracing.js

@@ -1,112 +0,0 @@
-"use strict";
-/**
- * SqliteTracingPlugin — records task execution data to ~/.crewx/crewx.db.
- *
- * Subscribes to task:start, task:output, and task:end events and persists
- * full records to the global CrewX SQLite database. Matches the schema
- * written by the global crewx CLI (0.8.x).
- *
- * DB location: {dbRoot}/.crewx/crewx.db
- *   (dbRoot defaults to os.homedir())
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SqliteTracingPlugin = void 0;
-const fs_1 = require("fs");
-const path_1 = require("path");
-const os_1 = require("os");
-const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
-const plugin_1 = require("../plugin");
-const workspace_1 = require("../utils/workspace");
-/** Detect host AI caller agent ID from environment (set by parent crewx process). */
-function detectCallerAgentId() {
-    return process.env['CREWX_CALLER_AGENT_ID'] ?? null;
-}
-class SqliteTracingPlugin extends plugin_1.CrewxPlugin {
-    name = 'sqlite-tracing';
-    db = null;
-    unsubs = [];
-    dbPath;
-    version;
-    constructor(opts) {
-        super();
-        this.dbPath = (0, path_1.join)(opts?.dbRoot ?? (0, os_1.homedir)(), '.crewx', 'crewx.db');
-        this.version = opts?.version ?? 'unknown';
-    }
-    attach(crewx) {
-        // Ensure parent directory exists
-        const dbDir = (0, path_1.dirname)(this.dbPath);
-        if (!(0, fs_1.existsSync)(dbDir)) {
-            (0, fs_1.mkdirSync)(dbDir, { recursive: true });
-        }
-        this.db = new better_sqlite3_1.default(this.dbPath);
-        // Fallback workspace only when crewx.yaml/.yml exists in cwd — prevents phantom workspace entries
-        const cwd = process.cwd();
-        const yamlExists = (0, fs_1.existsSync)((0, path_1.join)(cwd, 'crewx.yaml')) || (0, fs_1.existsSync)((0, path_1.join)(cwd, 'crewx.yml'));
-        const fallbackWorkspaceId = yamlExists ? (0, workspace_1.hashWorkspaceId)(cwd) : null;
-        const fallbackWorkspaceName = yamlExists ? (0, path_1.basename)(cwd) : null;
-        const callerAgentId = detectCallerAgentId();
-        const command = process.argv.join(' ');
-        this.unsubs.push(crewx.on('task:start', (event) => {
-            try {
-                const metadata = event.metadata
-                    ? JSON.stringify(event.metadata)
-                    : JSON.stringify({ provider: event.provider ?? 'cli/claude' });
-                this.db.prepare(`INSERT OR IGNORE INTO tasks
-               (id, agent_id, prompt, mode, status, pid, started_at,
-                crewx_version, platform,
-                model, rendered_prompt, command, coding_agent_command,
-                workspace_id, workspace_name,
-                caller_agent_id, trace_id, metadata, thread_id)
-             VALUES (?, ?, ?, ?, 'running', ?, ?,
-                     ?, ?,
-                     ?, ?, ?, ?,
-                     ?, ?,
-                     ?, ?, ?, ?)`).run(event.traceId, event.agentRef.replace(/^@/, ''), event.message, event.mode, event.pid ?? null, event.timestamp.toISOString(), this.version, event.platform ?? 'cli', event.model ?? null, event.renderedPrompt ?? null, command, event.codingAgentCommand ?? null, event.workspaceId ?? fallbackWorkspaceId, event.workspaceName ?? fallbackWorkspaceName, callerAgentId, event.traceId, // trace_id mirrors the task id for root requests
-                metadata, event.threadId ?? null);
-            }
-            catch {
-                // Non-fatal: tracing must never crash the main process
-            }
-        }), crewx.on('task:output', (event) => {
-            try {
-                const row = this.db.prepare('SELECT logs FROM tasks WHERE id=?').get(event.traceId);
-                const existing = row?.logs ? JSON.parse(row.logs) : [];
-                existing.push({
-                    timestamp: event.timestamp.toISOString(),
-                    level: event.level ?? 'stdout',
-                    message: event.output,
-                });
-                this.db.prepare('UPDATE tasks SET logs=? WHERE id=?').run(JSON.stringify(existing), event.traceId);
-            }
-            catch {
-                // Non-fatal
-            }
-        }), crewx.on('task:end', (event) => {
-            try {
-                const status = event.error ? 'failed' : 'success';
-                this.db.prepare(`UPDATE tasks
-             SET status=?, result=?, error=?,
-                 completed_at=?, duration_ms=?,
-                 exit_code=?,
-                 input_tokens=?, output_tokens=?, cached_input_tokens=?,
-                 cost_usd=?,
-                 model=COALESCE(?, model)
-             WHERE id=?`).run(status, event.result ?? null, event.error ? JSON.stringify(event.error) : null, event.timestamp.toISOString(), event.durationMs, event.exitCode ?? null, event.inputTokens ?? 0, event.outputTokens ?? 0, event.cachedInputTokens ?? 0, event.costUsd ?? 0, event.model ?? null, event.traceId);
-            }
-            catch {
-                // Non-fatal
-            }
-        }));
-    }
-    detach(_crewx) {
-        this.unsubs.forEach(fn => fn());
-        this.unsubs = [];
-        this.db?.close();
-        this.db = null;
-    }
-}
-exports.SqliteTracingPlugin = SqliteTracingPlugin;
-//# sourceMappingURL=sqlite-tracing.js.map

package/dist/provider/bridge.browser.js

@@ -1,49 +0,0 @@
-"use strict";
-/**
- * Browser-safe provider bridge.
- * Registry pattern only — no child_process / CLI spawn.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProviderError = void 0;
-exports.registerProviderFactory = registerProviderFactory;
-exports.createProvider = createProvider;
-class ProviderError extends Error {
-    providerStr;
-    constructor(message, providerStr) {
-        super(message);
-        this.providerStr = providerStr;
-        this.name = 'ProviderError';
-    }
-}
-exports.ProviderError = ProviderError;
-// ── Provider factory registry ───────────────────────────────────────────────
-const _providerFactories = new Map();
-/**
- * Register a provider factory for a given namespace.
- *
- * @example
- * registerProviderFactory('api', (id, providerStr) => ({
- *   async query(message, options) { ... },
- *   async execute(message, options) { ... },
- * }));
- */
-function registerProviderFactory(namespace, factory) {
-    _providerFactories.set(namespace, factory);
-}
-/**
- * Create a provider runtime for the given provider string.
- * Browser version — only supports registered factories (no CLI fallback).
- */
-function createProvider(providerStr) {
-    const parts = providerStr.split('/');
-    if (parts.length !== 2) {
-        throw new ProviderError(`Invalid provider format: "${providerStr}". Expected namespace/id (e.g., api/webllm)`, providerStr);
-    }
-    const [namespace, id] = parts;
-    const factory = _providerFactories.get(namespace);
-    if (factory) {
-        return factory(id, providerStr);
-    }
-    throw new ProviderError(`Unsupported provider namespace: "${namespace}". Register a factory with registerProviderFactory('${namespace}', factory).`, providerStr);
-}
-//# sourceMappingURL=bridge.browser.js.map

package/dist/provider/bridge.js

@@ -1,381 +0,0 @@
-"use strict";
-/**
- * Provider bridge: creates a runtime that can invoke AI providers.
- *
- * Supports a registry pattern — built-in cli/* providers are registered by default,
- * and additional namespaces (e.g. api/*, webllm/*) can be added via registerProviderFactory().
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClientToolCallRequiredError = exports.ProviderError = void 0;
-exports.parseStreamJsonOutput = parseStreamJsonOutput;
-exports.parseResultEventUsage = parseResultEventUsage;
-exports.registerProviderFactory = registerProviderFactory;
-exports.createProvider = createProvider;
-const child_process_1 = require("child_process");
-const parse_usage_js_1 = require("./parse-usage.js");
-function parseStreamJsonOutput(raw) {
-    const lines = raw.split('\n').filter(l => l.trim());
-    const assistantTexts = [];
-    const geminiDeltaTokens = [];
-    const copilotTexts = [];
-    const codexTexts = [];
-    const opencodeTexts = [];
-    let resultText = null;
-    for (const line of lines) {
-        try {
-            const parsed = JSON.parse(line);
-            // Claude format: { type: 'assistant', message: { content: [...] } }
-            if (parsed.type === 'assistant' && Array.isArray(parsed.message?.content)) {
-                for (const block of parsed.message.content) {
-                    if (block.type === 'text' && typeof block.text === 'string' && block.text.trim()) {
-                        assistantTexts.push(block.text.trim());
-                    }
-                }
-            }
-            // Gemini format: { type: 'message', role: 'assistant', delta: true, content: '...' }
-            if (parsed.type === 'message' &&
-                parsed.role === 'assistant' &&
-                parsed.delta === true &&
-                typeof parsed.content === 'string') {
-                geminiDeltaTokens.push(parsed.content);
-            }
-            // Copilot format: { type: 'assistant.message', data: { content: '...' } }
-            if (parsed.type === 'assistant.message' &&
-                typeof parsed.data?.content === 'string') {
-                const content = parsed.data.content;
-                if (content.trim())
-                    copilotTexts.push(content.trim());
-            }
-            // Codex format: { type: 'item.completed', item: { type: 'message'|'agent_message', text: '...' } }
-            // codex-specific: both 'message' and 'agent_message' item types are accepted
-            if (parsed.type === 'item.completed' &&
-                (parsed.item?.type === 'message' || parsed.item?.type === 'agent_message') &&
-                typeof parsed.item?.text === 'string') {
-                const text = parsed.item.text;
-                if (text.trim())
-                    codexTexts.push(text.trim());
-            }
-            // OpenCode format: { type: 'text', part: { text: '...' } }
-            if (parsed.type === 'text' && typeof parsed.part?.text === 'string') {
-                const text = parsed.part.text;
-                if (text.trim())
-                    opencodeTexts.push(text.trim());
-            }
-            if (parsed.type === 'result' && typeof parsed.result === 'string') {
-                resultText = parsed.result;
-            }
-        }
-        catch {
-            // Not valid JSON line — skip
-        }
-    }
-    if (assistantTexts.length > 0)
-        return assistantTexts.join('\n\n');
-    if (geminiDeltaTokens.length > 0)
-        return geminiDeltaTokens.join('');
-    if (copilotTexts.length > 0)
-        return copilotTexts.join('\n\n');
-    if (codexTexts.length > 0)
-        return codexTexts.join('\n\n');
-    if (opencodeTexts.length > 0)
-        return opencodeTexts.join('');
-    if (resultText)
-        return resultText;
-    return raw.trim();
-}
-function parseResultEventUsage(raw) {
-    const parsed = (0, parse_usage_js_1.parseUsage)(raw);
-    if (!parsed)
-        return null;
-    return {
-        inputTokens: parsed.inputTokens,
-        outputTokens: parsed.outputTokens,
-        cachedInputTokens: parsed.cachedInputTokens,
-        costUsd: 0,
-    };
-}
-class ProviderError extends Error {
-    providerStr;
-    constructor(message, providerStr) {
-        super(message);
-        this.providerStr = providerStr;
-        this.name = 'ProviderError';
-    }
-}
-exports.ProviderError = ProviderError;
-/**
- * Thrown by VercelProviderRuntime when generateText() encounters a tool without
- * an execute function (client tool). The caller should return requires_action
- * to the client, collect the tool result, and call continueWithToolResults().
- */
-class ClientToolCallRequiredError extends Error {
-    toolCall;
-    continuationState;
-    name = 'ClientToolCallRequiredError';
-    constructor(toolCall, continuationState) {
-        super(`Client tool call required: ${toolCall.toolName}`);
-        this.toolCall = toolCall;
-        this.continuationState = continuationState;
-    }
-}
-exports.ClientToolCallRequiredError = ClientToolCallRequiredError;
-// ── Provider factory registry ───────────────────────────────────────────────
-const _providerFactories = new Map();
-/**
- * Register a provider factory for a given namespace.
- *
- * @example
- * // Register an API-based provider namespace
- * registerProviderFactory('api', (id, providerStr) => new MyApiProvider(id));
- *
- * // Now createProvider('api/claude') works
- * const provider = createProvider('api/claude');
- */
-function registerProviderFactory(namespace, factory) {
-    _providerFactories.set(namespace, factory);
-}
-// CLI command mapping for each supported provider id
-const CLI_COMMANDS = {
-    claude: 'claude',
-    gemini: 'gemini',
-    copilot: 'copilot', // GitHub Copilot CLI (standalone binary)
-    codex: 'codex',
-    opencode: 'opencode', // OpenCode CLI (--format json stream)
-};
-/**
- * Create a provider runtime for the given provider string.
- *
- * Looks up the namespace in the provider registry first.
- * Falls back to built-in cli/* providers for backward compatibility.
- *
- * @param providerStr - Provider string in namespace/id format (e.g., 'cli/claude', 'api/claude')
- * @throws ProviderError for unknown or unsupported providers
- */
-function createProvider(providerStr) {
-    const parts = providerStr.split('/');
-    if (parts.length !== 2) {
-        throw new ProviderError(`Invalid provider format: "${providerStr}". Expected namespace/id (e.g., cli/claude)`, providerStr);
-    }
-    const [namespace, id] = parts;
-    // Check registry first (covers both user-registered and built-in cli namespace)
-    const factory = _providerFactories.get(namespace);
-    if (factory) {
-        return factory(id, providerStr);
-    }
-    // Built-in cli/* fallback (for backward compatibility when cli factory is not explicitly registered)
-    if (namespace === 'cli') {
-        const cliCommand = CLI_COMMANDS[id];
-        if (!cliCommand) {
-            throw new ProviderError(`Unknown CLI provider id: "${id}". Supported: ${Object.keys(CLI_COMMANDS).join(', ')}`, providerStr);
-        }
-        return new CliProviderRuntime(id, cliCommand, providerStr);
-    }
-    throw new ProviderError(`Unsupported provider namespace: "${namespace}". Register a factory with registerProviderFactory('${namespace}', factory).`, providerStr);
-}
-/**
- * Provider runtime that spawns a CLI process and collects its output.
- */
-class CliProviderRuntime {
-    providerId;
-    cliCommand;
-    providerStr;
-    constructor(providerId, cliCommand, providerStr) {
-        this.providerId = providerId;
-        this.cliCommand = cliCommand;
-        this.providerStr = providerStr;
-    }
-    async execute(message, options) {
-        const { args, stdinMessage } = this.buildArgs(message, options, true);
-        options?.onCommand?.(`${this.cliCommand} ${args.join(' ')}`);
-        return this.runProcess(args, options, stdinMessage);
-    }
-    async query(message, options) {
-        const { args, stdinMessage } = this.buildArgs(message, options);
-        options?.onCommand?.(`${this.cliCommand} ${args.join(' ')}`);
-        return this.runProcess(args, options, stdinMessage);
-    }
-    runProcess(args, options, stdinMessage) {
-        return new Promise((resolve, reject) => {
-            const proc = (0, child_process_1.spawn)(this.cliCommand, args, {
-                env: { ...process.env, ...(options?.env ?? {}) },
-                cwd: options?.cwd,
-                stdio: ['pipe', 'pipe', 'pipe'],
-                shell: process.platform === 'win32',
-            });
-            // Write message to stdin for providers that read prompt from stdin (e.g. codex)
-            // Always close stdin afterwards — some CLIs (e.g. opencode) hang waiting for
-            // input otherwise, even when the prompt was passed via argv.
-            if (stdinMessage !== undefined) {
-                proc.stdin.write(stdinMessage);
-            }
-            proc.stdin.end();
-            // Report child PID immediately after spawn
-            if (proc.pid !== undefined) {
-                options?.onPid?.(proc.pid);
-            }
-            let stdout = '';
-            let stderr = '';
-            let stdoutBuf = '';
-            let stderrBuf = '';
-            proc.stdout.on('data', (chunk) => {
-                const str = chunk.toString();
-                stdout += str;
-                stdoutBuf += str;
-                const lines = stdoutBuf.split('\n');
-                stdoutBuf = lines.pop() ?? '';
-                for (const line of lines) {
-                    if (line.trim())
-                        options?.onOutput?.(line, 'stdout');
-                }
-            });
-            proc.stderr.on('data', (chunk) => {
-                const str = chunk.toString();
-                stderr += str;
-                stderrBuf += str;
-                const lines = stderrBuf.split('\n');
-                stderrBuf = lines.pop() ?? '';
-                for (const line of lines) {
-                    if (line.trim())
-                        options?.onOutput?.(line, 'stderr');
-                }
-            });
-            proc.on('error', (err) => {
-                if (err.code === 'ENOENT') {
-                    reject(new ProviderError(`CLI command "${this.cliCommand}" not found. Is ${this.providerStr} installed?`, this.providerStr));
-                }
-                else {
-                    reject(new ProviderError(`Spawn error: ${err.message}`, this.providerStr));
-                }
-            });
-            proc.on('close', (code) => {
-                // Flush any residual buffered content (no trailing newline)
-                if (stdoutBuf.trim())
-                    options?.onOutput?.(stdoutBuf, 'stdout');
-                if (stderrBuf.trim())
-                    options?.onOutput?.(stderrBuf, 'stderr');
-                const exitCode = code ?? 0;
-                options?.onExitCode?.(exitCode);
-                if (code !== 0) {
-                    reject(new ProviderError(`Process exited with code ${code}: ${stderr.slice(0, 500)}`, this.providerStr));
-                    return;
-                }
-                // Extract usage and model from stream-json result event before resolving
-                const { usage, model } = this.parseResultEvent(stdout);
-                if (usage && options?.onUsage) {
-                    options.onUsage(usage);
-                }
-                // OpenCode stream doesn't emit model info in events; fall back to configured model
-                const effectiveModel = model ?? (this.providerId === 'opencode' ? (options?.model ?? null) : null);
-                if (effectiveModel && options?.onModel) {
-                    options.onModel(effectiveModel);
-                }
-                const parsed = this.parseOutput(stdout);
-                resolve(parsed);
-            });
-        });
-    }
-    buildArgs(message, options, isExecute = false) {
-        // HOTFIX: compose systemPrompt into the outgoing message for all CLI providers.
-        // CLI providers don't have a common --system-prompt flag, and agent-rendered
-        // prompts (persona, rules, inline.prompt, builtin_tools, skills) were being
-        // dropped entirely before this fix. Provider-native system-prompt flags
-        // (e.g. claude --append-system-prompt) should be adopted per-provider later
-        // for proper system/user separation + prompt caching.
-        const effectiveMessage = options?.systemPrompt
-            ? `${options.systemPrompt}\n\n---\n\n${message}`
-            : message;
-        // Copilot uses standalone `copilot` binary with prompt via stdin
-        // (matching pre-refactoring CopilotProvider behavior)
-        if (this.providerId === 'copilot') {
-            const args = options?.additionalArgs ? [...options.additionalArgs] : [];
-            if (options?.model)
-                args.push('--model', options.model);
-            return { args, stdinMessage: effectiveMessage };
-        }
-        // OpenCode: prompt is a positional arg appended last; --format json is system-forced.
-        // Security flags (e.g. --dangerously-skip-permissions) come from options.additionalArgs
-        // so operators can control them via crewx.yaml.
-        if (this.providerId === 'opencode') {
-            const additionalArgs = options?.additionalArgs;
-            const args = additionalArgs !== undefined ? [...additionalArgs] : ['run'];
-            // System guarantee: --format json must be present for stream-json parsing
-            if (!args.includes('--format')) {
-                args.push('--format', 'json');
-            }
-            if (options?.model)
-                args.push('--model', options.model);
-            args.push(effectiveMessage);
-            return { args };
-        }
-        // If agent config provides explicit CLI options, use them directly
-        if (options?.additionalArgs !== undefined) {
-            const args = [...options.additionalArgs];
-            const pIdx = args.indexOf('-p');
-            if (pIdx !== -1) {
-                // -p flag present: insert message as its value
-                args.splice(pIdx + 1, 0, effectiveMessage);
-                if (options.model)
-                    args.push('--model', options.model);
-                return { args };
-            }
-            else {
-                // No -p flag: provider reads prompt from stdin (e.g. codex)
-                // codex-specific safety net: ensure a JSON output flag is present.
-                // Accept both --json (older) and --experimental-json (newer) as equivalent.
-                if (this.providerId === 'codex' && !args.includes('--json') && !args.includes('--experimental-json')) {
-                    args.push('--json');
-                }
-                if (options.model)
-                    args.push('--model', options.model);
-                return { args, stdinMessage: effectiveMessage };
-            }
-        }
-        // Default fallback: claude/gemini stream-json format
-        const args = ['-p', effectiveMessage, '--output-format', 'stream-json', '--verbose'];
-        if (isExecute) {
-            args.push('--dangerously-skip-permissions');
-        }
-        if (options?.model) {
-            args.push('--model', options.model);
-        }
-        return { args };
-    }
-    parseOutput(raw) {
-        return parseStreamJsonOutput(raw);
-    }
-    /**
-     * Extract token usage, cost, and model from the stream-json result event.
-     * Claude CLI emits: { type: "result", usage: {...}, total_cost_usd: ..., modelUsage: {...} }
-     * OpenCode CLI emits: { type: "step_finish", part: { tokens: { input, output, cache: { read, write } }, cost: 0 } }
-     */
-    parseResultEvent(raw) {
-        const baseUsage = parseResultEventUsage(raw);
-        const lines = raw.split('\n');
-        for (const line of lines) {
-            if (!line.trim())
-                continue;
-            try {
-                const parsed = JSON.parse(line);
-                if (parsed.type === 'result') {
-                    const usageRaw = parsed.usage;
-                    const usage = usageRaw
-                        ? {
-                            inputTokens: Number(usageRaw['input_tokens'] ?? 0),
-                            outputTokens: Number(usageRaw['output_tokens'] ?? 0),
-                            cachedInputTokens: Number(usageRaw['cache_read_input_tokens'] ?? 0),
-                            costUsd: Number(parsed['total_cost_usd'] ?? 0),
-                        }
-                        : baseUsage;
-                    const modelUsage = parsed.modelUsage;
-                    const model = modelUsage ? Object.keys(modelUsage)[0] ?? null : null;
-                    return { usage, model };
-                }
-            }
-            catch {
-                // Not JSON — skip
-            }
-        }
-        return { usage: baseUsage, model: null };
-    }
-}
-//# sourceMappingURL=bridge.js.map