@elizaos/agent 0.25.9 → 2.0.0-alpha.151

package/packages/agent/src/services/stream-manager.js

@@ -0,0 +1,609 @@
+/**
+ * Stream Manager — cross-platform RTMP streaming via FFmpeg.
+ *
+ * Supports multiple input modes:
+ * - "pipe": Receives JPEG frames via writeFrame() → FFmpeg stdin (image2pipe).
+ *   Used for streaming desktop window contents captured by the host bridge.
+ * - "avfoundation" / "screen": macOS native screen capture.
+ * - "x11grab": Linux virtual display capture (Xvfb). Used for GPU-backed game streams.
+ * - "file": Reads a continuously-updated JPEG file (browser-capture).
+ * - "testsrc": Solid color test pattern (default fallback).
+ *
+ * Audio support:
+ * - "silent": Synthetic silent audio (anullsrc) — default.
+ * - "system": System/desktop audio capture.
+ * - "microphone": Microphone input.
+ * - File path: Play an audio file as stream audio.
+ *
+ * Volume control:
+ * - setVolume(0-100), mute(), unmute() — restarts FFmpeg to apply.
+ *
+ * Usage:
+ *   import { streamManager } from "./services/stream-manager";
+ *   await streamManager.start({ rtmpUrl, rtmpKey, inputMode: "pipe" });
+ *   streamManager.writeFrame(jpegBuffer); // called from frame capture
+ *   streamManager.setVolume(50);          // adjust volume mid-stream
+ *   await streamManager.stop();
+ *
+ * @module services/stream-manager
+ */
+import { execSync, spawn } from "node:child_process";
+import { logger } from "@elizaos/core";
+import { ttsStreamBridge } from "./tts-stream-bridge.js";
+const TAG = "[StreamManager]";
+class StreamManager {
+    ffmpeg = null;
+    _running = false;
+    startedAt = null;
+    _frameCount = 0;
+    /** Current stream config — stored for restart on volume/audio changes. */
+    _config = null;
+    /** Current volume level (0–100). */
+    _volume = 80;
+    /** Whether audio is muted. */
+    _muted = false;
+    /** Auto-restart state. */
+    _restartAttempts = 0;
+    _maxRestartAttempts = 5;
+    _restartDecayTimer = null;
+    _intentionalStop = false;
+    /** Pending auto-restart timer — cleared in stop() to prevent races. */
+    _restartTimer = null;
+    /** Guard: prevents concurrent start() calls from orphaning FFmpeg. */
+    _starting = false;
+    isRunning() {
+        return this._running;
+    }
+    getUptime() {
+        if (!this.startedAt)
+            return 0;
+        return Math.floor((Date.now() - this.startedAt) / 1000);
+    }
+    getHealth() {
+        return {
+            running: this._running,
+            ffmpegAlive: this.ffmpeg !== null &&
+                this.ffmpeg.exitCode === null &&
+                !this.ffmpeg.killed,
+            uptime: this.getUptime(),
+            frameCount: this._frameCount,
+            volume: this._volume,
+            muted: this._muted,
+            audioSource: this._config?.audioSource || "silent",
+            inputMode: this._config?.inputMode || null,
+        };
+    }
+    getVolume() {
+        return this._muted ? 0 : this._volume;
+    }
+    isMuted() {
+        return this._muted;
+    }
+    /**
+     * Set volume (0–100). Restarts FFmpeg if currently streaming to apply the change.
+     */
+    async setVolume(level) {
+        this._volume = Math.max(0, Math.min(100, Math.round(level)));
+        logger.info(`${TAG} Volume set to ${this._volume}`);
+        if (this._running && this._config) {
+            await this.restart();
+        }
+    }
+    /** Mute audio. Restarts FFmpeg if currently streaming. */
+    async mute() {
+        if (this._muted)
+            return;
+        this._muted = true;
+        logger.info(`${TAG} Audio muted`);
+        if (this._running && this._config) {
+            await this.restart();
+        }
+    }
+    /** Unmute audio. Restarts FFmpeg if currently streaming. */
+    async unmute() {
+        if (!this._muted)
+            return;
+        this._muted = false;
+        logger.info(`${TAG} Audio unmuted (volume: ${this._volume})`);
+        if (this._running && this._config) {
+            await this.restart();
+        }
+    }
+    /** Restart the stream with updated config (preserves uptime tracking). */
+    async restart() {
+        if (!this._config)
+            return;
+        const savedStartedAt = this.startedAt;
+        const savedFrameCount = this._frameCount;
+        // Mark as intentional so the exit handler doesn't trigger autoRestart()
+        // concurrently with our manual restart below.
+        this._intentionalStop = true;
+        // Detach TTS bridge before stopping FFmpeg
+        ttsStreamBridge.detach();
+        // Stop FFmpeg without resetting tracking
+        if (this.ffmpeg && !this.ffmpeg.killed && this.ffmpeg.exitCode === null) {
+            if (this.ffmpeg.stdin) {
+                try {
+                    this.ffmpeg.stdin.end();
+                }
+                catch {
+                    /* ignore */
+                }
+            }
+            this.ffmpeg.kill("SIGTERM");
+            await Promise.race([
+                new Promise((resolve) => this.ffmpeg?.on("exit", resolve)),
+                new Promise((resolve) => setTimeout(resolve, 2000)),
+            ]);
+            if (this.ffmpeg?.exitCode === null) {
+                this.ffmpeg.kill("SIGKILL");
+            }
+        }
+        this.ffmpeg = null;
+        this._running = false;
+        // Restart with current volume/mute applied
+        const config = {
+            ...this._config,
+            volume: this._volume,
+            muted: this._muted,
+        };
+        this._intentionalStop = false;
+        await this.start(config);
+        // Restore tracking
+        this.startedAt = savedStartedAt;
+        this._frameCount = savedFrameCount;
+        logger.info(`${TAG} Stream restarted (volume=${this._volume}, muted=${this._muted})`);
+    }
+    /**
+     * Write a JPEG frame to FFmpeg's stdin (only works in "pipe" mode).
+     * Returns true if the frame was accepted.
+     */
+    writeFrame(jpegData) {
+        if (!this._running || !this.ffmpeg?.stdin)
+            return false;
+        if (this.ffmpeg.killed || this.ffmpeg.exitCode !== null)
+            return false;
+        try {
+            this.ffmpeg.stdin.write(jpegData);
+            this._frameCount++;
+            if (this._frameCount % 150 === 0) {
+                logger.info(`${TAG} Piped ${this._frameCount} frames to FFmpeg`);
+            }
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async start(config) {
+        if (this._running || this._starting) {
+            logger.warn(`${TAG} Already running or starting — stop first`);
+            return;
+        }
+        this._starting = true;
+        try {
+            await this._startInner(config);
+        }
+        finally {
+            this._starting = false;
+        }
+    }
+    async _startInner(config) {
+        // Pre-flight: ensure FFmpeg is installed
+        try {
+            execSync("ffmpeg -version", { stdio: "ignore", timeout: 5000 });
+        }
+        catch {
+            const installHint = process.platform === "darwin"
+                ? "Install with: brew install ffmpeg"
+                : process.platform === "linux"
+                    ? "Install with: sudo apt install ffmpeg  (or your distro's package manager)"
+                    : "Download from https://ffmpeg.org/download.html";
+            throw new Error(`FFmpeg not found. Streaming requires FFmpeg to be installed.\n${installHint}`);
+        }
+        this._config = config;
+        this._frameCount = 0;
+        this._volume = config.volume ?? this._volume;
+        this._muted = config.muted ?? this._muted;
+        const resolution = config.resolution || "1280x720";
+        const bitrate = config.bitrate || "2500k";
+        const framerate = config.framerate || 15;
+        const rtmpTarget = `${config.rtmpUrl}/${config.rtmpKey}`;
+        const bufsize = `${parseInt(bitrate, 10) * 2}k`;
+        const mode = config.inputMode || "testsrc";
+        // Build FFmpeg args based on input mode
+        const videoInputArgs = this.buildVideoInputArgs(config, resolution, framerate);
+        const audioInputArgs = this.buildAudioInputArgs(config);
+        const isPipe = mode === "pipe";
+        const isScreenCapture = mode === "avfoundation" || mode === "screen" || mode === "x11grab";
+        // Effective volume: 0 when muted, otherwise 0–1.0 scale
+        const effectiveVolume = this._muted ? 0 : this._volume / 100;
+        // FFmpeg arg order: all inputs first, then filters, then encoding/output
+        const ffmpegArgs = [
+            "-thread_queue_size",
+            "512",
+            // Video input
+            ...videoInputArgs,
+            // Audio input
+            ...audioInputArgs,
+            // Video filter: scale for screen capture modes
+            ...(isScreenCapture
+                ? ["-vf", `scale=${resolution.replace("x", ":")}:flags=fast_bilinear`]
+                : []),
+            // Audio filter: volume control
+            "-af",
+            `volume=${effectiveVolume.toFixed(2)}`,
+            // Video encoding (platform-specific)
+            ...(process.platform === "darwin"
+                ? [
+                    "-c:v",
+                    "h264_videotoolbox",
+                    "-realtime",
+                    "1",
+                    "-b:v",
+                    bitrate,
+                    "-maxrate",
+                    bitrate,
+                    "-bufsize",
+                    bufsize,
+                ]
+                : [
+                    "-c:v",
+                    "libx264",
+                    "-preset",
+                    "veryfast",
+                    "-tune",
+                    "zerolatency",
+                    "-b:v",
+                    bitrate,
+                    "-maxrate",
+                    bitrate,
+                    "-bufsize",
+                    bufsize,
+                ]),
+            "-s",
+            resolution,
+            "-pix_fmt",
+            "yuv420p",
+            "-g",
+            "60",
+            // Audio encoding
+            "-c:a",
+            "aac",
+            "-b:a",
+            "128k",
+            // Output
+            "-f",
+            "flv",
+            rtmpTarget,
+        ];
+        const audioSrc = config.audioSource || "silent";
+        logger.info(`${TAG} Starting FFmpeg RTMP stream (video=${mode}, audio=${audioSrc}, vol=${this._volume}${this._muted ? " MUTED" : ""}) → ${config.rtmpUrl}`);
+        logger.info(`${TAG} Resolution: ${resolution}, Bitrate: ${bitrate}, FPS: ${framerate}`);
+        const isTts = (config.audioSource || "silent") === "tts";
+        // In pipe mode, FFmpeg reads from stdin; otherwise stdin is ignored.
+        // TTS mode adds a 4th stdio fd (pipe:3) for raw PCM audio input.
+        this.ffmpeg = spawn("ffmpeg", ["-y", ...ffmpegArgs], {
+            stdio: [
+                isPipe ? "pipe" : "ignore",
+                "pipe",
+                "pipe",
+                ...(isTts ? ["pipe"] : []),
+            ],
+        });
+        // Log all FFmpeg stderr for debugging
+        this.ffmpeg.stderr?.on("data", (chunk) => {
+            const line = chunk.toString().trim();
+            if (line) {
+                console.log(`[FFmpeg] ${line}`);
+            }
+        });
+        this.ffmpeg.on("exit", (code, signal) => {
+            if (this._running) {
+                logger.warn(`${TAG} FFmpeg exited unexpectedly (code=${code}, signal=${signal})`);
+                this._running = false;
+                if (!this._intentionalStop && this._config) {
+                    this.autoRestart();
+                }
+                else {
+                    this.startedAt = null;
+                }
+            }
+        });
+        // Handle stdin errors gracefully in pipe mode
+        if (isPipe && this.ffmpeg.stdin) {
+            this.ffmpeg.stdin.on("error", (err) => {
+                logger.warn(`${TAG} FFmpeg stdin error: ${err.message}`);
+            });
+        }
+        // Attach TTS bridge to pipe:3 for PCM audio
+        if (isTts && this.ffmpeg.stdio[3]) {
+            const pipe3 = this.ffmpeg.stdio[3];
+            ttsStreamBridge.attach(pipe3);
+            logger.info(`${TAG} TTS bridge attached to pipe:3`);
+        }
+        // Wait a moment to confirm it started
+        await new Promise((r) => setTimeout(r, 1500));
+        if (this.ffmpeg.exitCode !== null) {
+            const exitCode = this.ffmpeg.exitCode;
+            this.ffmpeg = null;
+            throw new Error(`${TAG} FFmpeg exited immediately with code ${exitCode}`);
+        }
+        this._running = true;
+        this.startedAt = Date.now();
+        this._intentionalStop = false;
+        // Decay restart counter every 30s of healthy running
+        if (this._restartDecayTimer)
+            clearInterval(this._restartDecayTimer);
+        this._restartDecayTimer = setInterval(() => {
+            if (this._restartAttempts > 0) {
+                this._restartAttempts = Math.max(0, this._restartAttempts - 1);
+                logger.info(`${TAG} Restart counter decayed to ${this._restartAttempts}`);
+            }
+        }, 30_000);
+        logger.info(`${TAG} FFmpeg streaming to RTMP — stream should be live`);
+    }
+    async stop() {
+        const uptime = this.getUptime();
+        const frames = this._frameCount;
+        // Detach TTS bridge before killing FFmpeg
+        ttsStreamBridge.detach();
+        if (this.ffmpeg && !this.ffmpeg.killed && this.ffmpeg.exitCode === null) {
+            const ffmpegProc = this.ffmpeg;
+            // Close stdin first in pipe mode to signal EOF
+            if (ffmpegProc.stdin) {
+                try {
+                    ffmpegProc.stdin.end();
+                }
+                catch {
+                    /* ignore */
+                }
+            }
+            ffmpegProc.kill("SIGTERM");
+            await Promise.race([
+                new Promise((resolve) => ffmpegProc.on("exit", resolve)),
+                new Promise((resolve) => setTimeout(resolve, 3000)),
+            ]);
+            if (ffmpegProc.exitCode === null) {
+                ffmpegProc.kill("SIGKILL");
+            }
+        }
+        this._intentionalStop = true;
+        if (this._restartTimer) {
+            clearTimeout(this._restartTimer);
+            this._restartTimer = null;
+        }
+        if (this._restartDecayTimer) {
+            clearInterval(this._restartDecayTimer);
+            this._restartDecayTimer = null;
+        }
+        this.ffmpeg = null;
+        this._running = false;
+        this.startedAt = null;
+        this._frameCount = 0;
+        this._restartAttempts = 0;
+        this._config = null;
+        logger.info(`${TAG} Stream stopped (uptime: ${uptime}s, frames: ${frames})`);
+        return { uptime };
+    }
+    /** Attempt to restart FFmpeg after unexpected exit with exponential backoff. */
+    autoRestart() {
+        if (this._restartAttempts >= this._maxRestartAttempts) {
+            logger.error(`${TAG} Max restart attempts (${this._maxRestartAttempts}) reached — giving up`);
+            this.startedAt = null;
+            if (this._restartDecayTimer) {
+                clearInterval(this._restartDecayTimer);
+                this._restartDecayTimer = null;
+            }
+            return;
+        }
+        this._restartAttempts++;
+        const delay = Math.min(1000 * 2 ** (this._restartAttempts - 1), 60_000);
+        logger.info(`${TAG} Auto-restart attempt ${this._restartAttempts}/${this._maxRestartAttempts} in ${delay}ms`);
+        this._restartTimer = setTimeout(async () => {
+            this._restartTimer = null;
+            if (this._intentionalStop || !this._config)
+                return;
+            const savedStartedAt = this.startedAt;
+            const savedFrameCount = this._frameCount;
+            try {
+                this.ffmpeg = null;
+                await this.start({
+                    ...this._config,
+                    volume: this._volume,
+                    muted: this._muted,
+                });
+                // Restore tracking so uptime is continuous
+                this.startedAt = savedStartedAt;
+                this._frameCount = savedFrameCount;
+                logger.info(`${TAG} Auto-restart successful`);
+            }
+            catch (err) {
+                this._running = false;
+                logger.error(`${TAG} Auto-restart failed: ${String(err)}`);
+                // start() failed before spawning FFmpeg — no exit event will fire,
+                // so manually chain the next restart attempt if retries remain.
+                if (!this._intentionalStop && this._config) {
+                    this.autoRestart();
+                }
+            }
+        }, delay);
+    }
+    // ---------------------------------------------------------------------------
+    // Video input args
+    // ---------------------------------------------------------------------------
+    buildVideoInputArgs(config, resolution, framerate) {
+        const mode = config.inputMode || "testsrc";
+        switch (mode) {
+            case "pipe": {
+                // Read JPEG frames from stdin via image2pipe.
+                // -c:v mjpeg is mandatory: image2pipe cannot auto-detect JPEG from piped data.
+                // -probesize/-analyzeduration eliminate the default 5MB probe buffer that
+                // causes FFmpeg to stall for ~100 frames before decoding starts.
+                return [
+                    "-probesize",
+                    "32",
+                    "-analyzeduration",
+                    "0",
+                    "-f",
+                    "image2pipe",
+                    "-c:v",
+                    "mjpeg",
+                    "-framerate",
+                    String(framerate),
+                    "-i",
+                    "pipe:0",
+                ];
+            }
+            case "avfoundation":
+            case "screen": {
+                // macOS native screen capture via avfoundation.
+                // videoDevice "3" = Capture screen 0; ":none" = no audio from avfoundation.
+                const videoDevice = config.videoDevice || "3";
+                return [
+                    "-f",
+                    "avfoundation",
+                    "-framerate",
+                    String(framerate),
+                    "-pixel_format",
+                    "nv12",
+                    "-capture_cursor",
+                    "1",
+                    "-i",
+                    `${videoDevice}:none`,
+                ];
+            }
+            case "x11grab": {
+                // Linux virtual display capture (Xvfb) for GPU-backed game streams.
+                // Requires: Xvfb :99 -screen 0 1280x720x24 -ac &
+                // Then run a browser/TUI on display :99.
+                const display = config.display || ":99";
+                return [
+                    "-f",
+                    "x11grab",
+                    "-video_size",
+                    resolution,
+                    "-framerate",
+                    String(framerate),
+                    "-draw_mouse",
+                    "0",
+                    "-i",
+                    display,
+                ];
+            }
+            case "file": {
+                // Read from a continuously-updated JPEG file (written by browser-capture).
+                const framePath = config.frameFile || "/tmp/eliza-stream-frame.jpg";
+                return [
+                    "-probesize",
+                    "32",
+                    "-analyzeduration",
+                    "0",
+                    "-loop",
+                    "1",
+                    "-f",
+                    "image2",
+                    "-c:v",
+                    "mjpeg",
+                    "-framerate",
+                    String(framerate),
+                    "-i",
+                    framePath,
+                ];
+            }
+            default: {
+                // Solid color test pattern (dark navy)
+                return [
+                    "-f",
+                    "lavfi",
+                    "-i",
+                    `color=c=0x1a1a2e:s=${resolution}:r=${framerate}`,
+                ];
+            }
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Audio input args
+    // ---------------------------------------------------------------------------
+    buildAudioInputArgs(config) {
+        const source = config.audioSource || "silent";
+        switch (source) {
+            case "tts": {
+                // Raw PCM from TTS bridge via pipe:3 (4th stdio fd).
+                // Format must match tts-stream-bridge output: s16le, 24kHz, mono.
+                // -use_wallclock_as_timestamps 1: raw PCM has no timestamps, so FFmpeg
+                //   uses wall-clock time to sync with the video stream.
+                // -probesize/-analyzeduration: eliminate probe buffering for immediate start.
+                // -thread_queue_size: prevent queue overflow from high-frequency tick writes.
+                return [
+                    "-use_wallclock_as_timestamps",
+                    "1",
+                    "-probesize",
+                    "32",
+                    "-analyzeduration",
+                    "0",
+                    "-thread_queue_size",
+                    "512",
+                    "-f",
+                    "s16le",
+                    "-ar",
+                    "24000",
+                    "-ac",
+                    "1",
+                    "-i",
+                    "pipe:3",
+                ];
+            }
+            case "silent": {
+                // Synthetic silent audio — always works, no hardware required.
+                return [
+                    "-f",
+                    "lavfi",
+                    "-i",
+                    "anullsrc=channel_layout=stereo:sample_rate=44100",
+                ];
+            }
+            case "system": {
+                // System/desktop audio capture.
+                if (process.platform === "darwin") {
+                    // macOS: requires BlackHole or similar virtual audio device.
+                    // audioDevice is the avfoundation audio device index (e.g., "2").
+                    const device = config.audioDevice || "0";
+                    return ["-f", "avfoundation", "-i", `none:${device}`];
+                }
+                // Linux: PulseAudio monitor source captures desktop audio.
+                const device = config.audioDevice || "default";
+                return ["-f", "pulse", "-i", device];
+            }
+            case "microphone": {
+                // Microphone input.
+                if (process.platform === "darwin") {
+                    const device = config.audioDevice || "0";
+                    return ["-f", "avfoundation", "-i", `none:${device}`];
+                }
+                const device = config.audioDevice || "default";
+                return ["-f", "pulse", "-i", device];
+            }
+            default: {
+                // Treat as a file path — play audio file as stream audio.
+                // Supports mp3, wav, ogg, flac, etc.
+                if (source.startsWith("/") || source.startsWith("./")) {
+                    return ["-stream_loop", "-1", "-i", source];
+                }
+                // Fallback to silent if source is unrecognized.
+                return [
+                    "-f",
+                    "lavfi",
+                    "-i",
+                    "anullsrc=channel_layout=stereo:sample_rate=44100",
+                ];
+            }
+        }
+    }
+    /** Get the TTS stream bridge for external speak triggers. */
+    getTtsBridge() {
+        return ttsStreamBridge;
+    }
+}
+// Module singleton
+export const streamManager = new StreamManager();

package/packages/agent/src/services/task-executor.d.ts

@@ -0,0 +1,47 @@
+import type { IAgentRuntime, Memory } from "@elizaos/core";
+/** Specification for a task to be executed */
+export interface TaskSpec {
+    id: string;
+    description: string;
+    type: string;
+    metadata?: Record<string, unknown>;
+    agentType?: string;
+    message?: Memory;
+}
+/** Result from a completed task */
+export interface TaskResult {
+    taskId: string;
+    success: boolean;
+    output?: string;
+    artifacts?: Array<{
+        name: string;
+        path: string;
+        type: string;
+    }>;
+    error?: string;
+    durationMs?: number;
+}
+/** Interface for task executors that handle specific task types */
+export interface TaskExecutor {
+    /** Unique type identifier (e.g., "coding", "research", "content") */
+    readonly type: string;
+    /** Human-readable description of what this executor handles */
+    readonly description: string;
+    /** Check if this executor can handle the given task */
+    canHandle(spec: TaskSpec, runtime: IAgentRuntime): boolean;
+    /** Execute the task and return results */
+    execute(spec: TaskSpec, runtime: IAgentRuntime): Promise<TaskResult>;
+    /** Abort a running task */
+    abort(taskId: string): Promise<void>;
+}
+/** Registry for task executors */
+export declare class TaskExecutorRegistry {
+    private executors;
+    register(executor: TaskExecutor): void;
+    unregister(type: string): void;
+    /** Find the best executor for a task spec */
+    findExecutor(spec: TaskSpec, runtime: IAgentRuntime): TaskExecutor | undefined;
+    getAll(): TaskExecutor[];
+    get(type: string): TaskExecutor | undefined;
+}
+//# sourceMappingURL=task-executor.d.ts.map

package/packages/agent/src/services/task-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-executor.d.ts","sourceRoot":"","sources":["../../../../../src/services/task-executor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAE3D,8CAA8C;AAC9C,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,mCAAmC;AACnC,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAChE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,mEAAmE;AACnE,MAAM,WAAW,YAAY;IAC3B,qEAAqE;IACrE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,+DAA+D;IAC/D,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAE7B,uDAAuD;IACvD,SAAS,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC;IAE3D,0CAA0C;IAC1C,OAAO,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAErE,2BAA2B;IAC3B,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACtC;AAED,kCAAkC;AAClC,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,SAAS,CAAwC;IAEzD,QAAQ,CAAC,QAAQ,EAAE,YAAY,GAAG,IAAI;IAItC,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAI9B,6CAA6C;IAC7C,YAAY,CACV,IAAI,EAAE,QAAQ,EACd,OAAO,EAAE,aAAa,GACrB,YAAY,GAAG,SAAS;IAa3B,MAAM,IAAI,YAAY,EAAE;IAIxB,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;CAG5C"}

package/packages/agent/src/services/task-executor.js

@@ -0,0 +1,31 @@
+/** Registry for task executors */
+export class TaskExecutorRegistry {
+    executors = new Map();
+    register(executor) {
+        this.executors.set(executor.type, executor);
+    }
+    unregister(type) {
+        this.executors.delete(type);
+    }
+    /** Find the best executor for a task spec */
+    findExecutor(spec, runtime) {
+        // If task has explicit type, try that first
+        if (spec.type) {
+            const explicit = this.executors.get(spec.type);
+            if (explicit?.canHandle(spec, runtime))
+                return explicit;
+        }
+        // Otherwise, find first executor that can handle it
+        for (const executor of this.executors.values()) {
+            if (executor.canHandle(spec, runtime))
+                return executor;
+        }
+        return undefined;
+    }
+    getAll() {
+        return Array.from(this.executors.values());
+    }
+    get(type) {
+        return this.executors.get(type);
+    }
+}