@crewx/sdk 0.8.0-rc.73 → 0.8.0-rc.75

package/dist/parsers/router.js

@@ -0,0 +1,56 @@
+"use strict";
+/**
+ * parseStdoutEvent — routes a single stdout JSONL event to the appropriate provider parser.
+ * Returns TaskLogEntry[] (may be empty if event is not recognized or irrelevant).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStdoutEvent = parseStdoutEvent;
+const claude_parser_1 = require("./claude.parser");
+const copilot_parser_1 = require("./copilot.parser");
+const codex_parser_1 = require("./codex.parser");
+const gemini_parser_1 = require("./gemini.parser");
+const opencode_parser_1 = require("./opencode.parser");
+function parseStdoutEvent(timestamp, message) {
+    let parsed;
+    try {
+        parsed = JSON.parse(message);
+    }
+    catch {
+        return [];
+    }
+    const type = parsed.type;
+    if (!type)
+        return [];
+    // Claude stream-json (system event excluded — meta event)
+    if (type === 'assistant' || type === 'user') {
+        return (0, claude_parser_1.parseClaudeEvent)(timestamp, parsed);
+    }
+    // Copilot json — assistant.* check must precede Gemini "message" check
+    if (type.startsWith('tool.execution') || type.startsWith('assistant.') || type === 'user.message') {
+        return (0, copilot_parser_1.parseCopilotEvent)(timestamp, parsed);
+    }
+    // Codex experimental-json
+    if (type.startsWith('item.') || type.startsWith('turn.') || type.startsWith('thread.')) {
+        return (0, codex_parser_1.parseCodexEvent)(timestamp, parsed);
+    }
+    // Gemini stream-json — tool_use/tool_result routed by structure below
+    if (type === 'message' || type === 'init') {
+        return (0, gemini_parser_1.parseGeminiEvent)(timestamp, parsed);
+    }
+    // tool_use / tool_result: disambiguate by schema structure.
+    // OpenCode has a `part` object; Gemini is flat (tool_name, parameters).
+    if (type === 'tool_use' || type === 'tool_result') {
+        if (parsed.part && typeof parsed.part === 'object') {
+            return (0, opencode_parser_1.parseOpencodeEvent)(timestamp, parsed);
+        }
+        return (0, gemini_parser_1.parseGeminiEvent)(timestamp, parsed);
+    }
+    // OpenCode stream-json (--format json)
+    // Note: 'text' is a generic name but not used by any other provider currently.
+    // 'step_start' and 'step_finish' are OpenCode-specific.
+    if (type === 'text' || type === 'step_start' || type === 'step_finish') {
+        return (0, opencode_parser_1.parseOpencodeEvent)(timestamp, parsed);
+    }
+    return [];
+}
+//# sourceMappingURL=router.js.map

package/dist/platform/BrowserFsAdapter.d.ts

@@ -0,0 +1,37 @@
+/**
+ * BrowserFsAdapter — IFsAdapter implementation for browser environments.
+ *
+ * Uses localStorage as the backing store with a key-prefix namespace.
+ * Paths are normalized to forward-slash POSIX style.
+ *
+ * Usage:
+ *   const fs = new BrowserFsAdapter();
+ *   // Pre-load content before using with DocumentLoader:
+ *   fs.setItem('/docs/guide.md', '# Guide\n...');
+ */
+import type { IFsAdapter } from './IFsAdapter';
+export declare class BrowserFsAdapter implements IFsAdapter {
+    private readonly prefix;
+    private readonly store;
+    /**
+     * @param options.prefix - localStorage key prefix (default: 'crewx:fs:')
+     * @param options.storage - optional external storage map (defaults to an in-memory Map;
+     *                          pass a localStorage-backed wrapper for persistence)
+     */
+    constructor(options?: {
+        prefix?: string;
+        storage?: Map<string, string>;
+    });
+    readFile(path: string): Promise<string>;
+    exists(path: string): Promise<boolean>;
+    resolvePath(...segments: string[]): string;
+    isAbsolute(path: string): boolean;
+    /** Store a virtual file for later reading. */
+    setItem(path: string, content: string): void;
+    /** Remove a virtual file. */
+    removeItem(path: string): void;
+    /** List all stored virtual file paths. */
+    keys(): string[];
+    private toKey;
+}
+//# sourceMappingURL=BrowserFsAdapter.d.ts.map

package/dist/platform/BrowserFsAdapter.js

@@ -0,0 +1,84 @@
+"use strict";
+/**
+ * BrowserFsAdapter — IFsAdapter implementation for browser environments.
+ *
+ * Uses localStorage as the backing store with a key-prefix namespace.
+ * Paths are normalized to forward-slash POSIX style.
+ *
+ * Usage:
+ *   const fs = new BrowserFsAdapter();
+ *   // Pre-load content before using with DocumentLoader:
+ *   fs.setItem('/docs/guide.md', '# Guide\n...');
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserFsAdapter = void 0;
+const DEFAULT_PREFIX = 'crewx:fs:';
+class BrowserFsAdapter {
+    prefix;
+    store;
+    /**
+     * @param options.prefix - localStorage key prefix (default: 'crewx:fs:')
+     * @param options.storage - optional external storage map (defaults to an in-memory Map;
+     *                          pass a localStorage-backed wrapper for persistence)
+     */
+    constructor(options) {
+        this.prefix = options?.prefix ?? DEFAULT_PREFIX;
+        this.store = options?.storage ?? new Map();
+    }
+    async readFile(path) {
+        const key = this.toKey(path);
+        const content = this.store.get(key);
+        if (content === undefined) {
+            throw new Error(`BrowserFsAdapter: file not found: ${path}`);
+        }
+        return content;
+    }
+    async exists(path) {
+        return this.store.has(this.toKey(path));
+    }
+    resolvePath(...segments) {
+        // Simple POSIX-style path joining (no true "resolve" since there's no cwd)
+        const joined = segments
+            .map(s => s.replace(/\\/g, '/'))
+            .join('/')
+            .replace(/\/+/g, '/');
+        // Normalize . and .. segments
+        const parts = joined.split('/');
+        const resolved = [];
+        for (const part of parts) {
+            if (part === '.' || part === '')
+                continue;
+            if (part === '..') {
+                resolved.pop();
+            }
+            else {
+                resolved.push(part);
+            }
+        }
+        const result = resolved.join('/');
+        return joined.startsWith('/') ? `/${result}` : result;
+    }
+    isAbsolute(path) {
+        return path.startsWith('/');
+    }
+    // ── Browser-specific helpers ───────────────────────────────────────────────
+    /** Store a virtual file for later reading. */
+    setItem(path, content) {
+        this.store.set(this.toKey(path), content);
+    }
+    /** Remove a virtual file. */
+    removeItem(path) {
+        this.store.delete(this.toKey(path));
+    }
+    /** List all stored virtual file paths. */
+    keys() {
+        return Array.from(this.store.keys())
+            .filter(k => k.startsWith(this.prefix))
+            .map(k => k.slice(this.prefix.length));
+    }
+    toKey(path) {
+        return `${this.prefix}${path.replace(/\\/g, '/')}`;
+    }
+}
+exports.BrowserFsAdapter = BrowserFsAdapter;
+//# sourceMappingURL=BrowserFsAdapter.js.map

package/dist/platform/IFsAdapter.d.ts

@@ -0,0 +1,29 @@
+/**
+ * IFsAdapter — minimal file-system abstraction for DocumentLoader.
+ *
+ * Allows injection of alternative implementations (e.g., in-memory for tests,
+ * or a WEB-compatible adapter in a future round).
+ *
+ * Node.js default: NodeFsAdapter.
+ */
+export interface IFsAdapter {
+    /**
+     * Read a file as UTF-8 string.
+     * @throws if the file does not exist or is not readable.
+     */
+    readFile(path: string): Promise<string>;
+    /**
+     * Check whether a file exists at the given path.
+     */
+    exists(path: string): Promise<boolean>;
+    /**
+     * Resolve path segments into an absolute path.
+     * Behaves like path.resolve() / path.join() depending on implementation.
+     */
+    resolvePath(...segments: string[]): string;
+    /**
+     * Return true if the given path is absolute.
+     */
+    isAbsolute(path: string): boolean;
+}
+//# sourceMappingURL=IFsAdapter.d.ts.map

package/dist/{core/remote/types.js → platform/IFsAdapter.js}

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=types.js.map
+//# sourceMappingURL=IFsAdapter.js.map

package/dist/platform/NodeFsAdapter.d.ts

@@ -0,0 +1,16 @@
+/**
+ * NodeFsAdapter — default IFsAdapter implementation using Node.js fs/path.
+ *
+ * This is the concrete adapter used in CLI and server contexts.
+ * Full platform abstraction (WEB, browser) is deferred to a future round.
+ */
+import type { IFsAdapter } from './IFsAdapter';
+export declare class NodeFsAdapter implements IFsAdapter {
+    readFile(path: string): Promise<string>;
+    exists(path: string): Promise<boolean>;
+    resolvePath(...segments: string[]): string;
+    isAbsolute(path: string): boolean;
+}
+/** Singleton default adapter for convenience in CLI usage. */
+export declare const defaultFsAdapter: IFsAdapter;
+//# sourceMappingURL=NodeFsAdapter.d.ts.map

package/dist/platform/NodeFsAdapter.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * NodeFsAdapter — default IFsAdapter implementation using Node.js fs/path.
+ *
+ * This is the concrete adapter used in CLI and server contexts.
+ * Full platform abstraction (WEB, browser) is deferred to a future round.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultFsAdapter = exports.NodeFsAdapter = void 0;
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+class NodeFsAdapter {
+    async readFile(path) {
+        return (0, promises_1.readFile)(path, 'utf-8');
+    }
+    async exists(path) {
+        try {
+            await (0, promises_1.access)(path);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    resolvePath(...segments) {
+        if (segments.length === 1) {
+            return (0, path_1.resolve)(segments[0]);
+        }
+        return (0, path_1.resolve)((0, path_1.join)(...segments));
+    }
+    isAbsolute(path) {
+        return (0, path_1.isAbsolute)(path);
+    }
+}
+exports.NodeFsAdapter = NodeFsAdapter;
+/** Singleton default adapter for convenience in CLI usage. */
+exports.defaultFsAdapter = new NodeFsAdapter();
+//# sourceMappingURL=NodeFsAdapter.js.map

package/dist/plugin/plugin-provider.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Plugin Provider Runtime
+ *
+ * Implements ProviderRuntime for `type: plugin` providers in crewx.yaml.
+ * Wraps an arbitrary CLI tool as a CrewX agent via child_process.spawn (shell: false).
+ *
+ * Symmetric to remote/remote-provider.ts — registered as the `plugin` namespace factory.
+ */
+import type { ProviderRuntime, ProviderFactory, ProviderQueryOptions } from '../provider/bridge.js';
+import type { PluginProviderConfig } from './types.js';
+/**
+ * ProviderRuntime implementation for plugin (CLI-wrapped) providers.
+ *
+ * Created by the `plugin` namespace factory when `createProvider('plugin/mock')` is called.
+ * Spawns the configured CLI with args derived from query_args/execute_args,
+ * applies `{model}` substitution, and routes the prompt via args or stdin.
+ */
+export declare class PluginProviderRuntime implements ProviderRuntime {
+    private readonly config;
+    private readonly providerStr;
+    constructor(id: string, config: PluginProviderConfig);
+    query(message: string, options?: ProviderQueryOptions): Promise<string>;
+    execute(message: string, options?: ProviderQueryOptions): Promise<string>;
+    private runProcess;
+}
+/**
+ * Create a provider factory function for the `plugin` namespace.
+ *
+ * @param pluginConfigs - Map of plugin provider ID → config (from crewx.yaml `providers:` section)
+ * @returns ProviderFactory to register via registerProviderFactory('plugin', factory)
+ */
+export declare function createPluginProviderFactory(pluginConfigs: Map<string, PluginProviderConfig>): ProviderFactory;
+//# sourceMappingURL=plugin-provider.d.ts.map

package/dist/plugin/plugin-provider.js

@@ -0,0 +1,207 @@
+"use strict";
+/**
+ * Plugin Provider Runtime
+ *
+ * Implements ProviderRuntime for `type: plugin` providers in crewx.yaml.
+ * Wraps an arbitrary CLI tool as a CrewX agent via child_process.spawn (shell: false).
+ *
+ * Symmetric to remote/remote-provider.ts — registered as the `plugin` namespace factory.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginProviderRuntime = void 0;
+exports.createPluginProviderFactory = createPluginProviderFactory;
+const child_process_1 = require("child_process");
+const bridge_js_1 = require("../provider/bridge.js");
+/**
+ * ProviderRuntime implementation for plugin (CLI-wrapped) providers.
+ *
+ * Created by the `plugin` namespace factory when `createProvider('plugin/mock')` is called.
+ * Spawns the configured CLI with args derived from query_args/execute_args,
+ * applies `{model}` substitution, and routes the prompt via args or stdin.
+ */
+class PluginProviderRuntime {
+    config;
+    providerStr;
+    constructor(id, config) {
+        this.config = config;
+        this.providerStr = `plugin/${id}`;
+        // Validate at construction time (fail early, not at call time)
+        validateCliCommand(config.cli_command);
+        validateCliArgs(config.query_args);
+        validateCliArgs(config.execute_args);
+        if (config.error_patterns)
+            validateErrorPatterns(config.error_patterns);
+        if (config.env)
+            validateEnv(config.env);
+    }
+    async query(message, options) {
+        const model = options?.model ?? this.config.default_model ?? 'default';
+        const args = resolveArgs(this.config.query_args, model, message, this.config.prompt_in_args);
+        const stdinMessage = this.config.prompt_in_args ? undefined : message;
+        options?.onCommand?.(`${this.config.cli_command} ${args.join(' ')}`);
+        const timeoutMs = this.config.timeout?.query ?? 600000;
+        return this.runProcess(args, options, stdinMessage, timeoutMs);
+    }
+    async execute(message, options) {
+        const model = options?.model ?? this.config.default_model ?? 'default';
+        const args = resolveArgs(this.config.execute_args, model, message, this.config.prompt_in_args);
+        const stdinMessage = this.config.prompt_in_args ? undefined : message;
+        options?.onCommand?.(`${this.config.cli_command} ${args.join(' ')}`);
+        const timeoutMs = this.config.timeout?.execute ?? 600000;
+        return this.runProcess(args, options, stdinMessage, timeoutMs);
+    }
+    runProcess(args, options, stdinMessage, timeoutMs) {
+        return new Promise((resolve, reject) => {
+            // Merge env: process.env is the base; config.env values are added on top.
+            // Never replaces process.env — only extends it.
+            const mergedEnv = {
+                ...process.env,
+                ...(this.config.env ?? {}),
+            };
+            const proc = (0, child_process_1.spawn)(this.config.cli_command, args, {
+                env: mergedEnv,
+                shell: false, // Security: no shell interpolation
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            // Write prompt to stdin when prompt_in_args is false
+            if (stdinMessage !== undefined) {
+                proc.stdin.write(stdinMessage);
+                proc.stdin.end();
+            }
+            else {
+                proc.stdin.end();
+            }
+            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');
+                }
+            });
+            // Hard timeout — terminate and reject if exceeded
+            const timeoutHandle = setTimeout(() => {
+                proc.kill('SIGTERM');
+                reject(new bridge_js_1.ProviderError(`Plugin provider "${this.providerStr}" timed out after ${timeoutMs}ms`, this.providerStr));
+            }, timeoutMs);
+            proc.on('error', (err) => {
+                clearTimeout(timeoutHandle);
+                if (err.code === 'ENOENT') {
+                    const hint = this.config.not_installed_message
+                        ?? `CLI command "${this.config.cli_command}" not found. Is ${this.config.id} installed?`;
+                    reject(new bridge_js_1.ProviderError(hint, this.providerStr));
+                }
+                else {
+                    reject(new bridge_js_1.ProviderError(`Spawn error: ${err.message}`, this.providerStr));
+                }
+            });
+            proc.on('close', (code) => {
+                clearTimeout(timeoutHandle);
+                // Flush 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);
+                // Check configured error patterns before exit code
+                if (this.config.error_patterns) {
+                    const combined = stderr || stdout;
+                    for (const ep of this.config.error_patterns) {
+                        if (combined.includes(ep.pattern)) {
+                            reject(new bridge_js_1.ProviderError(ep.message, this.providerStr));
+                            return;
+                        }
+                    }
+                }
+                if (code !== 0) {
+                    reject(new bridge_js_1.ProviderError(`Process exited with code ${code}: ${stderr.slice(0, 500)}`, this.providerStr));
+                    return;
+                }
+                resolve(stdout.trim());
+            });
+        });
+    }
+}
+exports.PluginProviderRuntime = PluginProviderRuntime;
+// ── Factory ─────────────────────────────────────────────────────────────────
+/**
+ * Create a provider factory function for the `plugin` namespace.
+ *
+ * @param pluginConfigs - Map of plugin provider ID → config (from crewx.yaml `providers:` section)
+ * @returns ProviderFactory to register via registerProviderFactory('plugin', factory)
+ */
+function createPluginProviderFactory(pluginConfigs) {
+    return (id, _providerStr) => {
+        const config = pluginConfigs.get(id);
+        if (!config) {
+            throw new bridge_js_1.ProviderError(`Plugin provider "${id}" not found. Available: ${Array.from(pluginConfigs.keys()).join(', ') || '(none)'}`, `plugin/${id}`);
+        }
+        return new PluginProviderRuntime(id, config);
+    };
+}
+// ── Helpers ─────────────────────────────────────────────────────────────────
+/**
+ * Build the final args array for a CLI invocation:
+ * 1. Replace `{model}` placeholders in each arg.
+ * 2. If promptInArgs is true, append the prompt as a positional argument.
+ */
+function resolveArgs(templateArgs, model, prompt, promptInArgs) {
+    const args = templateArgs.map(arg => arg.replace(/\{model\}/g, model));
+    if (promptInArgs) {
+        args.push(prompt);
+    }
+    return args;
+}
+// ── Validation ───────────────────────────────────────────────────────────────
+function validateCliCommand(cliCommand) {
+    if (!cliCommand || typeof cliCommand !== 'string') {
+        throw new Error('Plugin provider requires a cli_command');
+    }
+}
+function validateCliArgs(args) {
+    if (!Array.isArray(args)) {
+        throw new Error('CLI arguments must be an array');
+    }
+    for (const arg of args) {
+        if (typeof arg !== 'string') {
+            throw new Error('Each CLI argument must be a string');
+        }
+    }
+}
+function validateErrorPatterns(patterns) {
+    for (const { pattern } of patterns) {
+        if (typeof pattern !== 'string') {
+            throw new Error('Error pattern must be a string');
+        }
+    }
+}
+function validateEnv(env) {
+    for (const [key, value] of Object.entries(env)) {
+        if (typeof key !== 'string' || typeof value !== 'string') {
+            throw new Error('env entries must be string key/value pairs');
+        }
+    }
+}
+//# sourceMappingURL=plugin-provider.js.map

package/dist/plugin/types.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Plugin Provider Types
+ *
+ * Configuration for `type: plugin` providers in crewx.yaml.
+ * Plugin providers wrap arbitrary CLI tools as CrewX agents.
+ */
+export interface PluginProviderConfig {
+    id: string;
+    type: 'plugin';
+    /** CLI command (binary name or relative path). Executed via spawn(shell: false). */
+    cli_command: string;
+    display_name?: string;
+    description?: string;
+    /**
+     * Default model used for `{model}` substitution in args.
+     * Can be overridden per-call via QueryOptions.model.
+     */
+    default_model?: string;
+    /**
+     * CLI argument array for `query` mode.
+     * `{model}` placeholders are replaced with the resolved model name.
+     */
+    query_args: string[];
+    /**
+     * CLI argument array for `execute` mode.
+     * `{model}` placeholders are replaced with the resolved model name.
+     */
+    execute_args: string[];
+    /**
+     * When true, the prompt is appended as the final positional argument.
+     * When false, the prompt is written to the process stdin.
+     */
+    prompt_in_args: boolean;
+    /** Additional environment variables merged into process.env (never replaces it). */
+    env?: Record<string, string>;
+    /** Per-mode timeout in milliseconds. Defaults: query=600000, execute=600000. */
+    timeout?: {
+        query: number;
+        execute: number;
+    };
+    /**
+     * Output patterns that signal a provider-level error (e.g. "not authenticated").
+     * Matched against combined stdout+stderr. Uses string contains (not regex).
+     */
+    error_patterns?: Array<{
+        pattern: string;
+        type: string;
+        message: string;
+    }>;
+    /** Human-readable message shown when the CLI is not found. */
+    not_installed_message?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/plugin/types.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * Plugin Provider Types
+ *
+ * Configuration for `type: plugin` providers in crewx.yaml.
+ * Plugin providers wrap arbitrary CLI tools as CrewX agents.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/plugin.d.ts

@@ -0,0 +1,33 @@
+/**
+ * CrewxPlugin — base class for SDK plugins.
+ *
+ * Plugins subscribe to Crewx events in attach() and clean up in detach().
+ * Register via Crewx.use(plugin).
+ *
+ * @example
+ * class MyPlugin extends CrewxPlugin {
+ *   readonly name = 'my-plugin';
+ *   attach(crewx: Crewx) {
+ *     crewx.on('task:start', (e) => console.log(e.traceId));
+ *   }
+ * }
+ * await crewx.use(new MyPlugin());
+ */
+import type { Crewx } from './facade/Crewx';
+export declare abstract class CrewxPlugin {
+    /** Unique plugin name. Used for same-instance deduplication in Crewx.use(). */
+    abstract readonly name: string;
+    /**
+     * Called when the plugin is registered via Crewx.use().
+     * Subscribe to events and initialize resources here.
+     * May be async (e.g. for DB connections).
+     */
+    abstract attach(crewx: Crewx): void | Promise<void>;
+    /**
+     * Called on Crewx.close() in LIFO order.
+     * Remove event listeners and release resources here.
+     * Default: no-op.
+     */
+    detach(_crewx: Crewx): void | Promise<void>;
+}
+//# sourceMappingURL=plugin.d.ts.map

package/dist/plugin.js

@@ -0,0 +1,29 @@
+"use strict";
+/**
+ * CrewxPlugin — base class for SDK plugins.
+ *
+ * Plugins subscribe to Crewx events in attach() and clean up in detach().
+ * Register via Crewx.use(plugin).
+ *
+ * @example
+ * class MyPlugin extends CrewxPlugin {
+ *   readonly name = 'my-plugin';
+ *   attach(crewx: Crewx) {
+ *     crewx.on('task:start', (e) => console.log(e.traceId));
+ *   }
+ * }
+ * await crewx.use(new MyPlugin());
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrewxPlugin = void 0;
+class CrewxPlugin {
+    /**
+     * Called on Crewx.close() in LIFO order.
+     * Remove event listeners and release resources here.
+     * Default: no-op.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    detach(_crewx) { }
+}
+exports.CrewxPlugin = CrewxPlugin;
+//# sourceMappingURL=plugin.js.map

package/dist/plugins/conversation.d.ts

@@ -0,0 +1,18 @@
+import { CrewxPlugin } from '../plugin';
+import type { Crewx } from '../facade/Crewx';
+import type { IConversationHistoryProvider } from '../conversation/types';
+export interface ConversationPluginOptions {
+    dbPath?: string;
+}
+export declare class ConversationPlugin extends CrewxPlugin {
+    readonly name = "conversation";
+    private _provider;
+    private unsubStart;
+    private unsubEnd;
+    constructor(opts?: ConversationPluginOptions);
+    /** Expose provider for SDK history auto-fetch (WI-CONV-002). */
+    get conversationProvider(): IConversationHistoryProvider;
+    attach(crewx: Crewx): void;
+    detach(_crewx: Crewx): void;
+}
+//# sourceMappingURL=conversation.d.ts.map