@n8n/instance-ai 1.10.2 → 1.11.1

package/dist/tools/orchestration/plan-with-agent.tool.js

@@ -1,710 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.__testBuildPlannerBriefingContext = exports.__testGetPriorToolObservations = exports.__testGetRecentMessages = exports.__testFormatMessagesForBriefing = void 0;
-exports.__testClearPlannedTaskGraph = __testClearPlannedTaskGraph;
-exports.__testRehydrateAccumulatorFromGraph = __testRehydrateAccumulatorFromGraph;
-exports.createPlanWithAgentTool = createPlanWithAgentTool;
-const agents_1 = require("@n8n/agents");
-const luxon_1 = require("luxon");
-const zod_1 = require("zod");
-const add_plan_item_tool_1 = require("./add-plan-item.tool");
-const agent_persistence_1 = require("./agent-persistence");
-const blueprint_accumulator_1 = require("./blueprint-accumulator");
-const display_utils_1 = require("./display-utils");
-const plan_agent_prompt_1 = require("./plan-agent-prompt");
-const submit_plan_tool_1 = require("./submit-plan.tool");
-const tracing_utils_1 = require("./tracing-utils");
-const runtime_workspace_1 = require("../../agent/runtime-workspace");
-const max_steps_1 = require("../../constants/max-steps");
-const consume_with_hitl_1 = require("../../stream/consume-with-hitl");
-const tool_registry_1 = require("../../tool-registry");
-const langsmith_tracing_1 = require("../../tracing/langsmith-tracing");
-const stream_helpers_1 = require("../../utils/stream-helpers");
-const credentials_tool_1 = require("../credentials.tool");
-const data_tables_tool_1 = require("../data-tables.tool");
-const ask_user_tool_1 = require("../shared/ask-user.tool");
-const templates_tool_1 = require("../templates.tool");
-const MESSAGE_HISTORY_COUNT = 5;
-const PLANNER_DOMAIN_TOOL_NAMES = [
-    'nodes',
-    credentials_tool_1.CREDENTIALS_TOOL_ID,
-    data_tables_tool_1.DATA_TABLES_TOOL_ID,
-    'workflows',
-    ask_user_tool_1.ASK_USER_TOOL_ID,
-];
-const PLANNER_RESEARCH_TOOL_NAMES = ['research'];
-const RELEVANT_PRIOR_TOOL_NAMES = new Set([
-    ask_user_tool_1.ASK_USER_TOOL_ID,
-    credentials_tool_1.CREDENTIALS_TOOL_ID,
-    data_tables_tool_1.DATA_TABLES_TOOL_ID,
-]);
-function extractTextFromMemoryContent(content) {
-    if (typeof content === 'string')
-        return content;
-    if (Array.isArray(content))
-        return extractTextParts(content);
-    return '';
-}
-function extractTextParts(parts) {
-    return parts
-        .filter((c) => typeof c === 'object' &&
-        c !== null &&
-        'type' in c &&
-        c.type === 'text' &&
-        'text' in c &&
-        typeof c.text === 'string')
-        .map((c) => c.text)
-        .join('\n');
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function readString(value) {
-    return typeof value === 'string' && value.trim().length > 0 ? value : undefined;
-}
-function readRecord(value) {
-    return isRecord(value) ? value : undefined;
-}
-function readArray(value) {
-    return Array.isArray(value) ? value : [];
-}
-function readStringArray(value) {
-    return readArray(value).filter((item) => typeof item === 'string');
-}
-function addUnique(target, seen, value) {
-    if (!value || seen.has(value))
-        return;
-    seen.add(value);
-    target.push(value);
-}
-function summarizeList(values, limit = 10) {
-    const visible = values.slice(0, limit).join(', ');
-    const remaining = values.length - limit;
-    return remaining > 0 ? `${visible}, and ${remaining} more` : visible;
-}
-async function getRecentMessages(context, count) {
-    const messages = [];
-    if (context.memory) {
-        try {
-            const history = await context.memory.getMessages(context.threadId, {
-                limit: count,
-            });
-            for (const m of history) {
-                if (!('role' in m))
-                    continue;
-                const role = m.role;
-                const content = extractTextFromMemoryContent(m.content);
-                if ((role === 'user' || role === 'assistant') && content.length > 0) {
-                    messages.push({ role, content });
-                }
-            }
-        }
-        catch {
-        }
-    }
-    if (shouldAppendCurrentUserMessage(messages, context.currentUserMessage)) {
-        messages.push({ role: 'user', content: context.currentUserMessage });
-    }
-    return messages;
-}
-function shouldAppendCurrentUserMessage(messages, currentUserMessage) {
-    const current = currentUserMessage?.trim();
-    if (!current)
-        return false;
-    const lastUserMessage = [...messages].reverse().find((message) => message.role === 'user');
-    return lastUserMessage?.content.trim() !== current;
-}
-function getPriorToolObservations(context) {
-    const toolCalls = new Map();
-    const pendingResults = new Map();
-    for (const event of getPriorToolEvents(context)) {
-        if (event.type === 'tool-call') {
-            const { toolCallId, toolName, args } = event.payload;
-            if (!RELEVANT_PRIOR_TOOL_NAMES.has(toolName))
-                continue;
-            const pendingResult = pendingResults.get(toolCallId);
-            toolCalls.set(toolCallId, {
-                toolName,
-                args,
-                result: pendingResult,
-                hasResult: pendingResults.has(toolCallId),
-            });
-            continue;
-        }
-        if (event.type === 'tool-result') {
-            const { toolCallId, result } = event.payload;
-            const existing = toolCalls.get(toolCallId);
-            if (existing) {
-                existing.result = result;
-                existing.hasResult = true;
-            }
-            else {
-                pendingResults.set(toolCallId, result);
-            }
-        }
-    }
-    return [...toolCalls.values()]
-        .filter((observation) => observation.hasResult)
-        .map(({ toolName, args, result }) => ({ toolName, args, result }));
-}
-function getPriorToolEvents(context) {
-    if (context.messageGroupId) {
-        const runIds = getMessageGroupRunIds(context);
-        if (runIds.length > 0) {
-            try {
-                return context.eventBus.getEventsForRuns(context.threadId, runIds);
-            }
-            catch {
-            }
-        }
-    }
-    try {
-        return context.eventBus.getEventsForRun(context.threadId, context.runId);
-    }
-    catch {
-        return [];
-    }
-}
-function getMessageGroupRunIds(context) {
-    const messageGroupId = context.messageGroupId;
-    if (!messageGroupId)
-        return [];
-    const runIds = new Set();
-    try {
-        for (const { event } of context.eventBus.getEventsAfter(context.threadId, 0)) {
-            if (event.type === 'run-start' && event.payload.messageGroupId === messageGroupId) {
-                runIds.add(event.runId);
-            }
-        }
-    }
-    catch {
-        return [context.runId];
-    }
-    runIds.add(context.runId);
-    return [...runIds];
-}
-function buildPlannerBriefingContext(observations) {
-    const collectedAnswers = [];
-    const discoveredResources = [];
-    const seenAnswers = new Set();
-    const seenResources = new Set();
-    const credentialsById = buildCredentialLookup(observations);
-    for (const observation of observations) {
-        if (observation.toolName === ask_user_tool_1.ASK_USER_TOOL_ID) {
-            for (const answer of extractAskUserAnswerLines(observation)) {
-                addUnique(collectedAnswers, seenAnswers, answer);
-            }
-            continue;
-        }
-        if (observation.toolName === credentials_tool_1.CREDENTIALS_TOOL_ID) {
-            const action = readString(observation.args.action);
-            if (action === 'list') {
-                addUnique(discoveredResources, seenResources, summarizeCredentials(observation.result));
-            }
-            if (action === 'setup') {
-                for (const selection of extractCredentialSelectionLines(observation, credentialsById)) {
-                    addUnique(collectedAnswers, seenAnswers, selection);
-                }
-            }
-            continue;
-        }
-        if (observation.toolName === data_tables_tool_1.DATA_TABLES_TOOL_ID &&
-            readString(observation.args.action) === 'list') {
-            addUnique(discoveredResources, seenResources, summarizeDataTables(observation.result));
-        }
-    }
-    return { collectedAnswers, discoveredResources };
-}
-function buildCredentialLookup(observations) {
-    const credentialsById = new Map();
-    for (const observation of observations) {
-        if (observation.toolName !== credentials_tool_1.CREDENTIALS_TOOL_ID)
-            continue;
-        for (const credential of extractCredentials(observation.result)) {
-            if (credential.id)
-                credentialsById.set(credential.id, credential);
-        }
-    }
-    return credentialsById;
-}
-function extractAskUserAnswerLines(observation) {
-    const result = readRecord(observation.result);
-    if (!result || result.answered === false)
-        return [];
-    const questionsById = extractQuestionTextById(observation.args);
-    const answers = readArray(result.answers);
-    const lines = [];
-    for (const answerValue of answers) {
-        const answer = readRecord(answerValue);
-        if (!answer || answer.skipped === true)
-            continue;
-        const questionId = readString(answer.questionId);
-        const question = readString(answer.question) ?? (questionId ? questionsById.get(questionId) : undefined);
-        const selectedOptions = readStringArray(answer.selectedOptions);
-        const customText = readString(answer.customText);
-        const values = [...selectedOptions, ...(customText ? [customText] : [])];
-        if (!question || values.length === 0)
-            continue;
-        lines.push(`${question}: ${values.join(', ')}`);
-    }
-    return lines;
-}
-function extractQuestionTextById(args) {
-    const questionsById = new Map();
-    for (const questionValue of readArray(args.questions)) {
-        const question = readRecord(questionValue);
-        const id = readString(question?.id);
-        const text = readString(question?.question);
-        if (id && text)
-            questionsById.set(id, text);
-    }
-    return questionsById;
-}
-function extractCredentialSelectionLines(observation, credentialsById) {
-    const result = readRecord(observation.result);
-    const credentials = readRecord(result?.credentials);
-    if (!credentials)
-        return [];
-    const lines = [];
-    for (const [credentialType, credentialIdValue] of Object.entries(credentials)) {
-        const credentialId = readString(credentialIdValue);
-        if (!credentialId)
-            continue;
-        const credential = credentialsById.get(credentialId);
-        const label = credential
-            ? `${credential.name} (${credential.type})`
-            : `credential ID ${credentialId}`;
-        lines.push(`Credential selected for ${credentialType}: ${label}`);
-    }
-    return lines;
-}
-function summarizeCredentials(result) {
-    const credentials = extractCredentials(result);
-    if (credentials.length === 0)
-        return undefined;
-    return `Credentials available: ${summarizeList(credentials.map((credential) => `${credential.name} (${credential.type})`))}`;
-}
-function extractCredentials(result) {
-    const record = readRecord(result);
-    return readArray(record?.credentials)
-        .map(readCredentialBrief)
-        .filter((credential) => credential !== undefined);
-}
-function readCredentialBrief(value) {
-    const record = readRecord(value);
-    const name = readString(record?.name);
-    const type = readString(record?.type);
-    if (!name || !type)
-        return undefined;
-    const id = readString(record?.id);
-    return {
-        name,
-        type,
-        ...(id ? { id } : {}),
-    };
-}
-function summarizeDataTables(result) {
-    const tables = extractDataTables(result);
-    if (tables.length === 0)
-        return undefined;
-    return `Data tables available: ${summarizeList(tables.map((table) => table.name))}`;
-}
-function extractDataTables(result) {
-    const record = readRecord(result);
-    return readArray(record?.tables)
-        .map(readDataTableBrief)
-        .filter((table) => table !== undefined);
-}
-function readDataTableBrief(value) {
-    const record = readRecord(value);
-    const name = readString(record?.name);
-    if (!name)
-        return undefined;
-    const id = readString(record?.id);
-    return {
-        name,
-        ...(id ? { id } : {}),
-    };
-}
-function formatMessagesForBriefing(messages, guidance, timeZone, briefingContext) {
-    const parts = [];
-    const now = timeZone ? luxon_1.DateTime.now().setZone(timeZone) : luxon_1.DateTime.now();
-    const isoNow = now.toISO({ includeOffset: true }) ?? new Date().toISOString();
-    parts.push(`<current-datetime>${isoNow}</current-datetime>`);
-    if (timeZone) {
-        parts.push(`<user-timezone>${timeZone}</user-timezone>`);
-    }
-    if (messages.length > 0) {
-        parts.push('## Recent conversation');
-        for (const m of messages) {
-            const label = m.role === 'user' ? 'User' : 'Assistant';
-            const content = m.content.length > 2000 ? m.content.slice(0, 2000) + '...' : m.content;
-            parts.push(`**${label}:** ${content}`);
-        }
-    }
-    if (briefingContext?.collectedAnswers.length) {
-        parts.push('## Already-collected answers');
-        for (const answer of briefingContext.collectedAnswers) {
-            parts.push(`- ${answer}`);
-        }
-    }
-    if (briefingContext?.discoveredResources.length) {
-        parts.push('## Already-discovered resources');
-        for (const resource of briefingContext.discoveredResources) {
-            parts.push(`- ${resource}`);
-        }
-    }
-    if (guidance) {
-        parts.push(`\n## Orchestrator guidance\n${guidance}`);
-    }
-    parts.push('\nDesign the solution blueprint based on the conversation above.');
-    return parts.join('\n\n');
-}
-exports.__testFormatMessagesForBriefing = formatMessagesForBriefing;
-exports.__testGetRecentMessages = getRecentMessages;
-exports.__testGetPriorToolObservations = getPriorToolObservations;
-exports.__testBuildPlannerBriefingContext = buildPlannerBriefingContext;
-function publishClearingEvent(context) {
-    context.eventBus.publish(context.threadId, {
-        type: 'tasks-update',
-        runId: context.runId,
-        agentId: context.orchestratorAgentId,
-        payload: { tasks: { tasks: [] }, planItems: [] },
-    });
-}
-async function clearDraftChecklist(context) {
-    try {
-        await context.taskStorage.save(context.threadId, { tasks: [] });
-    }
-    catch {
-    }
-}
-async function __testClearPlannedTaskGraph(context) {
-    return await clearPlannedTaskGraph(context);
-}
-async function clearPlannedTaskGraph(context) {
-    if (!context.plannedTaskService)
-        return;
-    try {
-        const graph = await context.plannedTaskService.getGraph(context.threadId);
-        if (!graph)
-            return;
-        if (graph.planRunId !== context.runId)
-            return;
-        if (graph.status !== 'awaiting_approval')
-            return;
-        await context.plannedTaskService.clear(context.threadId);
-    }
-    catch {
-    }
-}
-async function __testRehydrateAccumulatorFromGraph(context, accumulator) {
-    return await rehydrateAccumulatorFromGraph(context, accumulator);
-}
-async function rehydrateAccumulatorFromGraph(context, accumulator) {
-    if (!context.plannedTaskService)
-        return;
-    try {
-        const graph = await context.plannedTaskService.getGraph(context.threadId);
-        if (graph?.status === 'awaiting_approval' && graph.tasks.length > 0) {
-            accumulator.loadFromTasks(graph.tasks);
-        }
-    }
-    catch {
-    }
-}
-const planToolSuspendSchema = zod_1.z
-    .object({
-    requestId: zod_1.z.string(),
-    message: zod_1.z.string(),
-    severity: zod_1.z.string(),
-    inputType: zod_1.z.string().optional(),
-})
-    .passthrough();
-const planToolResumeSchema = zod_1.z.record(zod_1.z.unknown());
-function createPlanWithAgentTool(context) {
-    return new agents_1.Tool('plan')
-        .description('Design and execute a multi-step plan. Spawns a planner agent that reads ' +
-        'the conversation history, discovers available credentials, data tables, ' +
-        'and best practices, designs the architecture, and shows it to the user ' +
-        'for approval. Use when the request requires 2 or more tasks with ' +
-        'dependencies. When this tool returns, the plan is already approved ' +
-        'and tasks are dispatched — just acknowledge briefly and end your turn.')
-        .input(zod_1.z.object({
-        guidance: zod_1.z
-            .string()
-            .optional()
-            .describe('Optional steering note for the planner — use ONLY when the conversation ' +
-            'history alone is ambiguous about what to build. The planner reads the ' +
-            'last 5 messages directly, so do NOT rewrite the user request here.'),
-    }))
-        .output(zod_1.z.object({
-        result: zod_1.z.string(),
-    }))
-        .suspend(planToolSuspendSchema)
-        .resume(planToolResumeSchema)
-        .handler(async (input, ctx) => {
-        const resumeData = ctx.resumeData;
-        const isResume = resumeData !== undefined && resumeData !== null;
-        if (!isResume && context.plannedTaskService && context.messageGroupId) {
-            const existing = await context.plannedTaskService.getGraph(context.threadId);
-            if (existing?.status === 'cancelled' &&
-                existing.messageGroupId === context.messageGroupId) {
-                context.logger.info('plan tool blocked: user denied a plan earlier in this turn', {
-                    threadId: context.threadId,
-                    messageGroupId: context.messageGroupId,
-                });
-                return {
-                    result: 'The user denied a plan earlier in this turn. Do not invoke the plan tool again — acknowledge briefly and wait for the next user message.',
-                };
-            }
-        }
-        const plannerTools = (0, tool_registry_1.createToolRegistry)();
-        for (const name of PLANNER_DOMAIN_TOOL_NAMES) {
-            const tool = context.domainTools.get(name);
-            if (tool)
-                plannerTools.set(name, tool);
-        }
-        for (const name of PLANNER_RESEARCH_TOOL_NAMES) {
-            const tool = context.domainTools.get(name);
-            if (tool)
-                plannerTools.set(name, tool);
-        }
-        plannerTools.set('templates', (0, templates_tool_1.createTemplatesTool)());
-        const accumulator = new blueprint_accumulator_1.BlueprintAccumulator();
-        plannerTools.set('add-plan-item', (0, add_plan_item_tool_1.createAddPlanItemTool)(accumulator, context));
-        plannerTools.set('remove-plan-item', (0, add_plan_item_tool_1.createRemovePlanItemTool)(accumulator, context));
-        plannerTools.set('submit-plan', (0, submit_plan_tool_1.createSubmitPlanTool)(accumulator, context));
-        const subAgentId = `agent-planner-${context.runId}`;
-        const tracedPlannerTools = (0, tracing_utils_1.traceSubAgentTools)(context, plannerTools, 'planner');
-        const subAgent = new agents_1.Agent('Workflow Planner Agent')
-            .model(context.modelId)
-            .instructions(plan_agent_prompt_1.PLANNER_AGENT_PROMPT, {
-            providerOptions: {
-                anthropic: { cacheControl: { type: 'ephemeral' } },
-            },
-        })
-            .tool((0, tool_registry_1.toolRegistryValues)(tracedPlannerTools))
-            .checkpoint(context.checkpointStore ?? 'memory');
-        (0, runtime_workspace_1.attachRuntimeWorkspaceCapabilities)(subAgent, {
-            runtimeSkills: context.runtimeSkills,
-        });
-        const telemetry = context.tracing?.getTelemetry?.({
-            agentRole: 'planner',
-            functionId: 'instance-ai.subagent.planner',
-            executionMode: 'background',
-            metadata: { agent_id: subAgentId },
-        });
-        if (telemetry) {
-            subAgent.telemetry(telemetry);
-        }
-        let traceRun;
-        try {
-            let consumeResult;
-            if (isResume) {
-                const resumeInfo = await context.findSubAgentResumeInfo?.('planner');
-                if (!resumeInfo) {
-                    return {
-                        result: 'The planning step could not be resumed because its state was lost. Please send a new message to continue.',
-                    };
-                }
-                await rehydrateAccumulatorFromGraph(context, accumulator);
-                traceRun = await (0, tracing_utils_1.startSubAgentTrace)(context, {
-                    agentId: subAgentId,
-                    role: 'planner',
-                    kind: 'planner',
-                    inputs: { resumed: true },
-                });
-                (0, langsmith_tracing_1.mergeTraceRunInputs)(traceRun, (0, langsmith_tracing_1.buildAgentTraceInputs)({
-                    systemPrompt: plan_agent_prompt_1.PLANNER_AGENT_PROMPT,
-                    tools: tracedPlannerTools,
-                    modelId: context.modelId,
-                }));
-                consumeResult = await (0, tracing_utils_1.withTraceRun)(context, traceRun, async () => {
-                    const resumed = await (0, stream_helpers_1.resumeAgentStream)(subAgent, resumeData, {
-                        runId: resumeInfo.runId,
-                        toolCallId: resumeInfo.toolCallId,
-                        persistence: resumeInfo.persistence,
-                        maxIterations: max_steps_1.MAX_STEPS.PLANNER,
-                    });
-                    return await (0, consume_with_hitl_1.consumeStreamCascading)({
-                        agent: subAgent,
-                        stream: resumed,
-                        runId: context.runId,
-                        agentId: subAgentId,
-                        eventBus: context.eventBus,
-                        logger: context.logger,
-                        threadId: context.threadId,
-                        abortSignal: context.abortSignal,
-                    });
-                });
-            }
-            else {
-                if (context.persistInFlightUserMessage) {
-                    await context.persistInFlightUserMessage();
-                }
-                const messages = await getRecentMessages(context, MESSAGE_HISTORY_COUNT);
-                const briefingContext = buildPlannerBriefingContext(getPriorToolObservations(context));
-                const briefing = formatMessagesForBriefing(messages, input.guidance, context.timeZone, briefingContext);
-                const subtitle = input.guidance ?? messages.find((m) => m.role === 'user')?.content ?? 'Planning...';
-                context.eventBus.publish(context.threadId, {
-                    type: 'agent-spawned',
-                    runId: context.runId,
-                    agentId: subAgentId,
-                    payload: {
-                        parentId: context.orchestratorAgentId,
-                        role: 'planner',
-                        tools: (0, tool_registry_1.toolRegistryKeys)(plannerTools),
-                        kind: 'planner',
-                        title: 'Planning',
-                        subtitle: (0, display_utils_1.truncateLabel)(subtitle),
-                        goal: briefing,
-                    },
-                });
-                traceRun = await (0, tracing_utils_1.startSubAgentTrace)(context, {
-                    agentId: subAgentId,
-                    role: 'planner',
-                    kind: 'planner',
-                    inputs: {
-                        guidance: input.guidance,
-                        messageCount: messages.length,
-                    },
-                });
-                (0, langsmith_tracing_1.mergeTraceRunInputs)(traceRun, (0, langsmith_tracing_1.buildAgentTraceInputs)({
-                    systemPrompt: plan_agent_prompt_1.PLANNER_AGENT_PROMPT,
-                    tools: tracedPlannerTools,
-                    modelId: context.modelId,
-                }));
-                consumeResult = await (0, tracing_utils_1.withTraceRun)(context, traceRun, async () => {
-                    const persistence = await (0, agent_persistence_1.createSubAgentPersistence)(context, {
-                        agentKind: 'planner',
-                    });
-                    const stream = await subAgent.stream(briefing, {
-                        maxIterations: max_steps_1.MAX_STEPS.PLANNER,
-                        abortSignal: context.abortSignal,
-                        persistence,
-                        providerOptions: {
-                            anthropic: { cacheControl: { type: 'ephemeral' } },
-                        },
-                    });
-                    return await (0, consume_with_hitl_1.consumeStreamCascading)({
-                        agent: subAgent,
-                        stream,
-                        runId: context.runId,
-                        agentId: subAgentId,
-                        eventBus: context.eventBus,
-                        logger: context.logger,
-                        threadId: context.threadId,
-                        abortSignal: context.abortSignal,
-                    });
-                });
-            }
-            if (consumeResult.status === 'suspended') {
-                const parsed = planToolSuspendSchema.safeParse(consumeResult.suspension.suspendPayload);
-                if (!parsed.success) {
-                    context.logger.warn('Planner emitted a suspension payload missing required fields', {
-                        threadId: context.threadId,
-                        runId: context.runId,
-                        toolName: consumeResult.suspension.toolName,
-                        zodIssues: parsed.error.issues,
-                    });
-                    publishClearingEvent(context);
-                    await clearDraftChecklist(context);
-                    await clearPlannedTaskGraph(context);
-                    return {
-                        result: 'Planner requested user input but the payload was malformed. Please try again.',
-                    };
-                }
-                return await ctx.suspend(parsed.data);
-            }
-            const resultText = consumeResult.status === 'completed' ? await consumeResult.text : '';
-            if (traceRun) {
-                await (0, tracing_utils_1.finishTraceRun)(context, traceRun, {
-                    outputs: {
-                        result: resultText,
-                        agentId: subAgentId,
-                        role: 'planner',
-                        hasItems: !accumulator.isEmpty(),
-                        itemCount: accumulator.getTaskItemsForEvent().length,
-                    },
-                });
-            }
-            context.eventBus.publish(context.threadId, {
-                type: 'agent-completed',
-                runId: context.runId,
-                agentId: subAgentId,
-                payload: {
-                    role: 'planner',
-                    result: resultText,
-                },
-            });
-            if (accumulator.isApproved()) {
-                if (context.plannedTaskService) {
-                    await context.plannedTaskService.approvePlan(context.threadId);
-                }
-                if (context.schedulePlannedTasks) {
-                    await context.schedulePlannedTasks();
-                }
-                const persistedCount = await getPersistedTaskCount(context);
-                const taskCount = persistedCount ?? accumulator.getTaskList().length;
-                return {
-                    result: `Plan approved and ${taskCount} task${taskCount === 1 ? '' : 's'} dispatched.`,
-                };
-            }
-            if (accumulator.isDenied()) {
-                publishClearingEvent(context);
-                await clearDraftChecklist(context);
-                return { result: 'Plan denied by user. No tasks were dispatched.' };
-            }
-            publishClearingEvent(context);
-            await clearDraftChecklist(context);
-            await clearPlannedTaskGraph(context);
-            if (!accumulator.isEmpty()) {
-                return {
-                    result: `Planner added ${accumulator.getTaskList().length} items but did not submit the plan for approval. The plan was not executed.`,
-                };
-            }
-            return {
-                result: `Planner finished without producing a plan. Agent output: ${resultText}`,
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            if (traceRun) {
-                await (0, tracing_utils_1.failTraceRun)(context, traceRun, error, {
-                    agent_id: subAgentId,
-                    agent_role: 'planner',
-                });
-            }
-            context.eventBus.publish(context.threadId, {
-                type: 'agent-completed',
-                runId: context.runId,
-                agentId: subAgentId,
-                payload: {
-                    role: 'planner',
-                    result: '',
-                    error: errorMessage,
-                },
-            });
-            if (!accumulator.isApproved()) {
-                publishClearingEvent(context);
-                await clearDraftChecklist(context);
-                await clearPlannedTaskGraph(context);
-            }
-            return { result: `Planner error: ${errorMessage}` };
-        }
-    })
-        .build();
-}
-async function getPersistedTaskCount(context) {
-    if (!context.plannedTaskService)
-        return undefined;
-    try {
-        const graph = await context.plannedTaskService.getGraph(context.threadId);
-        return graph?.tasks?.length;
-    }
-    catch {
-        return undefined;
-    }
-}
-//# sourceMappingURL=plan-with-agent.tool.js.map