@hold-rein/cli 0.0.0

package/dist/runtime/api/modules/agents/runtime/browser-tool-call-store.js

@@ -0,0 +1,69 @@
+export function createBrowserToolCallStore(timeoutMs = 60_000) {
+    const pending = new Map();
+    return {
+        clearAgent(agentId) {
+            for (const [key, call] of pending) {
+                if (call.agentId !== agentId)
+                    continue;
+                clearTimeout(call.timeout);
+                pending.delete(key);
+                call.resolve({
+                    content: [
+                        { text: "Browser tool call was interrupted.", type: "text" }
+                    ],
+                    details: { toolName: call.toolName },
+                    isError: true
+                });
+            }
+        },
+        createCall(request) {
+            const key = createKey(request.agentId, request.toolCallId);
+            if (pending.has(key)) {
+                return Promise.resolve({
+                    content: [
+                        { text: "Duplicate browser tool call id.", type: "text" }
+                    ],
+                    details: { toolName: request.toolName },
+                    isError: true
+                });
+            }
+            return new Promise((resolve) => {
+                const timeout = setTimeout(() => {
+                    pending.delete(key);
+                    resolve({
+                        content: [
+                            { text: "Browser tool call timed out.", type: "text" }
+                        ],
+                        details: { toolName: request.toolName },
+                        isError: true
+                    });
+                }, timeoutMs);
+                pending.set(key, {
+                    agentId: request.agentId,
+                    resolve,
+                    timeout,
+                    toolName: request.toolName
+                });
+            });
+        },
+        submitResult(input) {
+            const key = createKey(input.agentId, input.toolCallId);
+            const call = pending.get(key);
+            if (!call)
+                return false;
+            clearTimeout(call.timeout);
+            pending.delete(key);
+            call.resolve({
+                content: typeof input.content === "string"
+                    ? [{ text: input.content, type: "text" }]
+                    : input.content,
+                details: { toolName: call.toolName },
+                isError: input.isError ?? false
+            });
+            return true;
+        }
+    };
+}
+function createKey(agentId, toolCallId) {
+    return `${agentId}\0${toolCallId}`;
+}

package/dist/runtime/api/modules/agents/runtime/continuation-subagent.d.ts

@@ -0,0 +1,26 @@
+import type { AgentEventBus } from "../event/event-bus";
+import type { HarnessSession, StartHarnessOptions, StartHarnessResult } from "./type";
+import type { SubagentRun } from "../subagent";
+import type { SubagentRepository } from "../subagent/repository";
+type StartHarness = (promptText: string, harnessOptions: StartHarnessOptions) => Promise<StartHarnessResult>;
+interface SessionRepo {
+    create: (input: {
+        cwd: string;
+    }) => Promise<HarnessSession>;
+}
+export declare function startContinuationSubagent(input: {
+    agentName?: string;
+    eventBus: AgentEventBus;
+    parentAgentId: string;
+    parentAgentName: string | undefined;
+    parentSession: HarnessSession;
+    prompt: string;
+    sessionRepo: SessionRepo;
+    startHarness: StartHarness;
+    subagentRepository: SubagentRepository;
+    subagents: Map<string, SubagentRun<HarnessSession>>;
+    taskId: string;
+    workspacePath: string;
+}): Promise<void>;
+export {};
+//# sourceMappingURL=continuation-subagent.d.ts.map

package/dist/runtime/api/modules/agents/runtime/continuation-subagent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"continuation-subagent.d.ts","sourceRoot":"","sources":["../../../../src/modules/agents/runtime/continuation-subagent.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAGxD,OAAO,KAAK,EACV,cAAc,EACd,mBAAmB,EACnB,kBAAkB,EACnB,MAAM,QAAQ,CAAC;AAChB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAKjE,KAAK,YAAY,GAAG,CAClB,UAAU,EAAE,MAAM,EAClB,cAAc,EAAE,mBAAmB,KAChC,OAAO,CAAC,kBAAkB,CAAC,CAAC;AAEjC,UAAU,WAAW;IACnB,MAAM,EAAE,CAAC,KAAK,EAAE;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,cAAc,CAAC,CAAC;CAC7D;AAED,wBAAsB,yBAAyB,CAAC,KAAK,EAAE;IACrD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,aAAa,CAAC;IACxB,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,aAAa,EAAE,cAAc,CAAC;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,WAAW,CAAC;IACzB,YAAY,EAAE,YAAY,CAAC;IAC3B,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,cAAc,CAAC,CAAC,CAAC;IACpD,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,CAAC;CACvB,GAAG,OAAO,CAAC,IAAI,CAAC,CAgEhB"}

package/dist/runtime/api/modules/agents/runtime/continuation-subagent.js

@@ -0,0 +1,67 @@
+import { randomUUID } from "node:crypto";
+import { appendVisibleCustomMessage } from "./messages.js";
+import { toAgentSessionMetadata } from "./support.js";
+const CALL_SUBAGENT_CUSTOM_TYPE = "callsubagent";
+const DEFAULT_SUBAGENT_NAME = "subagent";
+export async function startContinuationSubagent(input) {
+    const agentName = input.agentName ?? DEFAULT_SUBAGENT_NAME;
+    const agentId = `agent_${randomUUID()}`;
+    const createdAt = new Date().toISOString();
+    const childSession = await input.sessionRepo.create({ cwd: input.workspacePath });
+    const childSessionMetadata = toAgentSessionMetadata(await childSession.getMetadata());
+    input.subagentRepository.create({
+        agentId,
+        agentName,
+        createdAt,
+        parentAgentId: input.parentAgentId,
+        sessionCreatedAt: childSessionMetadata.createdAt,
+        sessionId: childSessionMetadata.id,
+        sessionPath: childSessionMetadata.path,
+        status: "running",
+        taskId: input.taskId,
+        updatedAt: createdAt
+    });
+    let started;
+    try {
+        started = await input.startHarness(input.prompt, {
+            agentId,
+            agentName,
+            isContinue: false,
+            parentAgentId: input.parentAgentId,
+            pluginPrompt: input.prompt,
+            session: childSession
+        });
+    }
+    catch (error) {
+        input.subagentRepository.delete(agentId);
+        throw error;
+    }
+    input.subagents.set(started.agentId, {
+        agentId: started.agentId,
+        agentName,
+        agentSession: started.harnessSession,
+        consumed: false,
+        lastAssistantText: "",
+        parentAgentId: input.parentAgentId,
+        ...(input.parentAgentName === undefined
+            ? {}
+            : { parentAgentName: input.parentAgentName }),
+        parentSession: input.parentSession,
+        session: started.session,
+        status: "running"
+    });
+    await appendVisibleCustomMessage({
+        agentId: input.parentAgentId,
+        content: `Subagent "${agentName}" is running.`,
+        customType: CALL_SUBAGENT_CUSTOM_TYPE,
+        details: {
+            agentId: started.agentId,
+            agentName,
+            parentAgentId: input.parentAgentId,
+            session: started.session,
+            taskId: input.taskId
+        },
+        eventBus: input.eventBus,
+        session: input.parentSession
+    });
+}

package/dist/runtime/api/modules/agents/runtime/index.d.ts

@@ -0,0 +1,3 @@
+import type { AgentRuntime, CreateAgentRuntimeOptions } from './type';
+export declare function createAgentRuntime(options: CreateAgentRuntimeOptions): AgentRuntime;
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/api/modules/agents/runtime/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/modules/agents/runtime/index.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,YAAY,EAAE,yBAAyB,EAA4H,MAAM,QAAQ,CAAA;AAI/L,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,yBAAyB,GACjC,YAAY,CAodd"}

package/dist/runtime/api/modules/agents/runtime/index.js

@@ -0,0 +1,432 @@
+import { randomUUID } from "node:crypto";
+import { AgentHarness, NodeExecutionEnv, formatSkillsForSystemPrompt, loadSkills } from "@earendil-works/pi-agent-core/node";
+import { toStoredAgentMessage } from "../message/storage.js";
+import { resolveAgentModel } from "../model/resolver.js";
+import { appendVisibleCustomMessage } from "./messages.js";
+import { addPendingSubagentResult, appendSubagentResult, flushPendingSubagentResults } from "./subagent-results.js";
+import { createRuntimeRevokeSubagentTool, createRuntimeSubagentTools } from "./subagent-tools.js";
+import { startContinuationSubagent } from "./continuation-subagent.js";
+import { createSessionRepo, getEnvApiKey, getRuntimeSkillDirs, interruptHarness, toAgentSessionMetadata } from "./support.js";
+import { createRuntimeTokenCollectionOptions, createTokenCollection } from "./token-collection.js";
+import { runToolBeforeExecute } from "../approval/tool-approval.js";
+import { extractAssistantText, getNextCompletedSubagent, hasRunningSubagent } from "../subagent/index.js";
+import { pluginRegistry } from '../../../plugin.js';
+import { formatWorkspaceAgentInstructionsForSystemPrompt, readWorkspaceAgentInstructions } from "./workspace-agent-instructions.js";
+import { createModelProxyRuntimeController } from "../../model-proxies/model-proxy-runtime.js";
+import { createBrowserToolCallStore } from "./browser-tool-call-store.js";
+import { createBrowserRuntimeTools } from "./browser-runtime-tools.js";
+import { toRuntimeSkills } from "./browser-runtime-contributions.js";
+const AGENT_CONTINUATION_CUSTOM_TYPE = "agent_continuation";
+const AGENT_CONTINUE_PROMPT = "";
+export function createAgentRuntime(options) {
+    const runningAgents = new Map();
+    const sessionRepo = options.sessionRepo ?? createSessionRepo();
+    const subagentRepository = options.subagentRepository;
+    const subagents = new Map();
+    const harnessSessions = new Map();
+    const harnessTools = new Map();
+    const interruptedHarnesses = new WeakSet();
+    const tokenCollections = new Map();
+    const browserToolCalls = createBrowserToolCallStore(options.browserToolTimeoutMs);
+    return {
+        interrupt: async (agentId) => {
+            const runningAgent = runningAgents.get(agentId);
+            if (!runningAgent) {
+                return false;
+            }
+            interruptedHarnesses.add(runningAgent.harness);
+            browserToolCalls.clearAgent(agentId);
+            runningAgents.delete(agentId);
+            await interruptHarness(runningAgent.harness);
+            return true;
+        },
+        listMessages: async ({ session: metadata, workspacePath }) => {
+            const session = await sessionRepo.open({ ...metadata, cwd: workspacePath });
+            const context = await session.buildContext();
+            return context.messages.map((message) => toStoredAgentMessage(`message_${randomUUID()}`, message));
+        },
+        submitBrowserToolResult: async (input) => browserToolCalls.submitResult(input),
+        start: async (input) => {
+            const env = new NodeExecutionEnv({ cwd: input.workspacePath });
+            const proxyCandidate = input.provider === "local"
+                ? options.modelProxiesService?.selectCandidate(input.modelId)
+                : undefined;
+            if (input.provider === "local" && !proxyCandidate) {
+                throw new Error(options.modelProxiesService ? "No available model for proxy" : "Unknown proxy model");
+            }
+            const initialProvider = proxyCandidate?.provider ?? input.provider;
+            const initialModelId = proxyCandidate?.modelId ?? input.modelId;
+            let model = await resolveAgentModel(initialProvider, initialModelId, options.getCustomModel);
+            if (!model) {
+                throw new Error("Unknown model");
+            }
+            const workspaceAgentInstructions = await readWorkspaceAgentInstructions(input.workspacePath);
+            const pendingSubagentResults = new Map();
+            const createHarness = async (harnessOptions) => {
+                let activeMessageId;
+                let activeModel = model;
+                let proxyController;
+                const pendingVisibleMessages = new Map();
+                const pluginContext = {
+                    agentName: harnessOptions.agentName ?? "main",
+                    env,
+                    isContinue: harnessOptions.isContinue,
+                    session: harnessOptions.session,
+                    prompt: harnessOptions.pluginPrompt,
+                    taskId: input.taskId,
+                    thinkingLevel: input.thinkingLevel,
+                    model: activeModel
+                };
+                const contribution = await pluginRegistry.resolveContributions(pluginContext);
+                const skillDirs = await getRuntimeSkillDirs(input.workspacePath, [...(options.skillDirs || []), ...(contribution.skillDirs || [])], options.skillsService);
+                const { skills: loadedSkills } = await loadSkills(env, skillDirs);
+                const skills = [
+                    ...loadedSkills,
+                    ...(contribution.skills || []),
+                    ...toRuntimeSkills(input.runtimeContributions?.skills)
+                ];
+                const browserTools = createBrowserRuntimeTools({
+                    agentId: harnessOptions.agentId, eventBus: options.eventBus,
+                    store: browserToolCalls, tools: input.runtimeContributions?.tools
+                });
+                const tools = await createRuntimeSubagentTools({
+                    contributionTools: [...(contribution.tools || []), ...browserTools],
+                    eventBus: options.eventBus,
+                    parentAgentId: harnessOptions.agentId,
+                    ...(harnessOptions.agentName === undefined
+                        ? {}
+                        : { parentAgentName: harnessOptions.agentName }),
+                    parentSession: harnessOptions.session,
+                    pendingVisibleMessages,
+                    sessionRepo,
+                    startHarness,
+                    persistedSubagentRepository: subagentRepository,
+                    ...(options.subagentDatabase === undefined ? {} : { subagentDatabase: options.subagentDatabase }),
+                    subagents,
+                    taskId: input.taskId,
+                    workspacePath: input.workspacePath
+                });
+                harnessSessions.set(harnessOptions.agentId, harnessOptions.session);
+                harnessTools.set(harnessOptions.agentId, tools);
+                const harness = new AgentHarness({
+                    activeToolNames: tools.map(tool => tool.name),
+                    env,
+                    getApiKeyAndHeaders: async (requestedModel) => {
+                        const apiModel = requestedModel ?? proxyController?.getActiveModel() ?? activeModel;
+                        const apiKey = (await options.getApiKey?.(apiModel.provider, apiModel.id)) ??
+                            getEnvApiKey(apiModel.provider);
+                        return apiKey ? { apiKey } : undefined;
+                    },
+                    model: contribution.model || activeModel,
+                    resources: { skills },
+                    session: harnessOptions.session,
+                    systemPrompt: ({ resources }) => [
+                        ...(contribution.systemPrompts || []),
+                        ...(input.runtimeContributions?.systemPrompts || []),
+                        `Workspace: ${input.workspacePath}`,
+                        formatWorkspaceAgentInstructionsForSystemPrompt(workspaceAgentInstructions),
+                        `Current time: ${new Date().toISOString()}`,
+                        "Use shell_exec for workspace commands and skill scripts.",
+                        "Resolve skill-relative references from each skill file directory.",
+                        formatSkillsForSystemPrompt(resources.skills ?? [])
+                    ]
+                        .filter(Boolean)
+                        .join("\n\n"),
+                    thinkingLevel: input.thinkingLevel,
+                    tools
+                });
+                if (proxyCandidate && options.modelProxiesService) {
+                    proxyController = createModelProxyRuntimeController({
+                        activeCandidate: proxyCandidate,
+                        activeModel,
+                        proxyModelId: input.modelId,
+                        resolveModel: (provider, modelId) => resolveAgentModel(provider, modelId, options.getCustomModel),
+                        service: options.modelProxiesService,
+                        setModel: async (nextModel) => {
+                            model = nextModel;
+                            activeModel = nextModel;
+                            await harness.setModel(nextModel);
+                        }
+                    });
+                }
+                const tokenCollection = tokenCollections.get(input.taskId) ??
+                    createTokenCollection(input.taskId, createRuntimeTokenCollectionOptions({
+                        tokenFlushIntervalMs: options.tokenFlushIntervalMs,
+                        tokenUsageStorageTarget: options.tokenUsageStorageTarget
+                    }));
+                tokenCollections.set(input.taskId, tokenCollection);
+                tokenCollection.appendHarness(harness);
+                harness.subscribe(async (event) => {
+                    try {
+                        contribution.subscribe?.(event);
+                    }
+                    catch {
+                        // Keep plugin subscriber failures from breaking agent event delivery.
+                    }
+                    if (event.type === "message_start") {
+                        activeMessageId = `message_${randomUUID()}`;
+                        options.eventBus.emit({
+                            agentId: harnessOptions.agentId,
+                            payload: { message: toStoredAgentMessage(activeMessageId, event.message) },
+                            type: "message_start"
+                        });
+                        return;
+                    }
+                    if (event.type === "message_update" && activeMessageId) {
+                        options.eventBus.emit({
+                            agentId: harnessOptions.agentId,
+                            payload: {
+                                delta: event.assistantMessageEvent,
+                                messageId: activeMessageId
+                            },
+                            type: "message_delta"
+                        });
+                        return;
+                    }
+                    if (event.type === "message_end") {
+                        const messageId = activeMessageId ?? `message_${randomUUID()}`;
+                        const message = toStoredAgentMessage(messageId, event.message);
+                        const subagent = subagents.get(harnessOptions.agentId);
+                        if (subagent) {
+                            subagent.lastAssistantText = extractAssistantText(event.message);
+                        }
+                        options.eventBus.emit({
+                            agentId: harnessOptions.agentId,
+                            payload: { message },
+                            type: "message_end"
+                        });
+                        activeMessageId = undefined;
+                        if (proxyController && event.message.role === "assistant") {
+                            try {
+                                await proxyController.recordAssistantUsage({
+                                    inputToken: event.message.usage?.input ?? 0,
+                                    modelId: event.message.model,
+                                    outputToken: event.message.usage?.output ?? 0,
+                                    provider: event.message.provider
+                                });
+                            }
+                            catch (error) {
+                                options.eventBus.emit({
+                                    agentId: harnessOptions.agentId,
+                                    payload: {
+                                        message: error instanceof Error ? error.message : "Proxy fallback unavailable"
+                                    },
+                                    type: "agent_error"
+                                });
+                            }
+                        }
+                        if (event.message.role === "toolResult") {
+                            const pendingMessages = pendingVisibleMessages.get(event.message.toolCallId);
+                            if (pendingMessages) {
+                                for (const pendingMessage of pendingMessages) {
+                                    await appendVisibleCustomMessage({
+                                        agentId: harnessOptions.agentId,
+                                        ...pendingMessage,
+                                        eventBus: options.eventBus,
+                                        session: harnessOptions.session
+                                    });
+                                }
+                                pendingVisibleMessages.delete(event.message.toolCallId);
+                            }
+                            await flushPendingSubagentResults({
+                                agentId: harnessOptions.agentId,
+                                eventBus: options.eventBus,
+                                pendingSubagentResults,
+                                session: harnessOptions.session,
+                                subagents
+                            });
+                        }
+                        return;
+                    }
+                    if (event.type === "agent_end") {
+                        options.eventBus.emit({ agentId: harnessOptions.agentId, type: "agent_end" });
+                        if (interruptedHarnesses.has(harness)) {
+                            return;
+                        }
+                        if (harnessOptions.parentAgentId) {
+                            await finishSubagent(harnessOptions.agentId, contribution);
+                            return;
+                        }
+                        const continued = await continueOrEndTask(harnessOptions.agentId, harnessOptions.agentName, harnessOptions.session, contribution);
+                        if (!continued) {
+                            options.eventBus.emit({
+                                agentId: harnessOptions.agentId,
+                                type: "task_end"
+                            });
+                        }
+                    }
+                });
+                harness.on("tool_call", async (event) => {
+                    const tool = tools.find(tool => tool.name === event.toolName);
+                    if (!tool)
+                        return undefined;
+                    return runToolBeforeExecute({
+                        agentId: harnessOptions.agentId,
+                        approvalStore: options.approvalStore,
+                        event,
+                        eventBus: options.eventBus,
+                        approvalPolicy: input.approvalPolicy,
+                        tool,
+                        workspacePath: input.workspacePath
+                    });
+                });
+                return harness;
+            };
+            const finishSubagent = async (agentId, contribution) => {
+                const subagent = subagents.get(agentId);
+                if (!subagent)
+                    return;
+                const continued = await continueOrEndTask(subagent.agentId, subagent.agentName, subagent.agentSession, contribution);
+                if (continued)
+                    return;
+                subagent.status = "completed";
+                subagentRepository.updateStatus(subagent.agentId, "completed", new Date().toISOString());
+                await addRevokeToolToHarness(subagent.parentAgentId);
+                await continueOrEndTask(subagent.parentAgentId, subagent.parentAgentName, subagent.parentSession, undefined, { deferIfRunning: true });
+            };
+            const addRevokeToolToHarness = async (agentId) => {
+                const tools = harnessTools.get(agentId);
+                const parentSession = harnessSessions.get(agentId);
+                if (!tools || !parentSession || tools.some((tool) => tool.name === "revoke_subagent")) {
+                    return;
+                }
+                const tool = createRuntimeRevokeSubagentTool({
+                    eventBus: options.eventBus,
+                    parentAgentId: agentId,
+                    parentSession,
+                    sessionRepo,
+                    startHarness,
+                    persistedSubagentRepository: subagentRepository,
+                    ...(options.subagentDatabase === undefined ? {} : { subagentDatabase: options.subagentDatabase }),
+                    subagents,
+                    taskId: input.taskId,
+                    workspacePath: input.workspacePath
+                });
+                tools.push(tool);
+                await runningAgents.get(agentId)?.harness.setTools?.(tools, tools.map((item) => item.name));
+            };
+            const continueOrEndTask = async (harnessAgentId, harnessAgentName, harnessSession, contribution, continueOptions = {}) => {
+                const currentSubagent = subagents.get(harnessAgentId);
+                const completedSubagent = getNextCompletedSubagent(subagents, harnessAgentId);
+                if (completedSubagent) {
+                    if (continueOptions.deferIfRunning && runningAgents.has(harnessAgentId)) {
+                        addPendingSubagentResult(pendingSubagentResults, harnessAgentId, completedSubagent.agentId);
+                        return true;
+                    }
+                    const prompt = await appendSubagentResult({
+                        agentId: harnessAgentId,
+                        eventBus: options.eventBus,
+                        pendingSubagentResults,
+                        session: harnessSession,
+                        subagent: completedSubagent
+                    });
+                    await startHarness(AGENT_CONTINUE_PROMPT, {
+                        agentId: harnessAgentId,
+                        isContinue: true,
+                        pluginPrompt: prompt,
+                        session: harnessSession,
+                        ...(currentSubagent === undefined ? {} : { parentAgentId: currentSubagent.parentAgentId }),
+                        ...(harnessAgentName === undefined ? {} : { agentName: harnessAgentName })
+                    });
+                    return true;
+                }
+                if (hasRunningSubagent(subagents, harnessAgentId)) {
+                    return true;
+                }
+                const currentSessionMetadata = toAgentSessionMetadata(await harnessSession.getMetadata());
+                const context = await harnessSession.buildContext();
+                const continuation = await contribution?.onAgentEnd?.({
+                    messages: context.messages,
+                    runInput: { ...input, session: currentSessionMetadata },
+                    session: currentSessionMetadata
+                });
+                if (!continuation?.prompt) {
+                    return false;
+                }
+                if (continuation.useSubagent === true) {
+                    await startContinuationSubagent({
+                        ...(continuation.agentName === undefined
+                            ? {}
+                            : { agentName: continuation.agentName }),
+                        eventBus: options.eventBus,
+                        parentAgentId: harnessAgentId,
+                        parentAgentName: harnessAgentName,
+                        parentSession: harnessSession,
+                        prompt: continuation.prompt,
+                        sessionRepo,
+                        startHarness,
+                        subagentRepository,
+                        subagents,
+                        taskId: input.taskId,
+                        workspacePath: input.workspacePath
+                    });
+                    return true;
+                }
+                await appendVisibleCustomMessage({
+                    agentId: harnessAgentId,
+                    content: continuation.prompt,
+                    customType: AGENT_CONTINUATION_CUSTOM_TYPE,
+                    details: continuation.details,
+                    eventBus: options.eventBus,
+                    session: harnessSession
+                });
+                await startHarness(AGENT_CONTINUE_PROMPT, {
+                    agentId: harnessAgentId,
+                    isContinue: true,
+                    pluginPrompt: continuation.prompt,
+                    session: harnessSession,
+                    ...(currentSubagent === undefined ? {} : { parentAgentId: currentSubagent.parentAgentId }),
+                    ...(harnessAgentName === undefined ? {} : { agentName: harnessAgentName })
+                });
+                return true;
+            };
+            const startHarness = async (promptText, harnessOptions) => {
+                const harnessAgentId = harnessOptions.agentId ?? `agent_${randomUUID()}`;
+                const harnessSession = harnessOptions.session ?? (await sessionRepo.create({ cwd: input.workspacePath }));
+                const harnessSessionMetadata = toAgentSessionMetadata(await harnessSession.getMetadata());
+                const harness = await createHarness({
+                    ...harnessOptions,
+                    agentId: harnessAgentId,
+                    session: harnessSession
+                });
+                runningAgents.set(harnessAgentId, {
+                    harness,
+                    sessionId: harnessSessionMetadata.id
+                });
+                void harness.prompt(promptText)
+                    .catch((error) => {
+                    options.eventBus.emit({
+                        agentId: harnessAgentId,
+                        payload: {
+                            message: error instanceof Error ? error.message : "Agent run failed"
+                        },
+                        type: "agent_error"
+                    });
+                })
+                    .finally(() => {
+                    if (runningAgents.get(harnessAgentId)?.harness === harness) {
+                        runningAgents.delete(harnessAgentId);
+                    }
+                });
+                return {
+                    agentId: harnessAgentId,
+                    harnessSession,
+                    session: harnessSessionMetadata
+                };
+            };
+            const inputSession = input.session
+                ? await sessionRepo.open({ ...input.session, cwd: input.workspacePath })
+                : undefined;
+            const startedHarness = await startHarness(input.prompt, {
+                isContinue: false,
+                pluginPrompt: input.prompt,
+                ...(inputSession ? { session: inputSession } : {})
+            });
+            return {
+                agentId: startedHarness.agentId,
+                session: startedHarness.session,
+                status: "running"
+            };
+        }
+    };
+}

package/dist/runtime/api/modules/agents/runtime/messages.d.ts

@@ -0,0 +1,12 @@
+import type { AgentEventBus } from "../event/event-bus";
+export declare function appendVisibleCustomMessage(input: {
+    agentId: string;
+    content: string;
+    customType: string;
+    details?: unknown;
+    eventBus: AgentEventBus;
+    session: {
+        appendCustomMessageEntry: (customType: string, content: string, display: boolean, details?: unknown) => Promise<unknown>;
+    };
+}): Promise<void>;
+//# sourceMappingURL=messages.d.ts.map

package/dist/runtime/api/modules/agents/runtime/messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../../../src/modules/agents/runtime/messages.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAGxD,wBAAsB,0BAA0B,CAAC,KAAK,EAAE;IACtD,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,EAAE,aAAa,CAAC;IACxB,OAAO,EAAE;QACP,wBAAwB,EAAE,CACxB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,OAAO,EAChB,OAAO,CAAC,EAAE,OAAO,KACd,OAAO,CAAC,OAAO,CAAC,CAAC;KACvB,CAAC;CACH,iBAsBA"}

package/dist/runtime/api/modules/agents/runtime/messages.js

@@ -0,0 +1,19 @@
+import { randomUUID } from "node:crypto";
+export async function appendVisibleCustomMessage(input) {
+    await input.session.appendCustomMessageEntry(input.customType, input.content, true, input.details);
+    input.eventBus.emit({
+        agentId: input.agentId,
+        payload: {
+            message: {
+                content: input.content,
+                customType: input.customType,
+                ...(input.details === undefined ? {} : { details: input.details }),
+                display: true,
+                id: `message_${randomUUID()}`,
+                role: "custom",
+                timestamp: Date.now()
+            }
+        },
+        type: "message_start"
+    });
+}

package/dist/runtime/api/modules/agents/runtime/subagent-results.d.ts

@@ -0,0 +1,22 @@
+import type { AgentEventBus } from "../event/event-bus";
+import { type SubagentRun } from "../subagent";
+interface VisibleCustomMessageSession {
+    appendCustomMessageEntry: (customType: string, content: string, display: boolean, details?: unknown) => Promise<unknown>;
+}
+export declare function addPendingSubagentResult(pendingSubagentResults: Map<string, Set<string>>, agentId: string, subagentId: string): void;
+export declare function flushPendingSubagentResults<Session extends VisibleCustomMessageSession>(input: {
+    agentId: string;
+    eventBus: AgentEventBus;
+    pendingSubagentResults: Map<string, Set<string>>;
+    session: Session;
+    subagents: Map<string, SubagentRun<Session>>;
+}): Promise<void>;
+export declare function appendSubagentResult<Session extends VisibleCustomMessageSession>(input: {
+    agentId: string;
+    eventBus: AgentEventBus;
+    pendingSubagentResults: Map<string, Set<string>>;
+    session: Session;
+    subagent: SubagentRun<Session>;
+}): Promise<string>;
+export {};
+//# sourceMappingURL=subagent-results.d.ts.map