@n8n/agents 0.26.3 → 0.27.1

package/dist/runtime/tools/delegate-sub-agent-tool.js

@@ -1,133 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SUB_AGENT_TASK_DIFFICULTIES = exports.INLINE_DELEGATE_SUB_AGENT_TOOL_METADATA_KEY = exports.DELEGATED_CHILD_SUSPEND_UNSUPPORTED_MESSAGE = exports.INLINE_SUB_AGENT_ID = exports.DELEGATE_SUB_AGENT_TOOL_NAME = void 0;
-exports.parseDelegateSubAgentContinuation = parseDelegateSubAgentContinuation;
+exports.parseDelegateSubAgentContinuation = exports.SUB_AGENT_TASK_DIFFICULTIES = exports.INLINE_DELEGATE_SUB_AGENT_TOOL_METADATA_KEY = exports.DELEGATED_CHILD_SUSPEND_UNSUPPORTED_MESSAGE = exports.INLINE_SUB_AGENT_ID = exports.DELEGATE_SUB_AGENT_TOOL_NAME = exports.renderDelegateSubAgentPrompt = exports.generateResultToDelegateSubAgentOutput = exports.failedDelegatedChildSuspendOutput = void 0;
 exports.createDelegateSubAgentTool = createDelegateSubAgentTool;
 exports.getInlineDelegateSubAgentToolOptions = getInlineDelegateSubAgentToolOptions;
 exports.isDelegateSubAgentTool = isDelegateSubAgentTool;
-exports.renderDelegateSubAgentPrompt = renderDelegateSubAgentPrompt;
-exports.failedDelegatedChildSuspendOutput = failedDelegatedChildSuspendOutput;
-exports.generateResultToDelegateSubAgentOutput = generateResultToDelegateSubAgentOutput;
-const is_record_1 = require("@n8n/utils/is-record");
-const zod_1 = require("zod");
+const delegate_sub_agent_runner_1 = require("./delegate-sub-agent-runner");
 const sdk_owned_tool_1 = require("./sdk-owned-tool");
 const sub_agent_task_path_1 = require("./sub-agent-task-path");
-const abort_1 = require("../../sdk/abort");
-const message_1 = require("../../sdk/message");
 const tool_1 = require("../../sdk/tool");
-const execution_counter_1 = require("../loop/execution-counter");
-exports.DELEGATE_SUB_AGENT_TOOL_NAME = 'delegate_subagent';
-exports.INLINE_SUB_AGENT_ID = 'inline';
-exports.DELEGATED_CHILD_SUSPEND_UNSUPPORTED_MESSAGE = 'agents.chat.delegate.childSuspendUnsupported';
-exports.INLINE_DELEGATE_SUB_AGENT_TOOL_METADATA_KEY = 'inlineDelegateSubAgent';
-exports.SUB_AGENT_TASK_DIFFICULTIES = ['low', 'medium', 'high'];
-const SubAgentTaskDifficultySchema = zod_1.z.enum(exports.SUB_AGENT_TASK_DIFFICULTIES);
-const jsonValueSchema = zod_1.z.lazy(() => zod_1.z.union([
-    zod_1.z.string(),
-    zod_1.z.number(),
-    zod_1.z.boolean(),
-    zod_1.z.null(),
-    zod_1.z.array(jsonValueSchema),
-    zod_1.z.record(zod_1.z.string(), jsonValueSchema),
-]));
-const delegateSubAgentInputSchema = zod_1.z.object({
-    subAgentId: zod_1.z
-        .string()
-        .min(1)
-        .describe('Required. Use "inline" for a one-off inline sub-agent. Use an exact configured sub-agent ID only when one is listed and fits the task.'),
-    taskName: zod_1.z
-        .string()
-        .min(1)
-        .describe('Short human-readable name for this delegated task, e.g. "research_api".'),
-    goal: zod_1.z.string().min(1).describe('The concrete goal the sub-agent should accomplish.'),
-    context: zod_1.z
-        .string()
-        .optional()
-        .describe('All details the child needs, since it sees nothing else: constraints, paths, data, prior decisions, acceptance criteria, and what you have already tried or ruled out.'),
-    expectedOutput: zod_1.z.string().optional().describe('The expected shape or contents of the answer.'),
-    difficulty: SubAgentTaskDifficultySchema.optional().describe('Optional difficulty estimate for this delegated task. Use low for simple bounded work, medium for moderate analysis or implementation, and high for complex research, architecture, or multi-step reasoning.'),
-});
-const delegateSubAgentOutputSchema = zod_1.z.object({
-    status: zod_1.z.enum(['completed', 'failed', 'suspended', 'cancelled']),
-    taskPath: zod_1.z.string().optional(),
-    runId: zod_1.z.string().optional(),
-    threadId: zod_1.z.string().optional(),
-    model: zod_1.z.string().optional(),
-    answer: zod_1.z.string(),
-    structuredOutput: zod_1.z.unknown().optional(),
-    usage: zod_1.z
-        .object({
-        promptTokens: zod_1.z.number().optional(),
-        completionTokens: zod_1.z.number().optional(),
-        totalTokens: zod_1.z.number().optional(),
-        cost: zod_1.z.number().optional(),
-    })
-        .optional(),
-    finishReason: zod_1.z.string().optional(),
-    error: zod_1.z.string().optional(),
-    resumeContext: jsonValueSchema.optional(),
-    pendingSuspend: zod_1.z
-        .array(zod_1.z.object({
-        runId: zod_1.z.string(),
-        toolCallId: zod_1.z.string(),
-        toolName: zod_1.z.string(),
-        input: zod_1.z.unknown(),
-        suspendPayload: zod_1.z.unknown(),
-        resumeSchema: zod_1.z.unknown().optional(),
-    }))
-        .optional(),
-});
-const delegateSubAgentContinuationSchema = zod_1.z.object({
-    runId: zod_1.z.string(),
-    toolCallId: zod_1.z.string(),
-    taskPath: zod_1.z.string(),
-    subAgentId: zod_1.z.string(),
-    childCount: zod_1.z.number().int().nonnegative(),
-    threadId: zod_1.z.string().optional(),
-    resumeContext: jsonValueSchema.optional(),
-});
-const delegateSubAgentSuspendSchema = zod_1.z.unknown();
-const delegateSubAgentResumeSchema = zod_1.z.unknown();
-function parseDelegateSubAgentContinuation(value) {
-    const parsed = delegateSubAgentContinuationSchema.safeParse(value);
-    return parsed.success ? parsed.data : undefined;
-}
-const SUB_AGENT_FORWARD_CHAR_BUDGET = 20_000;
-const FORWARDED_CHILD_CHUNK_TYPES = new Set([
-    'text-delta',
-    'reasoning-start',
-    'reasoning-delta',
-    'reasoning-end',
-    'tool-input-start',
-    'tool-execution-start',
-    'tool-execution-end',
-]);
-function isForwardedChildChunk(chunk) {
-    return FORWARDED_CHILD_CHUNK_TYPES.has(chunk.type);
-}
-function createEmitChunkHelper(ctx, request) {
-    let forwardedChars = 0;
-    return (chunk) => {
-        if (request.parentToolCallId === undefined)
-            return;
-        if (!isForwardedChildChunk(chunk))
-            return;
-        let forwarded = chunk;
-        if (chunk.type === 'text-delta' || chunk.type === 'reasoning-delta') {
-            const remaining = SUB_AGENT_FORWARD_CHAR_BUDGET - forwardedChars;
-            if (remaining <= 0)
-                return;
-            const delta = chunk.delta.slice(0, remaining);
-            forwardedChars += delta.length;
-            forwarded = { ...chunk, delta };
-        }
-        ctx.emitEvent?.({
-            type: "subagent_chunk",
-            ...subAgentLifecycleBase(request),
-            chunk: forwarded,
-        });
-    };
-}
+const delegation_1 = require("../../types/runtime/delegation");
+var delegate_sub_agent_runner_2 = require("./delegate-sub-agent-runner");
+Object.defineProperty(exports, "failedDelegatedChildSuspendOutput", { enumerable: true, get: function () { return delegate_sub_agent_runner_2.failedDelegatedChildSuspendOutput; } });
+Object.defineProperty(exports, "generateResultToDelegateSubAgentOutput", { enumerable: true, get: function () { return delegate_sub_agent_runner_2.generateResultToDelegateSubAgentOutput; } });
+Object.defineProperty(exports, "renderDelegateSubAgentPrompt", { enumerable: true, get: function () { return delegate_sub_agent_runner_2.renderDelegateSubAgentPrompt; } });
+var delegation_2 = require("../../types/runtime/delegation");
+Object.defineProperty(exports, "DELEGATE_SUB_AGENT_TOOL_NAME", { enumerable: true, get: function () { return delegation_2.DELEGATE_SUB_AGENT_TOOL_NAME; } });
+Object.defineProperty(exports, "INLINE_SUB_AGENT_ID", { enumerable: true, get: function () { return delegation_2.INLINE_SUB_AGENT_ID; } });
+Object.defineProperty(exports, "DELEGATED_CHILD_SUSPEND_UNSUPPORTED_MESSAGE", { enumerable: true, get: function () { return delegation_2.DELEGATED_CHILD_SUSPEND_UNSUPPORTED_MESSAGE; } });
+Object.defineProperty(exports, "INLINE_DELEGATE_SUB_AGENT_TOOL_METADATA_KEY", { enumerable: true, get: function () { return delegation_2.INLINE_DELEGATE_SUB_AGENT_TOOL_METADATA_KEY; } });
+Object.defineProperty(exports, "SUB_AGENT_TASK_DIFFICULTIES", { enumerable: true, get: function () { return delegation_2.SUB_AGENT_TASK_DIFFICULTIES; } });
+Object.defineProperty(exports, "parseDelegateSubAgentContinuation", { enumerable: true, get: function () { return delegation_2.parseDelegateSubAgentContinuation; } });
 function resolveDelegateSubAgentPolicy(policy, toolName) {
     const resolvedPolicy = {
         ...policy,
@@ -145,7 +37,7 @@ function resolveDelegateSubAgentPolicy(policy, toolName) {
 const DELEGATE_SUB_AGENT_TOOL_NAME_PATTERN = /^[a-zA-Z][a-zA-Z0-9_-]{0,63}$/;
 function resolveDelegateSubAgentToolName(name) {
     if (name === undefined)
-        return exports.DELEGATE_SUB_AGENT_TOOL_NAME;
+        return delegation_1.DELEGATE_SUB_AGENT_TOOL_NAME;
     if (!DELEGATE_SUB_AGENT_TOOL_NAME_PATTERN.test(name)) {
         throw new Error(`Invalid delegate sub-agent tool name "${name}": must start with a letter and contain only letters, digits, underscores, and hyphens (max 64 characters)`);
     }
@@ -178,6 +70,18 @@ function resolveDelegateSubAgentSystemInstruction(options, toolName, inlineProvi
 function createDelegateSubAgentTool(options = {}) {
     const childPathIndexes = new Map();
     const toolName = resolveDelegateSubAgentToolName(options.name);
+    const resolvedOptions = resolveDelegateSubAgentOptions(options, toolName);
+    const tool = buildDelegateSubAgentTool(toolName, resolvedOptions, childPathIndexes);
+    return (0, sdk_owned_tool_1.withSdkOwnedBuiltInMetadata)({
+        ...tool,
+        ...createDelegateCancellationHandler(resolvedOptions, childPathIndexes),
+        metadata: {
+            ...tool.metadata,
+            [delegation_1.INLINE_DELEGATE_SUB_AGENT_TOOL_METADATA_KEY]: buildDelegateToolMetadata(resolvedOptions),
+        },
+    });
+}
+function resolveDelegateSubAgentOptions(options, toolName) {
     const resolvedOptions = {
         ...options,
         policy: resolveDelegateSubAgentPolicy(options.policy, toolName),
@@ -186,85 +90,87 @@ function createDelegateSubAgentTool(options = {}) {
         (resolvedOptions.cancelSubAgent === undefined)) {
         throw new Error(`${toolName} requires resumeSubAgent and cancelSubAgent to be configured together`);
     }
+    return resolvedOptions;
+}
+function buildDelegateSubAgentTool(toolName, resolvedOptions, childPathIndexes) {
     const inlineProviderToolInstruction = resolvedOptions.resolveInlineSubAgentProviderTools
         ? "Provider-defined tools are loaded for the inline child's selected model provider."
         : 'Inline children do not inherit provider-defined tools.';
     const toolBuilder = new tool_1.Tool(toolName)
         .description(resolveDelegateSubAgentDescription(resolvedOptions))
         .systemInstruction(resolveDelegateSubAgentSystemInstruction(resolvedOptions, toolName, inlineProviderToolInstruction))
-        .input(delegateSubAgentInputSchema)
-        .output(delegateSubAgentOutputSchema);
-    const handler = async (input, ctx) => await handleDelegateSubAgent(input, ctx, resolvedOptions, childPathIndexes);
+        .input(delegation_1.delegateSubAgentInputSchema)
+        .output(delegation_1.delegateSubAgentOutputSchema);
+    const handler = async (input, ctx) => await (0, delegate_sub_agent_runner_1.handleDelegateSubAgent)(input, ctx, resolvedOptions, childPathIndexes);
     const toModelOutput = (output) => resolvedOptions.toModelOutput ? resolvedOptions.toModelOutput(output) : output;
-    const tool = resolvedOptions.resumeSubAgent
-        ? toolBuilder
-            .suspend(delegateSubAgentSuspendSchema)
-            .resume(delegateSubAgentResumeSchema)
+    if (resolvedOptions.resumeSubAgent) {
+        return toolBuilder
+            .suspend(delegation_1.delegateSubAgentSuspendSchema)
+            .resume(delegation_1.delegateSubAgentResumeSchema)
             .handler(handler)
             .toModelOutput(toModelOutput)
-            .build()
-        : toolBuilder.handler(handler).toModelOutput(toModelOutput).build();
-    return (0, sdk_owned_tool_1.withSdkOwnedBuiltInMetadata)({
-        ...tool,
-        ...(resolvedOptions.cancelSubAgent !== undefined
+            .build();
+    }
+    return toolBuilder.handler(handler).toModelOutput(toModelOutput).build();
+}
+function createDelegateCancellationHandler(options, childPathIndexes) {
+    if (options.cancelSubAgent === undefined)
+        return {};
+    return {
+        onCancellation: async (rawInput, ctx) => {
+            const parsedInput = delegation_1.delegateSubAgentInputSchema.safeParse(rawInput);
+            if (!parsedInput.success) {
+                throw new Error('Delegated child input is missing or invalid');
+            }
+            await (0, delegate_sub_agent_runner_1.cancelDelegatedSubAgent)(parsedInput.data, ctx, options, childPathIndexes);
+        },
+    };
+}
+function buildDelegateToolMetadata(resolvedOptions) {
+    return {
+        ...(resolvedOptions.name !== undefined ? { name: resolvedOptions.name } : {}),
+        ...(resolvedOptions.availableSubAgents !== undefined
+            ? { availableSubAgents: resolvedOptions.availableSubAgents }
+            : {}),
+        policy: resolvedOptions.policy,
+        ...(resolvedOptions.inlineSubAgentBlockedTools !== undefined
+            ? { inlineSubAgentBlockedTools: resolvedOptions.inlineSubAgentBlockedTools }
+            : {}),
+        ...(resolvedOptions.inlineSubAgentModelsByDifficulty !== undefined
             ? {
-                onCancellation: async (rawInput, ctx) => {
-                    const parsedInput = delegateSubAgentInputSchema.safeParse(rawInput);
-                    if (!parsedInput.success) {
-                        throw new Error('Delegated child input is missing or invalid');
-                    }
-                    await cancelDelegatedSubAgent(parsedInput.data, ctx, resolvedOptions, childPathIndexes);
-                },
+                inlineSubAgentModelsByDifficulty: resolvedOptions.inlineSubAgentModelsByDifficulty,
             }
             : {}),
-        metadata: {
-            ...tool.metadata,
-            [exports.INLINE_DELEGATE_SUB_AGENT_TOOL_METADATA_KEY]: {
-                ...(resolvedOptions.name !== undefined ? { name: resolvedOptions.name } : {}),
-                ...(resolvedOptions.availableSubAgents !== undefined
-                    ? { availableSubAgents: resolvedOptions.availableSubAgents }
-                    : {}),
-                policy: resolvedOptions.policy,
-                ...(resolvedOptions.inlineSubAgentBlockedTools !== undefined
-                    ? { inlineSubAgentBlockedTools: resolvedOptions.inlineSubAgentBlockedTools }
-                    : {}),
-                ...(resolvedOptions.inlineSubAgentModelsByDifficulty !== undefined
-                    ? {
-                        inlineSubAgentModelsByDifficulty: resolvedOptions.inlineSubAgentModelsByDifficulty,
-                    }
-                    : {}),
-                ...(resolvedOptions.resolveInlineSubAgentProviderTools !== undefined
-                    ? {
-                        resolveInlineSubAgentProviderTools: resolvedOptions.resolveInlineSubAgentProviderTools,
-                    }
-                    : {}),
-                ...(resolvedOptions.runSubAgent !== undefined
-                    ? { runSubAgent: resolvedOptions.runSubAgent }
-                    : {}),
-                ...(resolvedOptions.resumeSubAgent !== undefined
-                    ? { resumeSubAgent: resolvedOptions.resumeSubAgent }
-                    : {}),
-                ...(resolvedOptions.shouldRetrySubAgentResumeError !== undefined
-                    ? { shouldRetrySubAgentResumeError: resolvedOptions.shouldRetrySubAgentResumeError }
-                    : {}),
-                ...(resolvedOptions.cancelSubAgent !== undefined
-                    ? { cancelSubAgent: resolvedOptions.cancelSubAgent }
-                    : {}),
-                ...(resolvedOptions.systemInstruction !== undefined
-                    ? { systemInstruction: resolvedOptions.systemInstruction }
-                    : {}),
-                ...(resolvedOptions.description !== undefined
-                    ? { description: resolvedOptions.description }
-                    : {}),
-                ...(resolvedOptions.toModelOutput !== undefined
-                    ? { toModelOutput: resolvedOptions.toModelOutput }
-                    : {}),
-            },
-        },
-    });
+        ...(resolvedOptions.resolveInlineSubAgentProviderTools !== undefined
+            ? {
+                resolveInlineSubAgentProviderTools: resolvedOptions.resolveInlineSubAgentProviderTools,
+            }
+            : {}),
+        ...(resolvedOptions.runSubAgent !== undefined
+            ? { runSubAgent: resolvedOptions.runSubAgent }
+            : {}),
+        ...(resolvedOptions.resumeSubAgent !== undefined
+            ? { resumeSubAgent: resolvedOptions.resumeSubAgent }
+            : {}),
+        ...(resolvedOptions.shouldRetrySubAgentResumeError !== undefined
+            ? { shouldRetrySubAgentResumeError: resolvedOptions.shouldRetrySubAgentResumeError }
+            : {}),
+        ...(resolvedOptions.cancelSubAgent !== undefined
+            ? { cancelSubAgent: resolvedOptions.cancelSubAgent }
+            : {}),
+        ...(resolvedOptions.systemInstruction !== undefined
+            ? { systemInstruction: resolvedOptions.systemInstruction }
+            : {}),
+        ...(resolvedOptions.description !== undefined
+            ? { description: resolvedOptions.description }
+            : {}),
+        ...(resolvedOptions.toModelOutput !== undefined
+            ? { toModelOutput: resolvedOptions.toModelOutput }
+            : {}),
+    };
 }
 function getInlineDelegateSubAgentToolOptions(tool) {
-    const value = tool.metadata?.[exports.INLINE_DELEGATE_SUB_AGENT_TOOL_METADATA_KEY];
+    const value = tool.metadata?.[delegation_1.INLINE_DELEGATE_SUB_AGENT_TOOL_METADATA_KEY];
     if (typeof value !== 'object' || value === null)
         return undefined;
     return value;
@@ -296,303 +202,4 @@ function formatDelegationPolicyInstructions(policy, toolName) {
         ].join('\n'),
     ];
 }
-async function handleDelegateSubAgent(input, ctx, options, childPathIndexes) {
-    let taskPath;
-    let request;
-    let startedAt;
-    try {
-        if (options.resumeSubAgent !== undefined &&
-            isInterruptibleToolContext(ctx) &&
-            ctx.continuation !== undefined) {
-            const restored = restoreDelegateRequest(input, ctx, ctx.continuation, options.policy, childPathIndexes);
-            const { checkpoint } = restored;
-            taskPath = checkpoint.taskPath;
-            request = restored.request;
-            startedAt = Date.now();
-            emitSubAgentStarted(ctx, request, startedAt);
-            let output;
-            try {
-                output = await options.resumeSubAgent({
-                    ...request,
-                    ...getChildCheckpointTarget(checkpoint),
-                    resumeData: ctx.resumeData,
-                }, createRunnerHelpers(ctx, request, options.name));
-            }
-            catch (error) {
-                if (ctx.abortSignal?.aborted || (0, abort_1.isAbortError)(error))
-                    throw error;
-                if (options.shouldRetrySubAgentResumeError?.(error) === false)
-                    throw error;
-                return await ctx.suspend(ctx.suspendPayload);
-            }
-            emitSubAgentCompleted(ctx, request, output, startedAt);
-            if (output.status === 'suspended') {
-                return await cascadeChildSuspension(ctx, request, output);
-            }
-            return output;
-        }
-        const childPathIndexKey = getChildPathIndexKey(ctx);
-        const childPathIndex = childPathIndexes.get(childPathIndexKey) ?? 0;
-        taskPath = (0, sub_agent_task_path_1.createChildSubAgentTaskPath)(input.taskName, childPathIndex);
-        childPathIndexes.set(childPathIndexKey, childPathIndex + 1);
-        request = createDelegateSubAgentRequest(input, ctx, taskPath, childPathIndex, options.policy);
-        startedAt = Date.now();
-        emitSubAgentStarted(ctx, request, startedAt);
-        const toolName = options.name ?? exports.DELEGATE_SUB_AGENT_TOOL_NAME;
-        if (!options.runSubAgent) {
-            throw new Error(`${toolName} was registered without a runSubAgent callback, and no host runner was provided. Register it on an Agent (for inline delegation) or pass runSubAgent.`);
-        }
-        const output = await options.runSubAgent(request, createRunnerHelpers(ctx, request, options.name));
-        emitSubAgentCompleted(ctx, request, output, startedAt);
-        if (output.status === 'suspended' &&
-            options.resumeSubAgent !== undefined &&
-            isInterruptibleToolContext(ctx)) {
-            return await cascadeChildSuspension(ctx, request, output);
-        }
-        return output;
-    }
-    catch (error) {
-        const aborted = ctx.abortSignal ? ctx.abortSignal.aborted : (0, abort_1.isAbortError)(error);
-        const output = {
-            status: aborted ? 'cancelled' : 'failed',
-            ...(taskPath !== undefined ? { taskPath } : {}),
-            answer: '',
-            ...(aborted ? {} : { error: stringifyUnknown(error) }),
-        };
-        if (request !== undefined && startedAt !== undefined) {
-            emitSubAgentCompleted(ctx, request, output, startedAt);
-        }
-        if (aborted)
-            throw error;
-        return output;
-    }
-}
-function createDelegateSubAgentRequest(input, ctx, taskPath, childCount, policy) {
-    return {
-        ...input,
-        taskPath,
-        childCount,
-        ...(ctx.runId !== undefined ? { parentRunId: ctx.runId } : {}),
-        ...(ctx.persistence?.threadId !== undefined
-            ? { parentThreadId: ctx.persistence.threadId }
-            : {}),
-        ...(ctx.persistence?.resourceId !== undefined
-            ? { parentResourceId: ctx.persistence.resourceId }
-            : {}),
-        ...(ctx.persistence?.hostMetadata !== undefined
-            ? { parentHostMetadata: ctx.persistence.hostMetadata }
-            : {}),
-        ...(ctx.abortSignal !== undefined ? { parentAbortSignal: ctx.abortSignal } : {}),
-        ...(ctx.toolCallId !== undefined ? { parentToolCallId: ctx.toolCallId } : {}),
-        ...(ctx.executionCounter !== undefined
-            ? { parentExecutionCounter: (0, execution_counter_1.withoutMessageCount)(ctx.executionCounter) }
-            : {}),
-        ...(ctx.parentTelemetry !== undefined ? { parentTelemetry: ctx.parentTelemetry } : {}),
-        ...(policy !== undefined ? { policy } : {}),
-    };
-}
-function isJsonSchemaObject(value) {
-    return (0, is_record_1.isRecord)(value);
-}
-async function cancelDelegatedSubAgent(input, ctx, options, childPathIndexes) {
-    if (options.cancelSubAgent === undefined || ctx.continuation === undefined)
-        return;
-    const { checkpoint, request } = restoreDelegateRequest(input, ctx, ctx.continuation, options.policy, childPathIndexes);
-    await options.cancelSubAgent({
-        ...request,
-        ...getChildCheckpointTarget(checkpoint),
-        reason: ctx.cancellation.message,
-    }, createRunnerHelpers(ctx, request, options.name));
-}
-function restoreDelegateRequest(input, ctx, continuation, policy, childPathIndexes) {
-    const checkpoint = parseDelegateSubAgentContinuation(continuation);
-    if (!checkpoint) {
-        throw new Error('Delegated child checkpoint metadata is missing or invalid');
-    }
-    if (checkpoint.subAgentId !== input.subAgentId) {
-        throw new Error('Delegated child checkpoint does not match the selected sub-agent');
-    }
-    const { taskPath } = checkpoint;
-    (0, sub_agent_task_path_1.assertSubAgentTaskPath)(taskPath);
-    const key = getChildPathIndexKey(ctx);
-    childPathIndexes.set(key, Math.max(childPathIndexes.get(key) ?? 0, checkpoint.childCount + 1));
-    const request = createDelegateSubAgentRequest(input, ctx, taskPath, checkpoint.childCount, policy);
-    return { checkpoint: { ...checkpoint, taskPath }, request };
-}
-function getChildCheckpointTarget(checkpoint) {
-    return {
-        childRunId: checkpoint.runId,
-        childToolCallId: checkpoint.toolCallId,
-        ...(checkpoint.threadId !== undefined ? { childThreadId: checkpoint.threadId } : {}),
-        ...(checkpoint.resumeContext !== undefined ? { resumeContext: checkpoint.resumeContext } : {}),
-    };
-}
-function createRunnerHelpers(ctx, request, configuredToolName) {
-    const toolName = configuredToolName ?? exports.DELEGATE_SUB_AGENT_TOOL_NAME;
-    return {
-        runInlineSubAgent: () => {
-            throw new Error(`${toolName} host runner does not support inline delegation without helpers.runInlineSubAgent from an Agent build.`);
-        },
-        emitChunk: createEmitChunkHelper(ctx, request),
-    };
-}
-function isInterruptibleToolContext(ctx) {
-    return 'suspend' in ctx;
-}
-async function cascadeChildSuspension(ctx, request, output) {
-    const suspension = output.pendingSuspend?.[0];
-    if (!suspension || !isJsonSchemaObject(suspension.resumeSchema)) {
-        throw new Error(exports.DELEGATED_CHILD_SUSPEND_UNSUPPORTED_MESSAGE);
-    }
-    return await ctx.suspend(suspension.suspendPayload, {
-        resumeSchema: suspension.resumeSchema,
-        continuation: {
-            runId: suspension.runId,
-            toolCallId: suspension.toolCallId,
-            taskPath: request.taskPath,
-            subAgentId: request.subAgentId,
-            childCount: request.childCount,
-            ...(output.threadId !== undefined ? { threadId: output.threadId } : {}),
-            ...(output.resumeContext !== undefined ? { resumeContext: output.resumeContext } : {}),
-        },
-    });
-}
-function emitSubAgentStarted(ctx, request, startedAt) {
-    ctx.emitEvent?.({
-        type: "subagent_started",
-        ...subAgentLifecycleBase(request),
-        startedAt,
-    });
-}
-function emitSubAgentCompleted(ctx, request, output, startedAt) {
-    const finishedAt = Date.now();
-    ctx.emitEvent?.({
-        type: "subagent_completed",
-        ...subAgentLifecycleBase(request),
-        status: output.status,
-        startedAt,
-        finishedAt,
-        durationMs: finishedAt - startedAt,
-        ...(output.runId !== undefined ? { runId: output.runId } : {}),
-        ...(output.threadId !== undefined ? { threadId: output.threadId } : {}),
-        ...(output.usage !== undefined ? { usage: output.usage } : {}),
-        ...(output.finishReason !== undefined ? { finishReason: output.finishReason } : {}),
-        ...(output.model !== undefined ? { model: output.model } : {}),
-        ...(output.error !== undefined ? { error: output.error } : {}),
-    });
-}
-function subAgentLifecycleBase(request) {
-    return {
-        taskName: request.taskName,
-        taskPath: request.taskPath,
-        ...(request.parentRunId !== undefined ? { parentRunId: request.parentRunId } : {}),
-        ...(request.parentToolCallId !== undefined
-            ? { parentToolCallId: request.parentToolCallId }
-            : {}),
-        ...(request.subAgentId !== undefined ? { subAgentId: request.subAgentId } : {}),
-    };
-}
-function getChildPathIndexKey(ctx) {
-    return ctx.runId ?? ctx.persistence?.threadId ?? ctx.persistence?.resourceId ?? 'adhoc';
-}
-function stringifyUnknown(value) {
-    if (value instanceof Error)
-        return value.message;
-    if (typeof value === 'string')
-        return value;
-    if (typeof value === 'number' || typeof value === 'boolean' || value === null) {
-        return String(value);
-    }
-    try {
-        return JSON.stringify(value);
-    }
-    catch {
-        return 'Unknown error';
-    }
-}
-function renderDelegateSubAgentPrompt(request) {
-    const sections = [
-        'You are a focused subagent working on a specific delegated task.',
-        `YOUR TASK:\n${request.goal}`,
-    ];
-    if (request.context) {
-        sections.push(`CONTEXT:\n${request.context}`);
-    }
-    if (request.expectedOutput) {
-        sections.push(`EXPECTED OUTPUT:\n${request.expectedOutput}`);
-    }
-    sections.push([
-        'Complete this task using the tools available to you. When finished, provide a clear, concise summary of:',
-        '- What you did',
-        '- What you found or accomplished',
-        '- Important outputs, decisions, or evidence',
-        '- Any issues, assumptions, or limitations',
-        '',
-        'If the information above is insufficient, do your best with explicitly stated assumptions and note what was missing, rather than stopping to ask.',
-        '',
-        'Be thorough but concise -- your response is returned to the parent agent as a summary.',
-    ].join('\n'));
-    return sections.join('\n\n');
-}
-function resolveDelegateSubAgentStatus(result) {
-    if (result.finishReason === 'error' || result.error !== undefined) {
-        return result.getState().status === 'cancelled' ? 'cancelled' : 'failed';
-    }
-    if (result.pendingSuspend !== undefined && result.pendingSuspend.length > 0) {
-        return 'suspended';
-    }
-    return 'completed';
-}
-function failedDelegatedChildSuspendOutput(taskPath, model) {
-    return {
-        status: 'failed',
-        taskPath,
-        answer: '',
-        error: exports.DELEGATED_CHILD_SUSPEND_UNSUPPORTED_MESSAGE,
-        ...(model !== undefined ? { model } : {}),
-    };
-}
-function generateResultToDelegateSubAgentOutput(taskPath, result, threadId) {
-    const status = resolveDelegateSubAgentStatus(result);
-    return {
-        status,
-        taskPath,
-        runId: result.runId,
-        ...(threadId !== undefined ? { threadId } : {}),
-        ...(result.model !== undefined ? { model: result.model } : {}),
-        answer: lastText(result.messages),
-        ...(result.structuredOutput !== undefined ? { structuredOutput: result.structuredOutput } : {}),
-        ...(result.usage !== undefined
-            ? {
-                usage: {
-                    promptTokens: result.usage.promptTokens,
-                    completionTokens: result.usage.completionTokens,
-                    totalTokens: result.usage.totalTokens,
-                    ...(result.usage.cost !== undefined ? { cost: result.usage.cost } : {}),
-                },
-            }
-            : {}),
-        ...(result.finishReason !== undefined ? { finishReason: result.finishReason } : {}),
-        ...(result.error !== undefined ? { error: stringifyUnknown(result.error) } : {}),
-        ...(status === 'suspended' && result.pendingSuspend !== undefined
-            ? { pendingSuspend: result.pendingSuspend }
-            : {}),
-    };
-}
-function lastText(messages) {
-    const llmMessages = (0, message_1.filterLlmMessages)(messages);
-    for (let i = llmMessages.length - 1; i >= 0; i--) {
-        const message = llmMessages[i];
-        if (!message)
-            continue;
-        const text = message.content
-            .filter((content) => content.type === 'text')
-            .map((content) => content.text)
-            .join('\n')
-            .trim();
-        if (text)
-            return text;
-    }
-    return '';
-}
 //# sourceMappingURL=delegate-sub-agent-tool.js.map