@elizaos/agent 2.0.0-alpha.144 → 2.0.0-alpha.151

package/packages/typescript/src/features/orchestrator/actions/send-to-agent.js

@@ -1,265 +0,0 @@
-/**
- * SEND_TO_AGENT action - Send input to a running task agent.
- *
- * Allows sending text or commands to an active PTY session.
- * Useful for responding to prompts, providing feedback, or giving new instructions.
- *
- * @module actions/send-to-agent
- */
-import { getCoordinator } from "../services/pty-service.js";
-import { normalizeAgentType } from "../services/pty-types.js";
-import { requireTaskAgentAccess } from "../services/task-policy.js";
-import { mergeTaskThreadEvalMetadata } from "./eval-metadata.js";
-export const sendToAgentAction = {
-    name: "SEND_TO_AGENT",
-    similes: [
-        "SEND_TO_CODING_AGENT",
-        "MESSAGE_CODING_AGENT",
-        "INPUT_TO_AGENT",
-        "RESPOND_TO_AGENT",
-        "TELL_CODING_AGENT",
-        "MESSAGE_AGENT",
-        "TELL_TASK_AGENT",
-    ],
-    description: "Send text input or key presses to a running task-agent session. " +
-        "Use this to respond to agent prompts, provide feedback, continue a task, or assign a fresh tracked task to an existing agent.",
-    examples: [
-        [
-            {
-                name: "{{user1}}",
-                content: { text: "Tell the running sub-agent to accept the changes" },
-            },
-            {
-                name: "{{agentName}}",
-                content: {
-                    text: "I'll send the approval to the task agent.",
-                    action: "SEND_TO_AGENT",
-                },
-            },
-        ],
-        [
-            {
-                name: "{{user1}}",
-                content: { text: "Say yes to the agent prompt" },
-            },
-            {
-                name: "{{agentName}}",
-                content: {
-                    text: "Sending confirmation to the agent.",
-                    action: "SEND_TO_AGENT",
-                },
-            },
-        ],
-    ],
-    validate: async (runtime, _message) => {
-        const ptyService = runtime.getService("PTY_SERVICE");
-        if (!ptyService) {
-            return false;
-        }
-        // Fast-fail: listSessions() does a JSON-RPC call to the Node worker which
-        // can take 30s to timeout when the worker is busy.  Cap at 2s so action
-        // validation doesn't block the entire message pipeline.
-        try {
-            const sessions = await Promise.race([
-                ptyService.listSessions(),
-                new Promise((_, reject) => setTimeout(() => reject(new Error("validate timeout")), 2000)),
-            ]);
-            return sessions.length > 0;
-        }
-        catch {
-            return false;
-        }
-    },
-    handler: async (runtime, message, state, options, callback) => {
-        const access = await requireTaskAgentAccess(runtime, message, "interact");
-        if (access.allowed === false) {
-            if (callback) {
-                await callback({
-                    text: access.reason,
-                });
-            }
-            return { success: false, error: "FORBIDDEN", text: access.reason };
-        }
-        const ptyService = runtime.getService("PTY_SERVICE");
-        if (!ptyService) {
-            if (callback) {
-                await callback({
-                    text: "PTY Service is not available.",
-                });
-            }
-            return { success: false, error: "SERVICE_UNAVAILABLE" };
-        }
-        const params = options?.parameters;
-        const content = message.content;
-        // Get session ID from content or state
-        let sessionId = params?.sessionId ?? content.sessionId;
-        if (!sessionId && state?.codingSession) {
-            sessionId = state.codingSession.id;
-        }
-        if (!sessionId) {
-            // Try to find the most recent session
-            const sessions = await ptyService.listSessions();
-            if (sessions.length === 0) {
-                if (callback) {
-                    await callback({
-                        text: "No active task-agent sessions. Spawn an agent first.",
-                    });
-                }
-                return { success: false, error: "NO_SESSION" };
-            }
-            sessionId = sessions[sessions.length - 1].id;
-        }
-        const session = ptyService.getSession(sessionId);
-        if (!session) {
-            if (callback) {
-                await callback({
-                    text: `Session ${sessionId} not found.`,
-                });
-            }
-            return { success: false, error: "SESSION_NOT_FOUND" };
-        }
-        try {
-            const keys = params?.keys ?? content.keys;
-            const trackedTask = params?.task ?? content.task;
-            const taskLabel = params?.label ?? content.label;
-            const input = params?.input ?? content.input ?? trackedTask;
-            if (keys) {
-                // Send special key sequence
-                await ptyService.sendKeysToSession(sessionId, keys);
-                if (callback) {
-                    await callback({
-                        text: "Sent key sequence to task agent.",
-                    });
-                }
-                return {
-                    success: true,
-                    text: "Sent key sequence",
-                    data: { sessionId, keys },
-                };
-            }
-            else if (input) {
-                // Send text input
-                await ptyService.sendToSession(sessionId, input);
-                if (trackedTask) {
-                    const coordinator = getCoordinator(runtime);
-                    const existingTask = coordinator?.getTaskContext(sessionId);
-                    const evalMetadata = mergeTaskThreadEvalMetadata(message, {
-                        source: "send-to-agent-action",
-                        messageId: message.id,
-                        sessionId,
-                    });
-                    const taskThread = coordinator && !existingTask
-                        ? await coordinator.createTaskThread({
-                            title: taskLabel ||
-                                (typeof session.metadata?.label === "string"
-                                    ? session.metadata.label
-                                    : `agent-${sessionId.slice(-8)}`),
-                            originalRequest: trackedTask,
-                            roomId: typeof message
-                                .roomId === "string"
-                                ? message
-                                    .roomId
-                                : null,
-                            ownerUserId: typeof message
-                                .userId === "string"
-                                ? message
-                                    .userId
-                                : null,
-                            scenarioId: evalMetadata.scenarioId,
-                            batchId: evalMetadata.batchId,
-                            metadata: evalMetadata.metadata,
-                        })
-                        : null;
-                    if (coordinator) {
-                        await coordinator.registerTask(sessionId, {
-                            threadId: existingTask?.threadId ?? taskThread?.id ?? sessionId,
-                            agentType: normalizeAgentType(session.agentType),
-                            label: taskLabel ||
-                                existingTask?.label ||
-                                (typeof session.metadata?.label === "string"
-                                    ? session.metadata.label
-                                    : `agent-${sessionId.slice(-8)}`),
-                            originalTask: trackedTask,
-                            workdir: session.workdir,
-                            ...(existingTask?.repo ? { repo: existingTask.repo } : {}),
-                            metadata: session.metadata &&
-                                typeof session.metadata === "object" &&
-                                !Array.isArray(session.metadata)
-                                ? session.metadata
-                                : undefined,
-                        });
-                        await coordinator.setTaskDelivered(sessionId);
-                    }
-                }
-                if (callback) {
-                    await callback({
-                        text: trackedTask
-                            ? `Assigned new tracked task to task agent: "${trackedTask}"`
-                            : `Sent to task agent: "${input}"`,
-                    });
-                }
-                return {
-                    success: true,
-                    text: trackedTask
-                        ? "Assigned new task to agent"
-                        : "Sent input to agent",
-                    data: {
-                        sessionId,
-                        input,
-                        ...(trackedTask ? { task: trackedTask } : {}),
-                    },
-                };
-            }
-            else {
-                if (callback) {
-                    await callback({
-                        text: "No input provided. Specify 'input', 'task', or 'keys' parameter.",
-                    });
-                }
-                return { success: false, error: "NO_INPUT" };
-            }
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            if (callback) {
-                await callback({
-                    text: `Failed to send to agent: ${errorMessage}`,
-                });
-            }
-            return { success: false, error: errorMessage };
-        }
-    },
-    parameters: [
-        {
-            name: "sessionId",
-            description: "ID of the task-agent session to send to. If not specified, uses the current session.",
-            required: false,
-            schema: { type: "string" },
-        },
-        {
-            name: "input",
-            description: "Text input to send to the running task agent.",
-            required: false,
-            schema: { type: "string" },
-        },
-        {
-            name: "task",
-            description: "New tracked task to assign to the existing agent. This is also sent as the next input so LIST_AGENTS and provider status reflect the new assignment.",
-            required: false,
-            schema: { type: "string" },
-        },
-        {
-            name: "label",
-            description: "Optional label to use when tracking a newly assigned task on an existing agent.",
-            required: false,
-            schema: { type: "string" },
-        },
-        {
-            name: "keys",
-            description: "Special key sequence to send (e.g., 'Enter', 'Ctrl-C', 'y').",
-            required: false,
-            schema: { type: "string" },
-        },
-    ],
-};
-export const sendToTaskAgentAction = sendToAgentAction;

package/packages/typescript/src/features/orchestrator/actions/spawn-agent.d.ts

@@ -1,12 +0,0 @@
-/**
- * SPAWN_AGENT action - Spawns a CLI task agent.
- *
- * Creates a new PTY session for a task agent (Claude Code, Codex, etc.)
- * and returns a session ID for subsequent interactions.
- *
- * @module actions/spawn-agent
- */
-import { type Action } from "@elizaos/core";
-export declare const spawnAgentAction: Action;
-export declare const spawnTaskAgentAction: Action;
-//# sourceMappingURL=spawn-agent.d.ts.map

package/packages/typescript/src/features/orchestrator/actions/spawn-agent.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"spawn-agent.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/orchestrator/actions/spawn-agent.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,EACN,KAAK,MAAM,EAQX,MAAM,eAAe,CAAC;AAqBvB,eAAO,MAAM,gBAAgB,EAAE,MAuZ9B,CAAC;AAEF,eAAO,MAAM,oBAAoB,QAAmB,CAAC"}

package/packages/typescript/src/features/orchestrator/actions/spawn-agent.js

@@ -1,356 +0,0 @@
-/**
- * SPAWN_AGENT action - Spawns a CLI task agent.
- *
- * Creates a new PTY session for a task agent (Claude Code, Codex, etc.)
- * and returns a session ID for subsequent interactions.
- *
- * @module actions/spawn-agent
- */
-import * as os from "node:os";
-import * as path from "node:path";
-import { logger, } from "@elizaos/core";
-import { buildAgentCredentials, isAnthropicOAuthToken, sanitizeCustomCredentials, } from "../services/agent-credentials.js";
-import { readConfigEnvKey } from "../services/config-env.js";
-import { getCoordinator } from "../services/pty-service.js";
-import { isPiAgentType, normalizeAgentType, toPiCommand, } from "../services/pty-types.js";
-import { requireTaskAgentAccess } from "../services/task-policy.js";
-import { mergeTaskThreadEvalMetadata } from "./eval-metadata.js";
-export const spawnAgentAction = {
-    name: "SPAWN_AGENT",
-    similes: [
-        "SPAWN_CODING_AGENT",
-        "START_CODING_AGENT",
-        "LAUNCH_CODING_AGENT",
-        "CREATE_CODING_AGENT",
-        "SPAWN_CODER",
-        "RUN_CODING_AGENT",
-        "SPAWN_SUB_AGENT",
-        "START_TASK_AGENT",
-        "CREATE_AGENT",
-    ],
-    description: "Spawn a specific task agent inside an existing workspace when you need direct control. " +
-        "These agents are intentionally open-ended and can handle investigation, writing, planning, testing, synthesis, repo work, and general async task execution. " +
-        "Returns a session ID that can be used to interact with the agent.",
-    examples: [
-        [
-            {
-                name: "{{user1}}",
-                content: {
-                    text: "Start a Codex task agent in that workspace and have it continue the investigation.",
-                },
-            },
-            {
-                name: "{{agentName}}",
-                content: {
-                    text: "I'll spawn a task agent in the current workspace and hand it the next chunk of work.",
-                    action: "SPAWN_AGENT",
-                },
-            },
-        ],
-        [
-            {
-                name: "{{user1}}",
-                content: {
-                    text: "Spin up a task agent for the follow-up work in this repo.",
-                },
-            },
-            {
-                name: "{{agentName}}",
-                content: {
-                    text: "I'll create a task-agent session for that.",
-                    action: "SPAWN_AGENT",
-                },
-            },
-        ],
-    ],
-    validate: async (runtime, _message) => {
-        // Check if PTYService is available
-        const ptyService = runtime.getService("PTY_SERVICE");
-        if (!ptyService) {
-            logger.warn("[SPAWN_AGENT] PTYService not available");
-            return false;
-        }
-        return true;
-    },
-    handler: async (runtime, message, state, options, callback) => {
-        const access = await requireTaskAgentAccess(runtime, message, "create");
-        if (access.allowed === false) {
-            if (callback) {
-                await callback({
-                    text: access.reason,
-                });
-            }
-            return { success: false, error: "FORBIDDEN", text: access.reason };
-        }
-        const ptyService = runtime.getService("PTY_SERVICE");
-        if (!ptyService) {
-            if (callback) {
-                await callback({
-                    text: "PTY Service is not available. Cannot spawn a task agent.",
-                });
-            }
-            return { success: false, error: "SERVICE_UNAVAILABLE" };
-        }
-        // Extract parameters from options or message content
-        const params = options?.parameters;
-        const content = message.content;
-        const explicitRawType = params?.agentType ?? content.agentType;
-        const task = params?.task ?? content.task;
-        const rawAgentType = explicitRawType ??
-            (await ptyService.resolveAgentType({
-                task,
-                workdir: (params?.workdir ?? content.workdir) ||
-                    undefined,
-            }));
-        const agentType = normalizeAgentType(rawAgentType);
-        const piRequested = isPiAgentType(rawAgentType);
-        const initialTask = piRequested ? toPiCommand(task) : task;
-        // Resolve workdir: explicit param > state from PROVISION_WORKSPACE > most recent workspace > cwd
-        let workdir = params?.workdir ?? content.workdir;
-        if (!workdir && state?.codingWorkspace) {
-            workdir = state.codingWorkspace.path;
-        }
-        if (!workdir) {
-            // Check workspace service for most recently provisioned workspace
-            const wsService = runtime.getService("CODING_WORKSPACE_SERVICE");
-            if (wsService) {
-                const workspaces = wsService.listWorkspaces();
-                if (workspaces.length > 0) {
-                    workdir = workspaces[workspaces.length - 1].path;
-                }
-            }
-        }
-        if (!workdir) {
-            if (callback) {
-                await callback({
-                    text: "No workspace found. Please provision a workspace first using PROVISION_WORKSPACE or provide a workdir.",
-                });
-            }
-            return { success: false, error: "NO_WORKSPACE" };
-        }
-        // Validate workdir is within allowed directories
-        const resolvedWorkdir = path.resolve(workdir);
-        const workspaceBaseDir = path.join(os.homedir(), ".eliza", "workspaces");
-        const allowedPrefixes = [
-            path.resolve(workspaceBaseDir),
-            path.resolve(process.cwd()),
-        ];
-        const isAllowed = allowedPrefixes.some((prefix) => resolvedWorkdir.startsWith(prefix + path.sep) ||
-            resolvedWorkdir === prefix);
-        if (!isAllowed) {
-            if (callback) {
-                await callback({
-                    text: "The specified workdir is outside of allowed directories. Please use a workspace directory.",
-                });
-            }
-            return { success: false, error: "WORKDIR_OUTSIDE_ALLOWED" };
-        }
-        workdir = resolvedWorkdir;
-        const memoryContent = params?.memoryContent ?? content.memoryContent;
-        const approvalPreset = params?.approvalPreset ?? content.approvalPreset;
-        // Custom credentials for MCP servers and other integrations
-        const customCredentialKeys = runtime.getSetting("CUSTOM_CREDENTIAL_KEYS");
-        let customCredentials;
-        if (customCredentialKeys) {
-            customCredentials = {};
-            for (const key of customCredentialKeys.split(",").map((k) => k.trim())) {
-                const val = runtime.getSetting(key);
-                if (val)
-                    customCredentials[key] = val;
-            }
-        }
-        const rawAnthropicKey = runtime.getSetting("ANTHROPIC_API_KEY");
-        customCredentials = sanitizeCustomCredentials(customCredentials, isAnthropicOAuthToken(rawAnthropicKey) ? [rawAnthropicKey] : []);
-        // Build credentials based on the user's configured LLM provider.
-        // Throws if cloud mode is selected but no cloud API key is paired.
-        const llmProvider = readConfigEnvKey("PARALLAX_LLM_PROVIDER") || "subscription";
-        let credentials;
-        try {
-            credentials = buildAgentCredentials(runtime);
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : "Failed to build credentials";
-            logger.error(`[spawn-agent] ${msg}`);
-            if (callback) {
-                await callback({ text: msg });
-            }
-            return { success: false, error: "INVALID_CREDENTIALS" };
-        }
-        try {
-            // Check if the agent CLI is installed (for non-shell agents)
-            if (agentType !== "shell" && agentType !== "pi") {
-                const [preflight] = await ptyService.checkAvailableAgents([
-                    agentType,
-                ]);
-                if (preflight && !preflight.installed) {
-                    if (callback) {
-                        await callback({
-                            text: `${preflight.adapter} CLI is not installed.\n` +
-                                `Install with: ${preflight.installCommand}\n` +
-                                `Docs: ${preflight.docsUrl}`,
-                        });
-                    }
-                    return { success: false, error: "AGENT_NOT_INSTALLED" };
-                }
-            }
-            // Check if coordinator is active — route blocking prompts through it
-            const coordinator = getCoordinator(runtime);
-            const evalMetadata = mergeTaskThreadEvalMetadata(message, {
-                source: "spawn-agent-action",
-                messageId: message.id,
-                requestedType: rawAgentType,
-            });
-            const taskThread = coordinator && task
-                ? await coordinator.createTaskThread({
-                    title: `agent-${Date.now()}`,
-                    originalRequest: task,
-                    roomId: typeof message
-                        .roomId === "string"
-                        ? message
-                            .roomId
-                        : null,
-                    ownerUserId: typeof message
-                        .userId === "string"
-                        ? message
-                            .userId
-                        : null,
-                    scenarioId: evalMetadata.scenarioId,
-                    batchId: evalMetadata.batchId,
-                    metadata: evalMetadata.metadata,
-                })
-                : null;
-            // Spawn the PTY session
-            const session = await ptyService.spawnSession({
-                name: `task-${Date.now()}`,
-                agentType,
-                workdir,
-                initialTask,
-                memoryContent,
-                credentials,
-                approvalPreset: approvalPreset ??
-                    ptyService.defaultApprovalPreset,
-                customCredentials,
-                // Let adapter auto-response handle startup prompts (API key, trust, etc.)
-                // when using cloud/API key mode — the LLM coordinator misinterprets these.
-                // In subscription mode, the coordinator handles all prompts.
-                ...(coordinator && llmProvider === "subscription"
-                    ? { skipAdapterAutoResponse: true }
-                    : {}),
-                metadata: {
-                    threadId: taskThread?.id,
-                    requestedType: rawAgentType,
-                    messageId: message.id,
-                    userId: message.userId,
-                },
-            });
-            // Register event handler for this session
-            ptyService.onSessionEvent((sessionId, event, data) => {
-                if (sessionId !== session.id)
-                    return;
-                // Log session events for debugging
-                logger.debug(`[Session ${sessionId}] ${event}: ${JSON.stringify(data)}`);
-                // When coordinator is active it owns chat messaging for these events
-                if (!coordinator) {
-                    // Handle blocked state - agent is waiting for input
-                    if (event === "blocked" && callback) {
-                        callback({
-                            text: `Task agent is waiting for input: ${data.prompt ?? "unknown prompt"}`,
-                        });
-                    }
-                    // Handle completion
-                    if (event === "completed" && callback) {
-                        callback({
-                            text: "Task agent completed the task.",
-                        });
-                    }
-                    // Handle errors
-                    if (event === "error" && callback) {
-                        callback({
-                            text: `Task agent encountered an error: ${data.message ?? "unknown error"}`,
-                        });
-                    }
-                }
-            });
-            if (coordinator && task) {
-                await coordinator.registerTask(session.id, {
-                    threadId: taskThread?.id ?? session.id,
-                    agentType,
-                    label: `agent-${session.id.slice(-8)}`,
-                    originalTask: task,
-                    workdir,
-                });
-            }
-            // Store session info in state for subsequent actions
-            if (state) {
-                state.codingSession = {
-                    id: session.id,
-                    agentType: session.agentType,
-                    workdir: session.workdir,
-                    status: session.status,
-                };
-            }
-            if (callback) {
-                await callback({
-                    text: `Started ${piRequested ? "pi" : agentType} task agent in ${workdir}${task ? ` with task: "${task}"` : ""}. Session ID: ${session.id}`,
-                });
-            }
-            return {
-                success: true,
-                text: `Started ${piRequested ? "pi" : agentType} task agent`,
-                data: {
-                    sessionId: session.id,
-                    agentType: piRequested ? "pi" : session.agentType,
-                    workdir: session.workdir,
-                    status: session.status,
-                },
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            logger.error("[SPAWN_AGENT] Failed to spawn agent:", errorMessage);
-            if (callback) {
-                await callback({
-                    text: `Failed to spawn task agent: ${errorMessage}`,
-                });
-            }
-            return { success: false, error: errorMessage };
-        }
-    },
-    parameters: [
-        {
-            name: "agentType",
-            description: "Specific task-agent framework to spawn. Options: claude (Claude Code), codex (OpenAI Codex), gemini (Google Gemini), aider, pi, shell (generic shell). " +
-                "If omitted, the orchestrator picks the preferred available framework.",
-            required: false,
-            schema: { type: "string" },
-        },
-        {
-            name: "workdir",
-            description: "Working directory for the agent. Defaults to current directory.",
-            required: false,
-            schema: { type: "string" },
-        },
-        {
-            name: "task",
-            description: "Open-ended task or prompt to send to the task agent once spawned.",
-            required: false,
-            schema: { type: "string" },
-        },
-        {
-            name: "memoryContent",
-            description: "Instructions or shared context to write to the task agent's memory file before spawning.",
-            required: false,
-            schema: { type: "string" },
-        },
-        {
-            name: "approvalPreset",
-            description: "Permission level for the task agent: readonly (safe audit), standard (reads+web auto, writes prompt), permissive (file ops auto, shell prompts), autonomous (all auto, use with sandbox)",
-            required: false,
-            schema: {
-                type: "string",
-                enum: ["readonly", "standard", "permissive", "autonomous"],
-            },
-        },
-    ],
-};
-export const spawnTaskAgentAction = spawnAgentAction;

package/packages/typescript/src/features/orchestrator/actions/start-coding-task.d.ts

@@ -1,22 +0,0 @@
-/**
- * CREATE_TASK action - Unified action to set up and launch task agents.
- *
- * Combines workspace provisioning and agent spawning into a single atomic action.
- * - If a repo URL is provided, clones it into a fresh workspace
- * - If no repo, creates a scratch sandbox directory
- * - Spawns the specified task agent(s) in that workspace with the given task
- * - Supports multi-agent mode via pipe-delimited `agents` param
- *
- * This eliminates the need for multi-action chaining (PROVISION_WORKSPACE -> SPAWN_AGENT)
- * and ensures agents always run in an isolated directory.
- *
- * @module actions/start-coding-task
- */
-import { type Action } from "@elizaos/core";
-type BackgroundAction = Action & {
-    suppressPostActionContinuation?: boolean;
-};
-export declare const startCodingTaskAction: BackgroundAction;
-export declare const createTaskAction: BackgroundAction;
-export {};
-//# sourceMappingURL=start-coding-task.d.ts.map

package/packages/typescript/src/features/orchestrator/actions/start-coding-task.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"start-coding-task.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/orchestrator/actions/start-coding-task.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EACN,KAAK,MAAM,EAQX,MAAM,eAAe,CAAC;AAkBvB,KAAK,gBAAgB,GAAG,MAAM,GAAG;IAChC,8BAA8B,CAAC,EAAE,OAAO,CAAC;CACzC,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,gBA0TnC,CAAC;AAEF,eAAO,MAAM,gBAAgB,kBAAwB,CAAC"}