@hold-rein/cli 0.0.0

package/dist/runtime/api/modules/agents/agent-runtime.js

@@ -0,0 +1,371 @@
+/* eslint-disable max-lines */
+import { randomUUID } from "node:crypto";
+import { AgentHarness, NodeExecutionEnv, formatSkillsForSystemPrompt, loadSkills } from "@earendil-works/pi-agent-core/node";
+import { toStoredAgentMessage } from "./agent-message-storage.js";
+import { resolveAgentModel } from "./agent-model-resolver.js";
+import {} from "./agent-types.js";
+import { appendVisibleCustomMessage } from "./agent-runtime-messages.js";
+import { runToolBeforeExecute } from "./agent-tool-approval.js";
+import { createCallSubagentTool, extractAssistantText, formatSubagentResult, getNextCompletedSubagent, hasRunningSubagent } from "./agent-subagents.js";
+import { createSessionRepo, getEnvApiKey, getSkillDirs, interruptHarness, toAgentSessionMetadata } from "./agent-runtime-support.js";
+import { createInMemorySubagentRepository } from "./subagent-repository.js";
+import { pluginRegistry } from '../../plugin.js';
+const AGENT_CONTINUATION_CUSTOM_TYPE = "agent_continuation";
+const AGENT_CONTINUE_PROMPT = "";
+const CALL_SUBAGENT_CUSTOM_TYPE = "callsubagent";
+const SUBAGENT_RESULT_CUSTOM_TYPE = "subagent_result";
+export function createAgentRuntime(options) {
+    const runningAgents = new Map();
+    const sessionRepo = options.sessionRepo ?? createSessionRepo();
+    const subagentRepository = options.subagentRepository ?? createInMemorySubagentRepository();
+    const subagents = new Map();
+    return {
+        interrupt: async (agentId) => {
+            const runningAgent = runningAgents.get(agentId);
+            if (!runningAgent) {
+                return false;
+            }
+            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));
+        },
+        start: async (input) => {
+            const env = new NodeExecutionEnv({ cwd: input.workspacePath });
+            const model = await resolveAgentModel(input.provider, input.modelId, options.getCustomModel);
+            if (!model) {
+                throw new Error("Unknown model");
+            }
+            const createHarness = async (harnessOptions) => {
+                let activeMessageId;
+                const pendingVisibleMessages = new Map();
+                const pluginContext = {
+                    agentName: harnessOptions.agentName ?? "main",
+                    env,
+                    isContinue: harnessOptions.isContinue,
+                    session: harnessOptions.session,
+                    prompt: harnessOptions.pluginPrompt,
+                    thinkingLevel: 'medium',
+                    model
+                };
+                const contribution = await pluginRegistry.resolveContributions(pluginContext);
+                const skillDirs = getSkillDirs(input.workspacePath, [...(options.skillDirs || []), ...(contribution.skillDirs || [])]);
+                const { skills: loadedSkills } = await loadSkills(env, skillDirs);
+                const skills = [...loadedSkills, ...(contribution.skills || [])];
+                const tools = [
+                    ...(contribution.tools || []),
+                    createCallSubagentTool({
+                        startSubagent: async ({ agentName, prompt, toolCallId }) => {
+                            const agentId = `agent_${randomUUID()}`;
+                            const createdAt = new Date().toISOString();
+                            const childSession = await sessionRepo.create({
+                                cwd: input.workspacePath
+                            });
+                            const childSessionMetadata = toAgentSessionMetadata(await childSession.getMetadata());
+                            subagentRepository.create({
+                                agentId,
+                                createdAt,
+                                parentAgentId: harnessOptions.agentId,
+                                sessionCreatedAt: childSessionMetadata.createdAt,
+                                sessionId: childSessionMetadata.id,
+                                sessionPath: childSessionMetadata.path,
+                                status: "running",
+                                taskId: input.taskId,
+                                updatedAt: createdAt
+                            });
+                            let started;
+                            try {
+                                started = await startHarness(prompt, {
+                                    agentId,
+                                    agentName,
+                                    isContinue: false,
+                                    parentAgentId: harnessOptions.agentId,
+                                    pluginPrompt: prompt,
+                                    session: childSession
+                                });
+                            }
+                            catch (error) {
+                                subagentRepository.delete(agentId);
+                                throw error;
+                            }
+                            const details = {
+                                agentId: started.agentId,
+                                agentName,
+                                parentAgentId: harnessOptions.agentId,
+                                session: started.session,
+                                taskId: input.taskId
+                            };
+                            subagents.set(started.agentId, {
+                                agentId: started.agentId,
+                                agentName,
+                                agentSession: started.harnessSession,
+                                consumed: false,
+                                lastAssistantText: "",
+                                parentAgentId: harnessOptions.agentId,
+                                ...(harnessOptions.agentName === undefined
+                                    ? {}
+                                    : { parentAgentName: harnessOptions.agentName }),
+                                parentSession: harnessOptions.session,
+                                session: started.session,
+                                status: "running"
+                            });
+                            pendingVisibleMessages.set(toolCallId, {
+                                content: `Subagent "${agentName}" is running.`,
+                                customType: CALL_SUBAGENT_CUSTOM_TYPE,
+                                details
+                            });
+                            return {
+                                content: [
+                                    {
+                                        text: `Subagent "${agentName}" is running. agentId=${started.agentId}`,
+                                        type: "text"
+                                    }
+                                ],
+                                details
+                            };
+                        }
+                    })
+                ];
+                const harness = new AgentHarness({
+                    activeToolNames: tools.map(tool => tool.name),
+                    env,
+                    getApiKeyAndHeaders: async () => {
+                        const apiKey = (await options.getApiKey?.(input.provider, input.modelId)) ??
+                            getEnvApiKey(input.provider);
+                        return apiKey ? { apiKey } : undefined;
+                    },
+                    model: contribution.model || model,
+                    resources: { skills },
+                    session: harnessOptions.session,
+                    systemPrompt: ({ resources }) => [
+                        ...(contribution.systemPrompts || []),
+                        `Workspace: ${input.workspacePath}`,
+                        `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"),
+                    tools
+                });
+                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 (event.message.role === "toolResult") {
+                            const pendingMessage = pendingVisibleMessages.get(event.message.toolCallId);
+                            if (pendingMessage) {
+                                await appendVisibleCustomMessage({
+                                    agentId: harnessOptions.agentId,
+                                    ...pendingMessage,
+                                    eventBus: options.eventBus,
+                                    session: harnessOptions.session
+                                });
+                                pendingVisibleMessages.delete(event.message.toolCallId);
+                            }
+                        }
+                        return;
+                    }
+                    if (event.type === "agent_end") {
+                        options.eventBus.emit({ agentId: harnessOptions.agentId, type: "agent_end" });
+                        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,
+                        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 continueOrEndTask(subagent.parentAgentId, subagent.parentAgentName, subagent.parentSession, undefined);
+                subagents.delete(subagent.agentId);
+            };
+            const continueOrEndTask = async (harnessAgentId, harnessAgentName, harnessSession, contribution) => {
+                const currentSubagent = subagents.get(harnessAgentId);
+                const completedSubagent = getNextCompletedSubagent(subagents, harnessAgentId);
+                if (completedSubagent) {
+                    completedSubagent.consumed = true;
+                    const prompt = formatSubagentResult(completedSubagent);
+                    // 这里有问题，因为子agent结束时父agent可能还在运行，所以不能直接加入消息并再次启动父agent，应该先检查父agent的状态，
+                    // 若父agent未在运行则执行以下逻辑，
+                    // 若父agent正在运行则应该等一个父agent可插入消息的位置（例如下一轮工具执行完成后），插入消息即可，无需重启一个harness
+                    await appendVisibleCustomMessage({
+                        agentId: harnessAgentId,
+                        content: prompt,
+                        customType: SUBAGENT_RESULT_CUSTOM_TYPE,
+                        details: {
+                            agentId: completedSubagent.agentId,
+                            agentName: completedSubagent.agentName,
+                            session: completedSubagent.session
+                        },
+                        eventBus: options.eventBus,
+                        session: harnessSession
+                    });
+                    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;
+                }
+                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/agent-subagents.d.ts

@@ -0,0 +1,32 @@
+import type { ServerPlugin } from "@hold-rein/plugin-server";
+import type { AgentSessionMetadata } from "./agent-types";
+export interface SubagentRun<ParentSession> {
+    agentId: string;
+    agentName: string;
+    agentSession: ParentSession;
+    consumed: boolean;
+    lastAssistantText: string;
+    parentAgentId: string;
+    parentAgentName?: string;
+    parentSession: ParentSession;
+    session: AgentSessionMetadata;
+    status: "running" | "completed";
+}
+export declare function createCallSubagentTool(input: {
+    startSubagent: (input: {
+        agentName: string;
+        prompt: string;
+        toolCallId: string;
+    }) => Promise<{
+        content: {
+            text: string;
+            type: "text";
+        }[];
+        details: unknown;
+    }>;
+}): ServerPlugin.PluginTool;
+export declare function getNextCompletedSubagent<ParentSession>(subagents: Map<string, SubagentRun<ParentSession>>, parentAgentId: string): SubagentRun<ParentSession> | undefined;
+export declare function hasRunningSubagent<ParentSession>(subagents: Map<string, SubagentRun<ParentSession>>, parentAgentId: string): boolean;
+export declare function formatSubagentResult<ParentSession>(subagent: SubagentRun<ParentSession>): string;
+export declare function extractAssistantText(message: unknown): string;
+//# sourceMappingURL=agent-subagents.d.ts.map

package/dist/runtime/api/modules/agents/agent-subagents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-subagents.d.ts","sourceRoot":"","sources":["../../../src/modules/agents/agent-subagents.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAE7D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAE1D,MAAM,WAAW,WAAW,CAAC,aAAa;IACxC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,aAAa,CAAC;IAC5B,QAAQ,EAAE,OAAO,CAAC;IAClB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,aAAa,EAAE,aAAa,CAAC;IAC7B,OAAO,EAAE,oBAAoB,CAAC;IAC9B,MAAM,EAAE,SAAS,GAAG,WAAW,CAAC;CACjC;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE;IAC5C,aAAa,EAAE,CAAC,KAAK,EAAE;QACrB,SAAS,EAAE,MAAM,CAAC;QAClB,MAAM,EAAE,MAAM,CAAC;QACf,UAAU,EAAE,MAAM,CAAC;KACpB,KAAK,OAAO,CAAC;QACZ,OAAO,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE,EAAE,CAAC;QAC1C,OAAO,EAAE,OAAO,CAAC;KAClB,CAAC,CAAC;CACJ,GAAG,YAAY,CAAC,UAAU,CAmC1B;AAED,wBAAgB,wBAAwB,CAAC,aAAa,EACpD,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,aAAa,CAAC,CAAC,EAClD,aAAa,EAAE,MAAM,GACpB,WAAW,CAAC,aAAa,CAAC,GAAG,SAAS,CAOxC;AAED,wBAAgB,kBAAkB,CAAC,aAAa,EAC9C,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,aAAa,CAAC,CAAC,EAClD,aAAa,EAAE,MAAM,GACpB,OAAO,CAKT;AAED,wBAAgB,oBAAoB,CAAC,aAAa,EAChD,QAAQ,EAAE,WAAW,CAAC,aAAa,CAAC,GACnC,MAAM,CAOR;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAmB7D"}

package/dist/runtime/api/modules/agents/agent-subagents.js

@@ -0,0 +1,65 @@
+import { Type } from "@earendil-works/pi-ai";
+export function createCallSubagentTool(input) {
+    return {
+        description: "Start a child agent to work on a delegated task.",
+        executionMode: "parallel",
+        label: "Call Subagent",
+        name: "call_subagent",
+        parameters: Type.Object({
+            agentName: Type.String({
+                description: "Short display name for the child agent."
+            }),
+            prompt: Type.String({
+                description: "Task prompt for the child agent."
+            })
+        }),
+        async execute(toolCallId, rawParams) {
+            const params = rawParams;
+            const agentName = typeof params.agentName === "string" && params.agentName.trim()
+                ? params.agentName.trim()
+                : "subagent";
+            const prompt = typeof params.prompt === "string" && params.prompt.trim()
+                ? params.prompt.trim()
+                : "";
+            if (!prompt) {
+                throw new Error("call_subagent requires a prompt");
+            }
+            return input.startSubagent({ agentName, prompt, toolCallId });
+        }
+    };
+}
+export function getNextCompletedSubagent(subagents, parentAgentId) {
+    return Array.from(subagents.values()).find((subagent) => subagent.parentAgentId === parentAgentId &&
+        subagent.status === "completed" &&
+        !subagent.consumed);
+}
+export function hasRunningSubagent(subagents, parentAgentId) {
+    return Array.from(subagents.values()).some((subagent) => subagent.parentAgentId === parentAgentId && subagent.status === "running");
+}
+export function formatSubagentResult(subagent) {
+    return [
+        `Subagent "${subagent.agentName}" completed.`,
+        `agentId: ${subagent.agentId}`,
+        "",
+        subagent.lastAssistantText || "No assistant response was captured."
+    ].join("\n");
+}
+export function extractAssistantText(message) {
+    if (!message || typeof message !== "object")
+        return "";
+    const record = message;
+    if (record.role !== "assistant" || !Array.isArray(record.content)) {
+        return "";
+    }
+    return record.content
+        .map((block) => {
+        if (!block || typeof block !== "object")
+            return "";
+        const content = block;
+        return content.type === "text" && typeof content.text === "string"
+            ? content.text
+            : "";
+    })
+        .filter(Boolean)
+        .join("\n");
+}

package/dist/runtime/api/modules/agents/agent-task-actions.d.ts

@@ -0,0 +1,9 @@
+import type { TaskTitleResult } from "./agent-types";
+import type { WorkspaceRepository } from "../workspaces/workspace-repository";
+export interface DeleteTaskResult {
+    status: "deleted" | "not_found" | "running";
+    taskId: string;
+}
+export declare function deleteTask(repository: WorkspaceRepository, taskId: string): Promise<DeleteTaskResult>;
+export declare function renameTask(repository: WorkspaceRepository, taskId: string, title: string, updatedAt: string): TaskTitleResult | null;
+//# sourceMappingURL=agent-task-actions.d.ts.map

package/dist/runtime/api/modules/agents/agent-task-actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-task-actions.d.ts","sourceRoot":"","sources":["../../../src/modules/agents/agent-task-actions.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AAE9E,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,SAAS,GAAG,WAAW,GAAG,SAAS,CAAC;IAC5C,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,wBAAsB,UAAU,CAC9B,UAAU,EAAE,mBAAmB,EAC/B,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,gBAAgB,CAAC,CAiB3B;AAED,wBAAgB,UAAU,CACxB,UAAU,EAAE,mBAAmB,EAC/B,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,GAChB,eAAe,GAAG,IAAI,CAIxB"}

package/dist/runtime/api/modules/agents/agent-task-actions.js

@@ -0,0 +1,33 @@
+import { unlink } from "node:fs/promises";
+export async function deleteTask(repository, taskId) {
+    const task = repository.findTaskById(taskId);
+    if (!task) {
+        return { status: "not_found", taskId };
+    }
+    if (task.status === "running") {
+        return { status: "running", taskId };
+    }
+    if (task.sessionPath) {
+        await deleteSessionFile(task.sessionPath);
+    }
+    repository.deleteTaskById(taskId);
+    return { status: "deleted", taskId };
+}
+export function renameTask(repository, taskId, title, updatedAt) {
+    const task = repository.updateTaskTitle(taskId, title, updatedAt);
+    return task ? { id: task.id, title: task.title } : null;
+}
+async function deleteSessionFile(sessionPath) {
+    try {
+        await unlink(sessionPath);
+    }
+    catch (error) {
+        if (isMissingFileError(error)) {
+            return;
+        }
+        throw error;
+    }
+}
+function isMissingFileError(error) {
+    return error instanceof Error && "code" in error && error.code === "ENOENT";
+}

package/dist/runtime/api/modules/agents/agent-task-title-generator.d.ts

@@ -0,0 +1,15 @@
+import { type AgentModelLookup } from "./agent-model-resolver";
+export interface GenerateTaskTitleInput {
+    apiKey?: string;
+    modelId: string;
+    prompt: string;
+    provider: string;
+}
+export interface TaskTitleGenerator {
+    generateTitle: (input: GenerateTaskTitleInput) => Promise<string>;
+}
+export interface CreateTaskTitleGeneratorOptions {
+    getCustomModel?: AgentModelLookup;
+}
+export declare function createDefaultTaskTitleGenerator(options?: CreateTaskTitleGeneratorOptions): TaskTitleGenerator;
+//# sourceMappingURL=agent-task-title-generator.d.ts.map

package/dist/runtime/api/modules/agents/agent-task-title-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-task-title-generator.d.ts","sourceRoot":"","sources":["../../../src/modules/agents/agent-task-title-generator.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,gBAAgB,EACtB,MAAM,wBAAwB,CAAC;AAEhC,MAAM,WAAW,sBAAsB;IACrC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,kBAAkB;IACjC,aAAa,EAAE,CAAC,KAAK,EAAE,sBAAsB,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;CACnE;AAED,MAAM,WAAW,+BAA+B;IAC9C,cAAc,CAAC,EAAE,gBAAgB,CAAC;CACnC;AAED,wBAAgB,+BAA+B,CAC7C,OAAO,GAAE,+BAAoC,GAC5C,kBAAkB,CAqDpB"}

package/dist/runtime/api/modules/agents/agent-task-title-generator.js

@@ -0,0 +1,61 @@
+import { complete } from "@earendil-works/pi-ai";
+import { resolveAgentModel } from "./agent-model-resolver.js";
+export function createDefaultTaskTitleGenerator(options = {}) {
+    return {
+        generateTitle: async (input) => {
+            const model = await resolveAgentModel(input.provider, input.modelId, options.getCustomModel);
+            if (!model) {
+                return createFallbackTitle(input.prompt);
+            }
+            try {
+                const message = await complete(model, {
+                    messages: [
+                        {
+                            content: [
+                                {
+                                    text: [
+                                        "Create a concise task title for this user request.",
+                                        "Return only the title, without quotes or punctuation wrappers.",
+                                        `Request: ${input.prompt}`
+                                    ].join("\n"),
+                                    type: "text"
+                                }
+                            ],
+                            role: "user",
+                            timestamp: Date.now()
+                        }
+                    ],
+                    systemPrompt: "You create short software task titles."
+                }, {
+                    ...(input.apiKey ? { apiKey: input.apiKey } : {}),
+                    maxTokens: 64,
+                    temperature: 0.2
+                });
+                const title = message.content
+                    .filter((content) => content.type === "text")
+                    .map((content) => content.text)
+                    .join("")
+                    .trim();
+                return normalizeGeneratedTitle(title, input.prompt);
+            }
+            catch {
+                return createFallbackTitle(input.prompt);
+            }
+        }
+    };
+}
+function normalizeGeneratedTitle(title, prompt) {
+    const normalizedTitle = title
+        .replace(/^["'`]+|["'`]+$/g, "")
+        .replace(/\s+/g, " ")
+        .trim();
+    return normalizedTitle.length > 0
+        ? normalizedTitle.slice(0, 80)
+        : createFallbackTitle(prompt);
+}
+function createFallbackTitle(prompt) {
+    const normalizedPrompt = prompt.replace(/\s+/g, " ").trim();
+    return normalizedPrompt.length > 0
+        ? normalizedPrompt.slice(0, 80)
+        : "New task";
+}

package/dist/runtime/api/modules/agents/agent-tool-approval.d.ts

@@ -0,0 +1,12 @@
+import type { ServerPlugin } from "@hold-rein/plugin-server";
+import type { AgentApprovalStore } from "./agent-approval-store";
+import type { AgentEventBus } from "./agent-event-bus";
+export declare function runToolBeforeExecute(input: {
+    agentId: string;
+    approvalStore: AgentApprovalStore;
+    event: ServerPlugin.ToolBeforeExecuteOptions["event"];
+    eventBus: AgentEventBus;
+    tool: ServerPlugin.PluginTool;
+    workspacePath: string;
+}): Promise<ServerPlugin.ToolBeforeExecuteResult>;
+//# sourceMappingURL=agent-tool-approval.d.ts.map

package/dist/runtime/api/modules/agents/agent-tool-approval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-tool-approval.d.ts","sourceRoot":"","sources":["../../../src/modules/agents/agent-tool-approval.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAE7D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAGvD,wBAAsB,oBAAoB,CAAC,KAAK,EAAE;IAChD,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,kBAAkB,CAAC;IAClC,KAAK,EAAE,YAAY,CAAC,wBAAwB,CAAC,OAAO,CAAC,CAAC;IACtD,QAAQ,EAAE,aAAa,CAAC;IACxB,IAAI,EAAE,YAAY,CAAC,UAAU,CAAC;IAC9B,aAAa,EAAE,MAAM,CAAC;CACvB,iDAwCA"}

package/dist/runtime/api/modules/agents/agent-tool-approval.js

@@ -0,0 +1,40 @@
+import { randomUUID } from "node:crypto";
+export async function runToolBeforeExecute(input) {
+    if (!input.tool.beforeExecute)
+        return undefined;
+    return input.tool.beforeExecute({
+        workspacePath: input.workspacePath,
+        event: input.event,
+        requestApproval: async (title) => {
+            const approvalId = `approval_${randomUUID()}`;
+            const approvalRequest = {
+                agentId: input.agentId,
+                approvalId,
+                ...(title === undefined ? {} : { title }),
+                tool: {
+                    name: input.tool.name,
+                    input: input.event.input,
+                    ...(input.tool.description === undefined
+                        ? {}
+                        : { description: input.tool.description }),
+                    ...(input.tool.label === undefined ? {} : { label: input.tool.label }),
+                    toolCallId: input.event.toolCallId
+                }
+            };
+            const approval = input.approvalStore.request(approvalRequest);
+            input.eventBus.emit({
+                agentId: input.agentId,
+                payload: approvalRequest,
+                type: "approval_requested"
+            });
+            const decision = await approval;
+            return decision.approved
+                ? undefined
+                : {
+                    block: true,
+                    reason: decision.reason?.trim() ||
+                        `User denied execute tool: ${input.tool.name}`
+                };
+        }
+    });
+}