@n8n/instance-ai 1.10.1 → 1.11.0

package/dist/tools/orchestration/build-workflow-agent.tool.js

@@ -1,1498 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildWorkflowAgentInputSchema = exports.DETACHED_BUILDER_REQUIREMENTS = void 0;
-exports.getBuilderSessionMemory = getBuilderSessionMemory;
-exports.builderWorkflowWorkspaceLayout = builderWorkflowWorkspaceLayout;
-exports.materializeBuilderRuntimeSkills = materializeBuilderRuntimeSkills;
-exports.buildWarmBuilderFollowUp = buildWarmBuilderFollowUp;
-exports.recordSuccessfulWorkflowBuilds = recordSuccessfulWorkflowBuilds;
-exports.determineVerificationReadiness = determineVerificationReadiness;
-exports.determineSetupRequirement = determineSetupRequirement;
-exports.mergeLatestVerificationIntoOutcome = mergeLatestVerificationIntoOutcome;
-exports.withTerminalLoopState = withTerminalLoopState;
-exports.finalizeBuildResult = finalizeBuildResult;
-exports.createMainWorkflowSnapshot = createMainWorkflowSnapshot;
-exports.shouldFinalSubmitMainWorkflow = shouldFinalSubmitMainWorkflow;
-exports.supportingWorkflowIdsFromSubmitAttempts = supportingWorkflowIdsFromSubmitAttempts;
-exports.resultFromPostStreamError = resultFromPostStreamError;
-exports.resultFromTerminalRemediation = resultFromTerminalRemediation;
-exports.resultFromLaterFailedMainSubmit = resultFromLaterFailedMainSubmit;
-exports.attemptFromAutoResubmit = attemptFromAutoResubmit;
-exports.shouldRecoverSavedWorkflowAfterFailedSubmit = shouldRecoverSavedWorkflowAfterFailedSubmit;
-exports.settleMissingMainWorkflowSubmit = settleMissingMainWorkflowSubmit;
-exports.startBuildWorkflowAgentTask = startBuildWorkflowAgentTask;
-exports.createBuildWorkflowAgentTool = createBuildWorkflowAgentTool;
-const agents_1 = require("@n8n/agents");
-const workflow_sdk_1 = require("@n8n/workflow-sdk");
-const n8n_workflow_1 = require("n8n-workflow");
-const nanoid_1 = require("nanoid");
-const node_crypto_1 = require("node:crypto");
-const zod_1 = require("zod");
-const agent_persistence_1 = require("./agent-persistence");
-const build_workflow_agent_prompt_1 = require("./build-workflow-agent.prompt");
-const builder_memory_compaction_1 = require("./builder-memory-compaction");
-const display_utils_1 = require("./display-utils");
-const tracing_utils_1 = require("./tracing-utils");
-const verify_built_workflow_tool_1 = require("./verify-built-workflow.tool");
-const runtime_workspace_1 = require("../../agent/runtime-workspace");
-const sub_agent_briefing_1 = require("../../agent/sub-agent-briefing");
-const max_steps_1 = require("../../constants/max-steps");
-const materialize_runtime_skills_1 = require("../../skills/materialize-runtime-skills");
-const runtime_skills_1 = require("../../skills/runtime-skills");
-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 extract_code_1 = require("../../workflow-builder/extract-code");
-const workflow_loop_1 = require("../../workflow-loop");
-const sandbox_fs_1 = require("../../workspace/sandbox-fs");
-const sandbox_setup_1 = require("../../workspace/sandbox-setup");
-const scoped_workspace_1 = require("../../workspace/scoped-workspace");
-const template_telemetry_1 = require("../../workspace/template-telemetry");
-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 resolve_credentials_1 = require("../workflows/resolve-credentials");
-const submit_workflow_identity_1 = require("../workflows/submit-workflow-identity");
-const workflow_json_utils_1 = require("../workflows/workflow-json-utils");
-const workflows_tool_1 = require("../workflows.tool");
-const WORKFLOW_NOT_SUBMITTED_FAILURE_SIGNATURE = 'workflow:not_submitted';
-const WORKFLOW_FINAL_SUBMIT_FAILED_FAILURE_SIGNATURE = 'workflow:final_submit_failed';
-function getBuilderSessionMemory(context, useSharedWorkspace) {
-    return useSharedWorkspace ? context.memory : undefined;
-}
-const BUILDER_WORK_ITEMS_DIR = 'builder-work-items';
-function safeWorkItemPathSegment(workItemId) {
-    const slug = workItemId
-        .replace(/[^A-Za-z0-9_-]+/g, '-')
-        .replace(/^-+|-+$/g, '')
-        .slice(0, 48);
-    const hash = (0, node_crypto_1.createHash)('sha256').update(workItemId).digest('hex').slice(0, 8);
-    return `${slug || 'work-item'}-${hash}`;
-}
-function builderWorkflowWorkspaceLayout(root, workItemId) {
-    const relativeWorkItemRoot = `${BUILDER_WORK_ITEMS_DIR}/${safeWorkItemPathSegment(workItemId)}`;
-    const workItemRoot = `${root}/${relativeWorkItemRoot}`;
-    return {
-        workItemRoot,
-        sourceDir: `${workItemRoot}/src`,
-        chunksDir: `${workItemRoot}/chunks`,
-        mainWorkflowPath: `${workItemRoot}/src/workflow.ts`,
-        tsconfigPath: `${workItemRoot}/tsconfig.json`,
-        relativeMainWorkflowPath: `${relativeWorkItemRoot}/src/workflow.ts`,
-    };
-}
-function renderBuilderTaskTsconfig() {
-    return `${JSON.stringify({
-        extends: '../../tsconfig.json',
-        include: ['src/**/*.ts', 'chunks/**/*.ts'],
-    }, null, 2)}\n`;
-}
-async function writeBuilderWorkspaceFile(workspace, filePath, content) {
-    if (workspace.filesystem) {
-        await workspace.filesystem.writeFile(filePath, content, { recursive: true });
-        return;
-    }
-    await (0, sandbox_fs_1.writeFileViaSandbox)(workspace, filePath, content);
-}
-async function materializeBuilderRuntimeSkills(context, workspace, root) {
-    const source = context.runtimeSkillCatalog ?? context.runtimeSkills;
-    if (!(0, runtime_skills_1.hasRuntimeSkills)(source)) {
-        return { workspace, source };
-    }
-    let materialized;
-    try {
-        const workspaceRoot = await (0, sandbox_setup_1.getWorkspaceRoot)(workspace);
-        materialized = await (0, materialize_runtime_skills_1.createPrebakedRuntimeSkillsFromWorkspace)({
-            source,
-            workspace,
-            root: workspaceRoot,
-            workspaceRoot: root,
-            logger: context.logger,
-        });
-    }
-    catch (error) {
-        context.logger.debug('Could not inspect prebaked runtime skills; materializing live', {
-            error: error instanceof Error ? error.message : String(error),
-        });
-    }
-    materialized ??= await (0, materialize_runtime_skills_1.materializeRuntimeSkillsIntoWorkspace)({
-        source,
-        workspace,
-        root,
-        logger: context.logger,
-    });
-    if (!materialized)
-        return { workspace, source };
-    return {
-        workspace: (0, scoped_workspace_1.createScopedWorkspace)(workspace, root, materialized.env),
-        source: materialized.source,
-    };
-}
-function toToolRegistry(tools) {
-    const registry = (0, tool_registry_1.createToolRegistry)();
-    for (const tool of tools) {
-        registry.set(tool.name, tool);
-    }
-    return registry;
-}
-const BUILDER_WORKFLOW_ACTIONS = [
-    'list',
-    'get',
-    'get-as-code',
-];
-const BUILDER_CREDENTIAL_ACTIONS = [
-    'list',
-    'get',
-    'search-types',
-    'test',
-];
-const BUILDER_SANDBOX_TOOL_NAMES = [
-    'nodes',
-    'executions',
-    data_tables_tool_1.DATA_TABLES_TOOL_ID,
-    'parse-file',
-    ask_user_tool_1.ASK_USER_TOOL_ID,
-    'research',
-];
-const BUILDER_TOOL_MODE_TOOL_NAMES = [
-    'build-workflow',
-    'nodes',
-    'workflows',
-    data_tables_tool_1.DATA_TABLES_TOOL_ID,
-    'parse-file',
-    ask_user_tool_1.ASK_USER_TOOL_ID,
-    'research',
-];
-function createBuilderWorkflowsTool(context) {
-    return (0, workflows_tool_1.createWorkflowsTool)(context, {
-        allowedActions: BUILDER_WORKFLOW_ACTIONS,
-        descriptionPrefix: 'Inspect workflows during build',
-    });
-}
-function createBuilderCredentialsTool(context) {
-    return (0, credentials_tool_1.createCredentialsTool)(context, {
-        allowedActions: BUILDER_CREDENTIAL_ACTIONS,
-        descriptionPrefix: 'Inspect credentials during build',
-        descriptionSuffix: 'Setup is handled after workflow verification.',
-    });
-}
-function buildWarmBuilderFollowUp(input) {
-    const parts = [
-        '<builder-follow-up type="fix">',
-        `Work item ID: ${input.workItemId}`,
-        `Workflow ID: ${input.workflowId}`,
-        'Continue from the existing sandbox files and your prior builder messages/tool calls. Apply the requested change, then submit the main workflow file.',
-        '',
-        exports.DETACHED_BUILDER_REQUIREMENTS,
-    ];
-    if (input.conversationContext) {
-        parts.push('', '<conversation-context>', input.conversationContext, '</conversation-context>');
-    }
-    parts.push('', '<requested-change>', input.task, '</requested-change>', '</builder-follow-up>');
-    return parts.join('\n');
-}
-async function promoteMainWorkflow(context, logger, workflowId) {
-    if (!workflowId || !context)
-        return;
-    try {
-        await context.workflowService.clearAiTemporary(workflowId);
-    }
-    catch (error) {
-        logger.warn(`Failed to clear AI-builder temporary marker on main workflow ${workflowId}: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null;
-}
-function recordSuccessfulWorkflowBuilds(tool, onWorkflowId) {
-    if (!tool?.handler)
-        return;
-    const original = tool.handler;
-    const wrapped = async (input, ctx) => {
-        const result = await original(input, ctx);
-        if (isRecord(result) && result.success === true && typeof result.workflowId === 'string') {
-            onWorkflowId(result.workflowId);
-        }
-        return result;
-    };
-    Object.assign(tool, { handler: wrapped });
-}
-function detectTriggerType(_attempt) {
-    return 'manual_or_testable';
-}
-function hasMockedCredentials(outcome) {
-    return ((outcome.mockedCredentialTypes?.length ?? 0) > 0 ||
-        Object.keys(outcome.mockedCredentialsByNode ?? {}).length > 0);
-}
-function hasCredentialVerificationData(outcome) {
-    return (Object.keys(outcome.verificationPinData ?? {}).length > 0 ||
-        outcome.usesWorkflowPinDataForVerification === true);
-}
-function hasSuccessfulStructuredVerification(outcome) {
-    return (outcome.verification?.attempted === true &&
-        outcome.verification.success &&
-        !!outcome.verification.executionId);
-}
-function determineVerificationReadiness(outcome) {
-    if (hasSuccessfulStructuredVerification(outcome)) {
-        return { status: 'already_verified' };
-    }
-    if (!outcome.submitted) {
-        return {
-            status: 'not_verifiable',
-            reason: 'not-submitted',
-            guidance: 'The build did not submit a workflow, so there is nothing to verify.',
-        };
-    }
-    if (!outcome.workflowId) {
-        return {
-            status: 'not_verifiable',
-            reason: 'missing-workflow-id',
-            guidance: 'The build outcome does not include a workflow ID.',
-        };
-    }
-    if (outcome.hasUnresolvedPlaceholders) {
-        return {
-            status: 'needs_setup',
-            reason: 'unresolved-placeholders',
-            guidance: 'Route the workflow through setup before verification.',
-        };
-    }
-    if (hasMockedCredentials(outcome) && !hasCredentialVerificationData(outcome)) {
-        return {
-            status: 'needs_setup',
-            reason: 'missing-mocked-credential-pin-data',
-            guidance: 'Route the workflow through setup because mocked credentials cannot be verified.',
-        };
-    }
-    if (outcome.remediation?.category === 'needs_setup') {
-        return {
-            status: 'needs_setup',
-            reason: 'workflow-needs-setup',
-            guidance: outcome.remediation.guidance,
-        };
-    }
-    if (!outcome.triggerNodes?.some((node) => (0, workflow_json_utils_1.isMockableTriggerNodeType)(node.nodeType))) {
-        return {
-            status: 'not_verifiable',
-            reason: 'non-mockable-trigger',
-            guidance: 'The workflow does not have a trigger the post-build verifier can exercise.',
-        };
-    }
-    return { status: 'ready' };
-}
-function determineSetupRequirement(outcome) {
-    if (!outcome.submitted || !outcome.workflowId) {
-        return { status: 'not_required' };
-    }
-    if (outcome.hasUnresolvedPlaceholders) {
-        return {
-            status: 'required',
-            reason: 'unresolved-placeholders',
-            guidance: 'Route the workflow through setup so the user can fill unresolved values.',
-        };
-    }
-    if (hasMockedCredentials(outcome)) {
-        return {
-            status: 'required',
-            reason: 'mocked-credentials',
-            guidance: 'Route the workflow through setup so the user can add real credentials.',
-        };
-    }
-    if (outcome.remediation?.category === 'needs_setup') {
-        return {
-            status: 'required',
-            reason: 'workflow-needs-setup',
-            guidance: outcome.remediation.guidance,
-        };
-    }
-    return { status: 'not_required' };
-}
-function withDeterministicRouting(outcome) {
-    return {
-        ...outcome,
-        verificationReadiness: determineVerificationReadiness(outcome),
-        setupRequirement: determineSetupRequirement(outcome),
-    };
-}
-function buildOutcome(workItemId, runId, taskId, attempt, finalText, supportingWorkflowIds = []) {
-    if (!attempt?.success) {
-        return withDeterministicRouting({
-            workItemId,
-            runId,
-            taskId,
-            submitted: false,
-            triggerType: 'manual_or_testable',
-            needsUserInput: false,
-            failureSignature: attempt?.errors?.join('; '),
-            remediation: attempt?.remediation,
-            summary: finalText,
-        });
-    }
-    const placeholderRemediation = attempt.hasUnresolvedPlaceholders
-        ? (0, workflow_loop_1.createRemediation)({
-            category: 'needs_setup',
-            shouldEdit: false,
-            reason: 'mocked_credentials_or_placeholders',
-            guidance: 'Workflow submitted successfully, but unresolved setup values remain. Stop code edits and route to workflows(action="setup").',
-        })
-        : undefined;
-    return withDeterministicRouting({
-        workItemId,
-        runId,
-        taskId,
-        workflowId: attempt.workflowId,
-        submitted: true,
-        triggerType: detectTriggerType(attempt),
-        needsUserInput: Boolean(placeholderRemediation),
-        blockingReason: placeholderRemediation?.guidance,
-        mockedNodeNames: attempt.mockedNodeNames,
-        mockedCredentialTypes: attempt.mockedCredentialTypes,
-        mockedCredentialsByNode: attempt.mockedCredentialsByNode,
-        triggerNodes: attempt.triggerNodes,
-        verificationPinData: attempt.verificationPinData,
-        usesWorkflowPinDataForVerification: attempt.usesWorkflowPinDataForVerification,
-        supportingWorkflowIds: supportingWorkflowIds.length > 0 ? supportingWorkflowIds : undefined,
-        hasUnresolvedPlaceholders: attempt.hasUnresolvedPlaceholders,
-        remediation: placeholderRemediation ?? attempt.remediation,
-        summary: finalText,
-    });
-}
-function mergeLatestVerificationIntoOutcome(outcome, latestOutcome) {
-    if (!latestOutcome?.verification)
-        return outcome;
-    if (latestOutcome.workItemId !== outcome.workItemId)
-        return outcome;
-    if (latestOutcome.taskId !== outcome.taskId)
-        return outcome;
-    if (outcome.workflowId &&
-        latestOutcome.workflowId &&
-        latestOutcome.workflowId !== outcome.workflowId) {
-        return outcome;
-    }
-    return withDeterministicRouting({
-        ...outcome,
-        verification: latestOutcome.verification,
-    });
-}
-function withTerminalLoopState(outcome, state) {
-    const remediation = state?.lastRemediation;
-    if (!outcome.submitted || !remediation || remediation.shouldEdit) {
-        return outcome;
-    }
-    return withDeterministicRouting({
-        ...outcome,
-        workflowId: outcome.workflowId ?? state.workflowId,
-        needsUserInput: remediation.category === 'needs_setup',
-        blockingReason: remediation.guidance,
-        remediation,
-    });
-}
-async function finalBuildOutcome(context, workItemId, outcome) {
-    const latestOutcome = await getLatestBuildOutcome(context, workItemId);
-    const loopState = await context.workflowTaskService?.getWorkflowLoopState(workItemId);
-    return withTerminalLoopState(mergeLatestVerificationIntoOutcome(outcome, latestOutcome), loopState);
-}
-async function finalizeBuildResult(context, workItemId, result) {
-    return {
-        text: result.text,
-        outcome: await finalBuildOutcome(context, workItemId, result.outcome),
-    };
-}
-async function reportAndFinalizeBuildResult(context, workItemId, result) {
-    await context.workflowTaskService?.reportBuildOutcome(result.outcome);
-    return await finalizeBuildResult(context, workItemId, result);
-}
-async function buildOutcomeWithLatestVerification(context, workItemId, taskId, attempt, finalText, supportingWorkflowIds = []) {
-    const outcome = buildOutcome(workItemId, context.runId, taskId, attempt, finalText, supportingWorkflowIds);
-    return await finalBuildOutcome(context, workItemId, outcome);
-}
-exports.DETACHED_BUILDER_REQUIREMENTS = `## Detached Task Contract
-
-You are running as a detached background task. Do not stop after a successful submit — verify the workflow works.
-
-### Completion criteria
-
-Your job is done when ONE of these is true:
-- the workflow is verified (ran successfully)
-- you are blocked after one repair attempt per unique failure
-
-Do NOT stop after a successful submit without verifying. Every trigger type is testable:
-manual / schedule via \`executions(action="run")\`; event-based triggers (form, webhook,
-chat, mcp, linear, github, slack, etc.) via \`verify-built-workflow\` with an \`inputData\`
-payload. The pin-data adapter injects it as the trigger node's output.
-
-### Submit discipline
-
-**Every file edit MUST be followed by submit-workflow before you do anything else.**
-The system tracks file hashes. If you edit the code and then call \`executions(action="run")\`, \`verify-built-workflow\`, or finish without re-submitting, your work is discarded. The sequence is always: edit → submit → then verify/run.
-
-### Verification
-
-- If submit-workflow returned mocked credentials, call \`verify-built-workflow\` with the workItemId and workflowId from this task.
-- Otherwise pick based on trigger type:
-  - **Manual / Schedule** — \`executions(action="run")\`.
-  - **Form Trigger** — pass \`inputData\` as a flat field map, e.g. \`{name: "Alice", email: "a@b.c"}\`. Do NOT wrap in \`formFields\` — production Form Trigger emits fields directly on \`$json\`, and the adapter rejects wrapped payloads.
-  - **Webhook** — \`verify-built-workflow\` with \`inputData\` as the body payload, e.g. \`{event: "signup", userId: "..."}\`. Adapter wraps it under \`body\`; downstream expressions use \`$json.body.<field>\`.
-  - **Chat Trigger** — \`verify-built-workflow\` with \`{chatInput: "user message"}\`.
-  - **Other event triggers (Linear, GitHub, Slack, MCP, etc.)** — \`verify-built-workflow\` with \`inputData\` matching the trigger's expected payload shape.
-- If verify-built-workflow returns remediation with \`shouldEdit: false\`, stop editing and follow its guidance.
-- If verification fails with \`shouldEdit: true\`, make one batched code repair and re-submit. Never exceed the remaining repair budget in the remediation metadata.
-- If verification fails otherwise, call \`executions(action="debug")\`, fix the code, re-submit, and retry once.
-- If the same failure signature repeats, stop and explain the block.
-
-### Resource discovery
-
-Before writing code that uses external services, **resolve real resource IDs**:
-- Call \`nodes(action="explore-resources")\` for any parameter with searchListMethod (calendars, spreadsheets, channels, models, etc.)
-- Do NOT use "primary", "default", or any assumed identifier — look up the actual value
-- Call \`nodes(action="suggested")\` early if the workflow fits a known category (web_app, form_input, data_persistence, etc.) — the pattern hints prevent common mistakes
-- Check @builderHint annotations in node type definitions for critical configuration guidance
-
-### Publishing
-
-Do NOT call \`workflows(action="publish")\` for the main workflow. Publishing is the user's decision after testing. Your job ends at a successful submit. The only exception is sub-workflows in the compositional pattern — those must be published so the parent workflow can reference them.
-`;
-function hashContent(content) {
-    return (0, node_crypto_1.createHash)('sha256')
-        .update(content ?? '', 'utf8')
-        .digest('hex');
-}
-function createMainWorkflowSnapshot(content) {
-    if (content === null) {
-        return { exists: false };
-    }
-    return {
-        exists: true,
-        sourceHash: hashContent(content),
-    };
-}
-function shouldFinalSubmitMainWorkflow(input) {
-    return (input.current.exists &&
-        (!input.initial.exists || input.initial.sourceHash !== input.current.sourceHash));
-}
-function buildNotSubmittedOutcome(workItemId, runId, taskId, finalText, failureSignature = WORKFLOW_NOT_SUBMITTED_FAILURE_SIGNATURE) {
-    return withDeterministicRouting({
-        workItemId,
-        runId,
-        taskId,
-        submitted: false,
-        triggerType: 'manual_or_testable',
-        needsUserInput: false,
-        failureSignature,
-        summary: finalText,
-    });
-}
-function deterministicSuffix(seed, label, length) {
-    return (0, node_crypto_1.createHash)('sha256')
-        .update(label)
-        .update('\0')
-        .update(seed)
-        .digest('hex')
-        .slice(0, length);
-}
-function shouldUseDeterministicBuilderIds(context) {
-    return process.env.E2E_TESTS === 'true' && context.tracing?.replayMode !== 'off';
-}
-function createDeterministicBuilderIds(input) {
-    const seed = JSON.stringify({
-        task: input.task,
-        workflowId: input.workflowId ?? '',
-        plannedTaskId: input.plannedTaskId ?? '',
-        conversationContext: input.conversationContext ?? '',
-    });
-    return {
-        subAgentId: `agent-builder-${deterministicSuffix(seed, 'agent', 6)}`,
-        taskId: `build-${deterministicSuffix(seed, 'task', 8)}`,
-        workItemId: `wi_${deterministicSuffix(seed, 'work-item', 8)}`,
-    };
-}
-function latestSuccessfulMainSubmit(submitAttempts, mainWorkflowPath) {
-    for (let i = submitAttempts.length - 1; i >= 0; i--) {
-        const attempt = submitAttempts[i];
-        if (attempt.filePath === mainWorkflowPath && attempt.success && attempt.workflowId) {
-            return attempt;
-        }
-    }
-    return undefined;
-}
-function latestMainSubmit(submitAttempts, mainWorkflowPath) {
-    for (let i = submitAttempts.length - 1; i >= 0; i--) {
-        const attempt = submitAttempts[i];
-        if (attempt.filePath === mainWorkflowPath) {
-            return attempt;
-        }
-    }
-    return undefined;
-}
-function supportingWorkflowIdsFromSubmitAttempts(submitAttempts, mainWorkflowPath, mainWorkflowId, referencedWorkflowIds = []) {
-    const seen = new Set();
-    const referencedWorkflowIdSet = new Set(referencedWorkflowIds);
-    const supportingWorkflowIds = [];
-    for (const attempt of submitAttempts) {
-        if (!attempt.success || !attempt.workflowId)
-            continue;
-        if (attempt.filePath === mainWorkflowPath)
-            continue;
-        if (attempt.workflowId === mainWorkflowId)
-            continue;
-        if (!referencedWorkflowIdSet.has(attempt.workflowId))
-            continue;
-        if (seen.has(attempt.workflowId))
-            continue;
-        seen.add(attempt.workflowId);
-        supportingWorkflowIds.push(attempt.workflowId);
-    }
-    return supportingWorkflowIds;
-}
-function resultFromPostStreamError(input) {
-    const latestAttempt = latestMainSubmit(input.submitAttempts, input.mainWorkflowPath);
-    if (!latestAttempt)
-        return undefined;
-    const attempt = latestAttempt.success
-        ? latestAttempt
-        : shouldRecoverSavedWorkflowAfterFailedSubmit(latestAttempt)
-            ? latestSuccessfulMainSubmit(input.submitAttempts, input.mainWorkflowPath)
-            : undefined;
-    if (!attempt)
-        return undefined;
-    const errorText = input.error instanceof Error ? input.error.message : String(input.error);
-    const text = `Workflow ${attempt.workflowId} submitted successfully. A later step failed: ${errorText}`;
-    return {
-        text,
-        outcome: buildOutcome(input.workItemId, input.runId, input.taskId, attempt, text, supportingWorkflowIdsFromSubmitAttempts(input.submitAttempts, input.mainWorkflowPath, attempt.workflowId, attempt.referencedWorkflowIds)),
-    };
-}
-function resultFromTerminalRemediation(input) {
-    const latestAttempt = latestMainSubmit(input.submitAttempts, input.mainWorkflowPath);
-    const attempt = latestAttempt &&
-        !latestAttempt.success &&
-        shouldRecoverSavedWorkflowAfterFailedSubmit(latestAttempt)
-        ? (latestSuccessfulMainSubmit(input.submitAttempts, input.mainWorkflowPath) ?? latestAttempt)
-        : latestAttempt;
-    const text = input.remediation.guidance;
-    const outcome = buildOutcome(input.workItemId, input.runId, input.taskId, attempt, text, supportingWorkflowIdsFromSubmitAttempts(input.submitAttempts, input.mainWorkflowPath, attempt?.workflowId, attempt?.referencedWorkflowIds));
-    return {
-        text,
-        outcome: withDeterministicRouting({
-            ...outcome,
-            needsUserInput: outcome.needsUserInput || input.remediation.category === 'needs_setup',
-            blockingReason: input.remediation.guidance,
-            remediation: input.remediation,
-        }),
-    };
-}
-async function getWorkflowNodeSummaries(context, workflowId) {
-    if (!context || !workflowId)
-        return undefined;
-    try {
-        const json = await context.workflowService.getAsWorkflowJSON(workflowId);
-        const summaries = [];
-        for (const node of json.nodes ?? []) {
-            if (!node.name || !node.type)
-                continue;
-            summaries.push({ name: node.name, type: node.type });
-        }
-        return summaries;
-    }
-    catch {
-        return undefined;
-    }
-}
-async function getLatestBuildOutcome(context, workItemId) {
-    try {
-        return await context.workflowTaskService?.getBuildOutcome(workItemId);
-    }
-    catch {
-        return undefined;
-    }
-}
-async function compactSuccessfulBuilderMemory(input) {
-    if (!input.shouldUseBuilderMemory)
-        return;
-    try {
-        const [nodeSummaries, latestOutcome] = await Promise.all([
-            getWorkflowNodeSummaries(input.domainContext, input.workflowId),
-            getLatestBuildOutcome(input.context, input.workItemId),
-        ]);
-        await (0, builder_memory_compaction_1.compactBuilderMemoryThread)({
-            context: input.context,
-            binding: input.binding,
-            workflowId: input.workflowId,
-            workItemId: input.workItemId,
-            sourceFilePath: input.mainWorkflowPath,
-            nodeSummaries,
-            triggerNodes: input.mainWorkflowAttempt.triggerNodes,
-            mockedNodeNames: input.mainWorkflowAttempt.mockedNodeNames,
-            mockedCredentialTypes: input.mainWorkflowAttempt.mockedCredentialTypes,
-            mockedCredentialsByNode: input.mainWorkflowAttempt.mockedCredentialsByNode,
-            verification: latestOutcome?.verification,
-            lastRequestedChange: input.lastRequestedChange,
-            finalBuilderResult: input.finalText,
-        });
-    }
-    catch {
-    }
-}
-async function finalizeSuccessfulMainWorkflowSubmit(input) {
-    await promoteMainWorkflow(input.domainContext, input.context.logger, input.mainWorkflowAttempt.workflowId);
-    await compactSuccessfulBuilderMemory({
-        context: input.context,
-        binding: input.binding,
-        domainContext: input.domainContext,
-        workflowId: input.mainWorkflowAttempt.workflowId,
-        workItemId: input.workItemId,
-        mainWorkflowPath: input.mainWorkflowPath,
-        mainWorkflowAttempt: input.mainWorkflowAttempt,
-        lastRequestedChange: input.lastRequestedChange,
-        finalText: input.finalText,
-        shouldUseBuilderMemory: input.shouldUseBuilderMemory,
-    });
-    const outcome = await buildOutcomeWithLatestVerification(input.context, input.workItemId, input.taskId, input.mainWorkflowAttempt, input.finalText, supportingWorkflowIdsFromSubmitAttempts(input.submitAttemptHistory, input.mainWorkflowPath, input.mainWorkflowAttempt.workflowId, input.mainWorkflowAttempt.referencedWorkflowIds));
-    return {
-        text: input.finalText,
-        outcome,
-    };
-}
-function resultFromLaterFailedMainSubmit(input) {
-    if (!shouldRecoverSavedWorkflowAfterFailedSubmit(input.failedAttempt))
-        return undefined;
-    const preservedAttempt = latestSuccessfulMainSubmit(input.submitAttempts, input.mainWorkflowPath);
-    if (!preservedAttempt)
-        return undefined;
-    const errorText = input.failedAttempt.errors?.join(' ') ?? 'Unknown submit-workflow failure.';
-    const text = `Workflow ${preservedAttempt.workflowId} was already submitted successfully. ` +
-        `A later submit failed: ${errorText}`;
-    return {
-        text,
-        outcome: buildOutcome(input.workItemId, input.runId, input.taskId, preservedAttempt, text, supportingWorkflowIdsFromSubmitAttempts(input.submitAttempts, input.mainWorkflowPath, preservedAttempt.workflowId, preservedAttempt.referencedWorkflowIds)),
-    };
-}
-function isFreshAttemptForHash(attempt, sourceHash) {
-    return attempt?.sourceHash === sourceHash;
-}
-function attemptFromAutoResubmit(input) {
-    if (isFreshAttemptForHash(input.latestAttempt, input.sourceHash)) {
-        return input.latestAttempt;
-    }
-    if (input.resubmit.success)
-        return undefined;
-    return {
-        filePath: input.filePath,
-        sourceHash: input.sourceHash,
-        success: false,
-        errors: input.resubmit.errors,
-        remediation: input.resubmit.remediation,
-    };
-}
-function shouldRecoverSavedWorkflowAfterFailedSubmit(attempt) {
-    return attempt.remediation?.shouldEdit === false;
-}
-function formatSubmitWorkflowErrors(output, fallback) {
-    const errors = output.errors?.join(' ') ?? '';
-    return errors.length > 0 ? errors : fallback;
-}
-async function settleMissingMainWorkflowSubmit(input) {
-    const currentSnapshot = createMainWorkflowSnapshot(input.currentMainWorkflow);
-    const shouldFinalSubmit = shouldFinalSubmitMainWorkflow({
-        initial: input.initialMainWorkflowSnapshot,
-        current: currentSnapshot,
-    });
-    input.context.trackTelemetry?.('Builder finished without submit', {
-        thread_id: input.context.threadId,
-        run_id: input.runId,
-        work_item_id: input.workItemId,
-        ...(input.workflowId ? { workflow_id: input.workflowId } : {}),
-        has_main_workflow_file: currentSnapshot.exists,
-        main_workflow_changed: shouldFinalSubmit,
-        final_settlement: shouldFinalSubmit
-            ? 'final_submit'
-            : input.currentMainWorkflow === null
-                ? 'missing_file'
-                : 'unchanged_file',
-    });
-    if (!shouldFinalSubmit) {
-        const text = input.currentMainWorkflow === null
-            ? 'Error: workflow builder finished without creating or submitting /src/workflow.ts.'
-            : 'Error: workflow builder finished without submitting /src/workflow.ts; the file was unchanged from the start of the run.';
-        return await reportAndFinalizeBuildResult(input.context, input.workItemId, {
-            text,
-            outcome: buildNotSubmittedOutcome(input.workItemId, input.runId, input.taskId, text),
-        });
-    }
-    if (!input.submitTool?.handler) {
-        const text = 'Error: workflow builder wrote /src/workflow.ts, but submit-workflow was unavailable for final settlement.';
-        return await reportAndFinalizeBuildResult(input.context, input.workItemId, {
-            text,
-            outcome: buildNotSubmittedOutcome(input.workItemId, input.runId, input.taskId, text, WORKFLOW_FINAL_SUBMIT_FAILED_FAILURE_SIGNATURE),
-        });
-    }
-    const attemptsBeforeFinalSubmit = input.submitAttemptHistory.length;
-    let finalSubmit;
-    try {
-        const submitInput = { filePath: input.mainWorkflowPath };
-        if (input.workflowId) {
-            submitInput.workflowId = input.workflowId;
-        }
-        finalSubmit = (await input.submitTool.handler(submitInput, {}));
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        const recordedAttempt = input.submitAttempts.get(input.mainWorkflowPath);
-        if (isFreshAttemptForHash(recordedAttempt, input.currentMainWorkflowHash)) {
-            if (recordedAttempt.success) {
-                return await input.onSuccessfulSubmit(recordedAttempt);
-            }
-            if (shouldRecoverSavedWorkflowAfterFailedSubmit(recordedAttempt)) {
-                const recovered = resultFromLaterFailedMainSubmit({
-                    failedAttempt: recordedAttempt,
-                    submitAttempts: input.submitAttemptHistory,
-                    mainWorkflowPath: input.mainWorkflowPath,
-                    workItemId: input.workItemId,
-                    runId: input.runId,
-                    taskId: input.taskId,
-                });
-                if (recovered) {
-                    return await input.onRecoveredSubmit(recovered);
-                }
-            }
-            const recordedErrors = recordedAttempt.errors?.join(' ') ?? message;
-            const text = `Error: final submit of /src/workflow.ts failed. ${recordedErrors}`;
-            return await finalizeBuildResult(input.context, input.workItemId, {
-                text,
-                outcome: buildOutcome(input.workItemId, input.runId, input.taskId, recordedAttempt, text),
-            });
-        }
-        const text = `Error: final submit of /src/workflow.ts failed before recording an attempt. ${message}`;
-        const result = {
-            text,
-            outcome: buildNotSubmittedOutcome(input.workItemId, input.runId, input.taskId, text, WORKFLOW_FINAL_SUBMIT_FAILED_FAILURE_SIGNATURE),
-        };
-        if (input.submitAttemptHistory.length === attemptsBeforeFinalSubmit) {
-            return await reportAndFinalizeBuildResult(input.context, input.workItemId, result);
-        }
-        return await finalizeBuildResult(input.context, input.workItemId, result);
-    }
-    const refreshedAttempt = attemptFromAutoResubmit({
-        latestAttempt: input.submitAttempts.get(input.mainWorkflowPath),
-        resubmit: finalSubmit,
-        filePath: input.mainWorkflowPath,
-        sourceHash: input.currentMainWorkflowHash,
-    });
-    if (finalSubmit.success && refreshedAttempt?.success) {
-        return await input.onSuccessfulSubmit(refreshedAttempt);
-    }
-    if (refreshedAttempt &&
-        !refreshedAttempt.success &&
-        shouldRecoverSavedWorkflowAfterFailedSubmit(refreshedAttempt)) {
-        const recovered = resultFromLaterFailedMainSubmit({
-            failedAttempt: refreshedAttempt,
-            submitAttempts: input.submitAttemptHistory,
-            mainWorkflowPath: input.mainWorkflowPath,
-            workItemId: input.workItemId,
-            runId: input.runId,
-            taskId: input.taskId,
-        });
-        if (recovered) {
-            return await input.onRecoveredSubmit(recovered);
-        }
-    }
-    const finalSubmitErrors = refreshedAttempt?.errors?.join(' ') ??
-        formatSubmitWorkflowErrors(finalSubmit, 'Final submit did not record a main workflow attempt.');
-    const text = `Error: final submit of /src/workflow.ts failed. ${finalSubmitErrors}`;
-    const result = {
-        text,
-        outcome: refreshedAttempt
-            ? buildOutcome(input.workItemId, input.runId, input.taskId, refreshedAttempt, text)
-            : buildNotSubmittedOutcome(input.workItemId, input.runId, input.taskId, text, WORKFLOW_FINAL_SUBMIT_FAILED_FAILURE_SIGNATURE),
-    };
-    const reportedMainAttempt = input.submitAttempts.get(input.mainWorkflowPath);
-    if (!refreshedAttempt || refreshedAttempt !== reportedMainAttempt) {
-        return await reportAndFinalizeBuildResult(input.context, input.workItemId, result);
-    }
-    return await finalizeBuildResult(input.context, input.workItemId, result);
-}
-async function startBuildWorkflowAgentTask(context, input) {
-    if (!context.spawnBackgroundTask) {
-        return {
-            result: 'Error: background task support not available.',
-            taskId: '',
-            agentId: '',
-        };
-    }
-    const spawnBackgroundTask = context.spawnBackgroundTask;
-    const sharedWorkspace = context.workspace;
-    const domainContext = context.domainContext;
-    const useSandbox = !!sharedWorkspace && !!domainContext;
-    let builderTools;
-    let prompt = build_workflow_agent_prompt_1.BUILDER_AGENT_PROMPT;
-    let credMap;
-    if (useSandbox) {
-        credMap = await (0, resolve_credentials_1.buildCredentialMap)(domainContext.credentialService);
-        const builderWorkflowsTool = createBuilderWorkflowsTool(domainContext);
-        const builderCredentialsTool = createBuilderCredentialsTool(domainContext);
-        builderTools = (0, tool_registry_1.createToolRegistry)();
-        for (const name of BUILDER_SANDBOX_TOOL_NAMES) {
-            const tool = context.domainTools.get(name);
-            if (tool) {
-                builderTools.set(name, tool);
-            }
-        }
-        builderTools.set('workflows', builderWorkflowsTool);
-        builderTools.set(credentials_tool_1.CREDENTIALS_TOOL_ID, builderCredentialsTool);
-        if (context.workflowTaskService && context.domainContext) {
-            builderTools.set('verify-built-workflow', (0, verify_built_workflow_tool_1.createVerifyBuiltWorkflowTool)(context));
-        }
-    }
-    else {
-        builderTools = (0, tool_registry_1.createToolRegistry)();
-        for (const name of BUILDER_TOOL_MODE_TOOL_NAMES) {
-            const tool = context.domainTools.get(name);
-            if (tool) {
-                builderTools.set(name, tool);
-            }
-        }
-        if (domainContext) {
-            builderTools.set('workflows', createBuilderWorkflowsTool(domainContext));
-            builderTools.set(credentials_tool_1.CREDENTIALS_TOOL_ID, createBuilderCredentialsTool(domainContext));
-        }
-        if (!builderTools.has('build-workflow')) {
-            return { result: 'Error: build-workflow tool not available.', taskId: '', agentId: '' };
-        }
-    }
-    const deterministicIds = shouldUseDeterministicBuilderIds(context)
-        ? createDeterministicBuilderIds(input)
-        : undefined;
-    const subAgentId = input.agentId ?? deterministicIds?.subAgentId ?? `agent-builder-${(0, nanoid_1.nanoid)(6)}`;
-    const taskId = input.taskId ?? deterministicIds?.taskId ?? `build-${(0, nanoid_1.nanoid)(8)}`;
-    const baseWorkItemId = input.workItemId ??
-        deterministicIds?.workItemId ??
-        (input.workflowId ? `${context.runId}:default` : `wi_${(0, nanoid_1.nanoid)(8)}`);
-    const { workflowId } = input;
-    const workItemId = baseWorkItemId;
-    const relativeMainWorkflowPath = builderWorkflowWorkspaceLayout('', workItemId).relativeMainWorkflowPath;
-    const builderThreadId = (0, node_crypto_1.randomUUID)();
-    const builderResourceId = (0, agent_persistence_1.createSubAgentResourceId)(context.threadId, 'workflow-builder');
-    const builderMemoryBinding = {
-        resource: builderResourceId,
-        thread: builderThreadId,
-    };
-    let additionalContext = '';
-    if (useSandbox && workflowId) {
-        additionalContext = `[CONTEXT: Modifying existing workflow ${workflowId}. The current code is pre-loaded in ${relativeMainWorkflowPath} — read it first, then edit. Use workflowId "${workflowId}" when calling submit-workflow.]\n\n[WORK ITEM ID: ${workItemId}]`;
-    }
-    else if (useSandbox) {
-        additionalContext = `[WORK ITEM ID: ${workItemId}]`;
-    }
-    else if (workflowId) {
-        additionalContext = `[CONTEXT: Modifying existing workflow ${workflowId}. Use workflowId "${workflowId}" when calling build-workflow.]`;
-    }
-    const runningTaskSummaries = context.getRunningTaskSummaries?.();
-    const briefing = await (0, sub_agent_briefing_1.buildSubAgentBriefing)({
-        task: input.task,
-        conversationContext: input.conversationContext,
-        additionalContext: additionalContext || undefined,
-        requirements: useSandbox ? exports.DETACHED_BUILDER_REQUIREMENTS : undefined,
-        iteration: context.iterationLog
-            ? {
-                log: context.iterationLog,
-                threadId: context.threadId,
-                taskKey: `build:${workflowId ?? 'new'}`,
-            }
-            : undefined,
-        runningTasks: runningTaskSummaries,
-    });
-    const detachedTraceFactory = (0, tracing_utils_1.createDetachedSubAgentTraceFactory)(context, {
-        agentId: subAgentId,
-        role: 'workflow-builder',
-        kind: 'builder',
-        taskId,
-        plannedTaskId: input.plannedTaskId,
-        workItemId,
-        inputs: {
-            task: input.task,
-            workflowId: input.workflowId,
-            conversationContext: input.conversationContext,
-        },
-    });
-    const createTraceContext = async () => await detachedTraceFactory();
-    const spawnOutcome = spawnBackgroundTask({
-        taskId,
-        threadId: context.threadId,
-        agentId: subAgentId,
-        role: 'workflow-builder',
-        createTraceContext,
-        plannedTaskId: input.plannedTaskId,
-        workItemId,
-        dedupeKey: {
-            role: 'workflow-builder',
-            plannedTaskId: input.plannedTaskId,
-            workflowId: input.workflowId,
-        },
-        parentCheckpointId: context.isCheckpointFollowUp === true ? context.checkpointTaskId : undefined,
-        run: async (signal, drainCorrections, waitForCorrection, { traceContext }) => await (0, tracing_utils_1.withTraceContextActor)(traceContext, async () => {
-            const submitAttempts = new Map();
-            const submitAttemptHistory = [];
-            if (useSandbox && sharedWorkspace && domainContext) {
-                let workspace = sharedWorkspace;
-                const root = await (0, sandbox_setup_1.getWorkspaceRoot)(workspace);
-                const materializedRuntimeSkills = await materializeBuilderRuntimeSkills(context, workspace, root);
-                workspace = materializedRuntimeSkills.workspace;
-                const runtimeSkills = materializedRuntimeSkills.source;
-                const builderLayout = builderWorkflowWorkspaceLayout(root, workItemId);
-                let telemetrySession;
-                let unsubscribeTelemetry;
-                try {
-                    telemetrySession = (0, template_telemetry_1.createTemplateTelemetrySession)({
-                        context,
-                        threadId: context.threadId,
-                        runId: context.runId,
-                        workItemId,
-                        userRequestExcerpt: input.task,
-                        templatesVersion: domainContext.templatesService?.getVersion() ?? null,
-                    });
-                    (0, template_telemetry_1.attachTemplateTelemetrySession)(workspace, telemetrySession);
-                    const templateToolObserver = (0, template_telemetry_1.createTypedToolObserver)(telemetrySession);
-                    unsubscribeTelemetry = context.eventBus.subscribe(context.threadId, (stored) => {
-                        if (stored.event.agentId !== subAgentId)
-                            return;
-                        templateToolObserver(stored.event);
-                    });
-                    prompt = (0, build_workflow_agent_prompt_1.createSandboxBuilderAgentPrompt)(root, {
-                        mainWorkflowPath: builderLayout.mainWorkflowPath,
-                        sourceDir: builderLayout.sourceDir,
-                        chunksDir: builderLayout.chunksDir,
-                        tsconfigPath: builderLayout.tsconfigPath,
-                    });
-                    await writeBuilderWorkspaceFile(workspace, builderLayout.tsconfigPath, renderBuilderTaskTsconfig());
-                    if (workflowId) {
-                        try {
-                            const json = await domainContext.workflowService.getAsWorkflowJSON(workflowId);
-                            const rawCode = (0, workflow_sdk_1.generateWorkflowCode)(json);
-                            const code = `${extract_code_1.SDK_IMPORT_STATEMENT}\n\n${rawCode}`;
-                            await writeBuilderWorkspaceFile(workspace, builderLayout.mainWorkflowPath, code);
-                        }
-                        catch {
-                        }
-                    }
-                    else {
-                        await writeBuilderWorkspaceFile(workspace, builderLayout.mainWorkflowPath, `${extract_code_1.SDK_IMPORT_STATEMENT}\n\n`);
-                    }
-                    const mainWorkflowPath = builderLayout.mainWorkflowPath;
-                    const initialMainWorkflowSnapshot = createMainWorkflowSnapshot(await (0, sandbox_fs_1.readFileViaSandbox)(workspace, mainWorkflowPath));
-                    builderTools.set('submit-workflow', (0, submit_workflow_identity_1.createIdentityEnforcedSubmitWorkflowTool)({
-                        context: domainContext,
-                        workspace,
-                        credentialMap: credMap,
-                        root,
-                        defaultFilePath: mainWorkflowPath,
-                        currentRunId: context.runId,
-                        getWorkflowLoopState: async () => await context.workflowTaskService?.getWorkflowLoopState(workItemId),
-                        onGuardFired: (event) => {
-                            context.trackTelemetry?.('Builder remediation guard fired', {
-                                thread_id: context.threadId,
-                                run_id: context.runId,
-                                work_item_id: workItemId,
-                                workflow_id: event.workflowId,
-                                category: event.category,
-                                attempt_count: event.attemptCount,
-                                reason: event.reason,
-                            });
-                        },
-                        onAttempt: async (attempt) => {
-                            submitAttempts.set(attempt.filePath, attempt);
-                            submitAttemptHistory.push(attempt);
-                            if (attempt.filePath !== mainWorkflowPath) {
-                                return;
-                            }
-                            if (!context.workflowTaskService) {
-                                return;
-                            }
-                            await context.workflowTaskService.reportBuildOutcome(buildOutcome(workItemId, context.runId, taskId, attempt, attempt.success
-                                ? 'Workflow submitted and ready for verification.'
-                                : (attempt.errors?.join(' ') ?? 'Workflow submission failed.')));
-                        },
-                    }));
-                    const tracedBuilderTools = (0, tracing_utils_1.traceSubAgentTools)(context, builderTools, 'workflow-builder');
-                    const runtimeWorkspaceTools = toToolRegistry(workspace.getTools());
-                    const builderMemory = getBuilderSessionMemory(context, true);
-                    const shouldUseBuilderMemory = Boolean(builderMemory);
-                    const subAgent = new agents_1.Agent('Workflow Builder Agent')
-                        .model(context.modelId)
-                        .instructions(prompt, {
-                        providerOptions: {
-                            anthropic: { cacheControl: { type: 'ephemeral' } },
-                        },
-                    })
-                        .tool((0, tool_registry_1.toolRegistryValues)(tracedBuilderTools))
-                        .checkpoint(context.checkpointStore ?? 'memory');
-                    (0, runtime_workspace_1.attachRuntimeWorkspaceCapabilities)(subAgent, { workspace, runtimeSkills });
-                    if (builderMemory) {
-                        subAgent.memory(builderMemory);
-                    }
-                    const telemetry = traceContext?.getTelemetry?.({
-                        agentRole: 'workflow-builder',
-                        functionId: 'instance-ai.subagent.workflow-builder',
-                        executionMode: 'background_subagent',
-                        metadata: { agent_id: subAgentId, task_id: taskId },
-                    });
-                    if (telemetry) {
-                        subAgent.telemetry(telemetry);
-                    }
-                    (0, langsmith_tracing_1.mergeTraceRunInputs)(traceContext?.actorRun, (0, langsmith_tracing_1.buildAgentTraceInputs)({
-                        systemPrompt: prompt,
-                        tools: tracedBuilderTools,
-                        runtimeTools: runtimeWorkspaceTools,
-                        runtimeSkills: runtimeSkills?.registry,
-                        modelId: context.modelId,
-                    }));
-                    let finalText;
-                    try {
-                        const persistence = await (0, agent_persistence_1.createSubAgentPersistence)(context, {
-                            agentKind: 'workflow-builder',
-                            threadId: builderThreadId,
-                            resourceId: builderResourceId,
-                        });
-                        const resumeOptions = {
-                            providerOptions: {
-                                anthropic: { cacheControl: { type: 'ephemeral' } },
-                            },
-                        };
-                        const stream = await subAgent.stream(briefing, {
-                            maxIterations: max_steps_1.MAX_STEPS.BUILDER,
-                            abortSignal: signal,
-                            persistence,
-                            providerOptions: {
-                                anthropic: { cacheControl: { type: 'ephemeral' } },
-                            },
-                        });
-                        const hitlResult = await (0, consume_with_hitl_1.consumeStreamWithHitl)({
-                            agent: subAgent,
-                            stream,
-                            runId: context.runId,
-                            agentId: subAgentId,
-                            eventBus: context.eventBus,
-                            logger: context.logger,
-                            threadId: context.threadId,
-                            abortSignal: signal,
-                            waitForConfirmation: context.waitForConfirmation,
-                            drainCorrections,
-                            waitForCorrection,
-                            maxIterations: max_steps_1.MAX_STEPS.BUILDER,
-                            resumeOptions,
-                            persistence,
-                        });
-                        finalText = await (0, consume_with_hitl_1.requireCompletedHitlText)(hitlResult, 'Workflow builder sub-agent');
-                    }
-                    catch (error) {
-                        const recovered = resultFromPostStreamError({
-                            error,
-                            submitAttempts: submitAttemptHistory,
-                            mainWorkflowPath,
-                            workItemId,
-                            runId: context.runId,
-                            taskId,
-                        });
-                        if (recovered) {
-                            await promoteMainWorkflow(domainContext, context.logger, recovered.outcome.workflowId);
-                            return await finalizeBuildResult(context, workItemId, recovered);
-                        }
-                        throw error;
-                    }
-                    const mainWorkflowAttempt = submitAttempts.get(mainWorkflowPath);
-                    const currentMainWorkflow = await (0, sandbox_fs_1.readFileViaSandbox)(workspace, mainWorkflowPath);
-                    const currentMainWorkflowHash = hashContent(currentMainWorkflow);
-                    if (!mainWorkflowAttempt) {
-                        return await settleMissingMainWorkflowSubmit({
-                            context,
-                            workItemId,
-                            runId: context.runId,
-                            taskId,
-                            workflowId,
-                            mainWorkflowPath,
-                            initialMainWorkflowSnapshot,
-                            currentMainWorkflow,
-                            currentMainWorkflowHash,
-                            submitTool: tracedBuilderTools.get('submit-workflow'),
-                            submitAttempts,
-                            submitAttemptHistory,
-                            finalText,
-                            onSuccessfulSubmit: async (attempt) => await finalizeSuccessfulMainWorkflowSubmit({
-                                context,
-                                binding: builderMemoryBinding,
-                                domainContext,
-                                workItemId,
-                                taskId,
-                                mainWorkflowPath,
-                                mainWorkflowAttempt: attempt,
-                                submitAttemptHistory,
-                                lastRequestedChange: input.task,
-                                finalText,
-                                shouldUseBuilderMemory,
-                            }),
-                            onRecoveredSubmit: async (recovered) => {
-                                await promoteMainWorkflow(domainContext, context.logger, recovered.outcome.workflowId);
-                                return await finalizeBuildResult(context, workItemId, recovered);
-                            },
-                        });
-                    }
-                    if (!mainWorkflowAttempt.success) {
-                        const recovered = resultFromLaterFailedMainSubmit({
-                            failedAttempt: mainWorkflowAttempt,
-                            submitAttempts: submitAttemptHistory,
-                            mainWorkflowPath,
-                            workItemId,
-                            runId: context.runId,
-                            taskId,
-                        });
-                        if (recovered) {
-                            await promoteMainWorkflow(domainContext, context.logger, recovered.outcome.workflowId);
-                            return await finalizeBuildResult(context, workItemId, recovered);
-                        }
-                        const errorText = mainWorkflowAttempt.errors?.join(' ') ?? 'Unknown submit-workflow failure.';
-                        const text = `Error: workflow builder stopped after a failed submit-workflow for ${mainWorkflowPath}. ${errorText}`;
-                        return {
-                            text,
-                            outcome: buildOutcome(workItemId, context.runId, taskId, mainWorkflowAttempt, text),
-                        };
-                    }
-                    if (mainWorkflowAttempt.sourceHash !== currentMainWorkflowHash) {
-                        const submitTool = tracedBuilderTools.get('submit-workflow');
-                        if (submitTool?.handler) {
-                            const resubmit = (await submitTool.handler({
-                                filePath: mainWorkflowPath,
-                                workflowId: mainWorkflowAttempt.workflowId,
-                            }, {}));
-                            const refreshedAttempt = attemptFromAutoResubmit({
-                                latestAttempt: submitAttempts.get(mainWorkflowPath),
-                                resubmit,
-                                filePath: mainWorkflowPath,
-                                sourceHash: currentMainWorkflowHash,
-                            });
-                            if (resubmit.success && refreshedAttempt?.success) {
-                                await promoteMainWorkflow(domainContext, context.logger, refreshedAttempt.workflowId);
-                                await compactSuccessfulBuilderMemory({
-                                    context,
-                                    binding: builderMemoryBinding,
-                                    domainContext,
-                                    workflowId: refreshedAttempt.workflowId,
-                                    workItemId,
-                                    mainWorkflowPath,
-                                    mainWorkflowAttempt: refreshedAttempt,
-                                    lastRequestedChange: input.task,
-                                    finalText,
-                                    shouldUseBuilderMemory,
-                                });
-                                const outcome = await buildOutcomeWithLatestVerification(context, workItemId, taskId, refreshedAttempt, finalText);
-                                return {
-                                    text: finalText,
-                                    outcome,
-                                };
-                            }
-                            const resubmitErrors = refreshedAttempt?.errors?.join(' ') ??
-                                formatSubmitWorkflowErrors(resubmit, 'Auto-re-submit failed.');
-                            if (refreshedAttempt &&
-                                !refreshedAttempt.success &&
-                                shouldRecoverSavedWorkflowAfterFailedSubmit(refreshedAttempt)) {
-                                const recovered = resultFromLaterFailedMainSubmit({
-                                    failedAttempt: refreshedAttempt,
-                                    submitAttempts: submitAttemptHistory,
-                                    mainWorkflowPath,
-                                    workItemId,
-                                    runId: context.runId,
-                                    taskId,
-                                });
-                                if (recovered) {
-                                    await promoteMainWorkflow(domainContext, context.logger, recovered.outcome.workflowId);
-                                    return await finalizeBuildResult(context, workItemId, recovered);
-                                }
-                            }
-                            const text = `Error: auto-re-submit of edited ${mainWorkflowPath} failed. ${resubmitErrors}`;
-                            return {
-                                text,
-                                outcome: buildOutcome(workItemId, context.runId, taskId, refreshedAttempt ?? undefined, text),
-                            };
-                        }
-                    }
-                    await promoteMainWorkflow(domainContext, context.logger, mainWorkflowAttempt.workflowId);
-                    await compactSuccessfulBuilderMemory({
-                        context,
-                        binding: builderMemoryBinding,
-                        domainContext,
-                        workflowId: mainWorkflowAttempt.workflowId,
-                        workItemId,
-                        mainWorkflowPath,
-                        mainWorkflowAttempt,
-                        lastRequestedChange: input.task,
-                        finalText,
-                        shouldUseBuilderMemory,
-                    });
-                    const outcome = await buildOutcomeWithLatestVerification(context, workItemId, taskId, mainWorkflowAttempt, finalText);
-                    return {
-                        text: finalText,
-                        outcome,
-                    };
-                }
-                finally {
-                    unsubscribeTelemetry?.();
-                    if (telemetrySession) {
-                        try {
-                            telemetrySession.flush();
-                            (0, template_telemetry_1.detachTemplateTelemetrySession)(workspace);
-                        }
-                        catch (error) {
-                            context.logger.warn('build-workflow-agent: failed to flush template telemetry', {
-                                error: error instanceof Error ? error.message : String(error),
-                            });
-                        }
-                    }
-                }
-            }
-            let fallbackMainWorkflowId;
-            recordSuccessfulWorkflowBuilds(builderTools.get('build-workflow'), (workflowId) => {
-                fallbackMainWorkflowId = workflowId;
-            });
-            const tracedBuilderTools = (0, tracing_utils_1.traceSubAgentTools)(context, builderTools, 'workflow-builder');
-            const runtimeSkills = context.runtimeSkills;
-            const subAgent = new agents_1.Agent('Workflow Builder Agent')
-                .model(context.modelId)
-                .instructions(prompt, {
-                providerOptions: {
-                    anthropic: { cacheControl: { type: 'ephemeral' } },
-                },
-            })
-                .tool((0, tool_registry_1.toolRegistryValues)(tracedBuilderTools))
-                .checkpoint(context.checkpointStore ?? 'memory');
-            (0, runtime_workspace_1.attachRuntimeWorkspaceCapabilities)(subAgent, { runtimeSkills });
-            const telemetry = traceContext?.getTelemetry?.({
-                agentRole: 'workflow-builder',
-                functionId: 'instance-ai.subagent.workflow-builder',
-                executionMode: 'background_subagent',
-                metadata: { agent_id: subAgentId, task_id: taskId },
-            });
-            if (telemetry) {
-                subAgent.telemetry(telemetry);
-            }
-            (0, langsmith_tracing_1.mergeTraceRunInputs)(traceContext?.actorRun, (0, langsmith_tracing_1.buildAgentTraceInputs)({
-                systemPrompt: prompt,
-                tools: tracedBuilderTools,
-                runtimeSkills: runtimeSkills?.registry,
-                modelId: context.modelId,
-            }));
-            const resumeOptions = {
-                providerOptions: {
-                    anthropic: { cacheControl: { type: 'ephemeral' } },
-                },
-            };
-            const persistence = await (0, agent_persistence_1.createSubAgentPersistence)(context, {
-                agentKind: 'workflow-builder',
-                threadId: builderThreadId,
-                resourceId: builderResourceId,
-            });
-            const stream = await subAgent.stream(briefing, {
-                maxIterations: max_steps_1.MAX_STEPS.BUILDER,
-                abortSignal: signal,
-                persistence,
-                providerOptions: {
-                    anthropic: { cacheControl: { type: 'ephemeral' } },
-                },
-            });
-            const hitlResult = await (0, consume_with_hitl_1.consumeStreamWithHitl)({
-                agent: subAgent,
-                stream,
-                runId: context.runId,
-                agentId: subAgentId,
-                eventBus: context.eventBus,
-                logger: context.logger,
-                threadId: context.threadId,
-                abortSignal: signal,
-                waitForConfirmation: context.waitForConfirmation,
-                drainCorrections,
-                waitForCorrection,
-                maxIterations: max_steps_1.MAX_STEPS.BUILDER,
-                resumeOptions,
-                persistence,
-            });
-            const toolFinalText = await (0, consume_with_hitl_1.requireCompletedHitlText)(hitlResult, 'Workflow builder sub-agent');
-            await promoteMainWorkflow(domainContext, context.logger, fallbackMainWorkflowId);
-            return { text: toolFinalText };
-        }),
-    });
-    if (spawnOutcome.status === 'duplicate') {
-        return {
-            result: `Workflow build already in progress (task: ${spawnOutcome.existing.taskId}). Acknowledge and wait for the planned-task-follow-up — do not dispatch again.`,
-            taskId: spawnOutcome.existing.taskId,
-            agentId: spawnOutcome.existing.agentId,
-        };
-    }
-    if (spawnOutcome.status === 'limit-reached') {
-        return {
-            result: 'Could not start build: concurrent background-task limit reached. Wait for an existing task to finish and try again.',
-            taskId: '',
-            agentId: '',
-        };
-    }
-    context.eventBus.publish(context.threadId, {
-        type: 'agent-spawned',
-        runId: context.runId,
-        agentId: subAgentId,
-        payload: {
-            parentId: context.orchestratorAgentId,
-            role: 'workflow-builder',
-            tools: (0, tool_registry_1.toolRegistryKeys)(builderTools),
-            taskId,
-            kind: 'builder',
-            title: 'Building workflow',
-            subtitle: (0, display_utils_1.truncateLabel)(input.task),
-            goal: input.task,
-            targetResource: input.workflowId
-                ? { type: 'workflow', id: input.workflowId }
-                : { type: 'workflow' },
-        },
-    });
-    return {
-        result: `Workflow build started (task: ${taskId}). Reply with one short sentence — e.g. name what's being built. Do NOT summarize the plan or list details.`,
-        taskId,
-        agentId: subAgentId,
-    };
-}
-exports.buildWorkflowAgentInputSchema = zod_1.z.object({
-    task: zod_1.z
-        .string()
-        .describe('What to build and any context: user requirements, available credential names/types.'),
-    workflowId: zod_1.z
-        .string()
-        .optional()
-        .describe('Existing workflow ID to modify. When provided, the agent starts with the current workflow code pre-loaded.'),
-    conversationContext: zod_1.z
-        .string()
-        .optional()
-        .describe('Brief summary of the conversation so far — what was discussed, decisions made, and information gathered (e.g., which credentials are available). The builder uses this to avoid repeating information the user already knows.'),
-    workItemId: zod_1.z
-        .string()
-        .optional()
-        .describe('Workflow-loop work item ID. Required for repair builds so remediation budgets continue on the same work item.'),
-    bypassPlan: zod_1.z
-        .boolean()
-        .optional()
-        .describe('Set to true for any edit to an existing workflow — adding/removing/rewiring a node, changing an expression, swapping a credential, changing a schedule, fixing a Code node. Requires an existing `workflowId` and a one-sentence `reason`. The orchestrator verifies the result afterwards via `verify-built-workflow` when the trigger is mockable. ' +
-        'A runtime guard rejects direct calls without `bypassPlan: true` outside replan/checkpoint follow-ups: new workflow builds, multi-workflow work, and data-table schema changes must go through `plan` so the build gets its orchestrator-run checkpoint.'),
-    reason: zod_1.z
-        .string()
-        .optional()
-        .describe('One sentence explaining why the planner is being bypassed (e.g. "swap Slack channel on workflow X", "fix Code node shape issue"). Required when bypassPlan is true.'),
-});
-const buildWorkflowAgentSuspendSchema = zod_1.z.object({
-    requestId: zod_1.z.string(),
-    message: zod_1.z.string(),
-    severity: zod_1.z.literal('warning'),
-});
-const buildWorkflowAgentResumeSchema = zod_1.z.object({
-    approved: zod_1.z.boolean(),
-});
-function isPostPlanFollowUp(context) {
-    return context.isReplanFollowUp === true || context.isCheckpointFollowUp === true;
-}
-function isBuildViaPlanGuardEnabled() {
-    const raw = process.env.N8N_INSTANCE_AI_ENFORCE_BUILD_VIA_PLAN;
-    if (raw === undefined)
-        return true;
-    return raw.toLowerCase() !== 'false' && raw !== '0';
-}
-const PLAN_GUARD_REJECTION_LIMIT = 3;
-async function resolveWorkflowNameForEditConfirmation(context, workflowId) {
-    try {
-        const workflow = await context.domainContext?.workflowService.get(workflowId);
-        const workflowName = workflow?.name?.trim();
-        return workflowName && workflowName.length > 0 ? workflowName : workflowId;
-    }
-    catch {
-        return workflowId;
-    }
-}
-function createBuildWorkflowAgentTool(context) {
-    let planGuardRejectionCount = 0;
-    const rejectPlanGuardCall = (result) => {
-        planGuardRejectionCount++;
-        if (planGuardRejectionCount >= PLAN_GUARD_REJECTION_LIMIT) {
-            context.logger.warn('build-workflow-with-agent plan-guard rejection limit reached — aborting run', {
-                threadId: context.threadId,
-                rejectionCount: planGuardRejectionCount,
-            });
-            throw new n8n_workflow_1.UserError('Stopped: the agent looped on `build-workflow-with-agent` rejections without correcting them. Try again or rephrase the request.');
-        }
-        return { result, taskId: '' };
-    };
-    return new agents_1.Tool('build-workflow-with-agent')
-        .description('Build or modify an n8n workflow using a specialized builder agent. ' +
-        'The agent handles node discovery, schema lookups, code generation, and validation internally. ' +
-        'For edits to an existing workflow, call directly with `bypassPlan: true`, the existing `workflowId`, and a one-sentence `reason` — the orchestrator runs a lightweight verify afterwards. ' +
-        'For new workflows, multi-workflow builds, or data-table schema changes, go through `plan` — ' +
-        'a runtime guard rejects direct calls without `bypassPlan: true` outside replan/checkpoint follow-ups, because those paths need the orchestrator-run checkpoint for end-to-end verification.')
-        .input(exports.buildWorkflowAgentInputSchema)
-        .output(zod_1.z.object({
-        result: zod_1.z.string(),
-        taskId: zod_1.z.string(),
-    }))
-        .suspend(buildWorkflowAgentSuspendSchema)
-        .resume(buildWorkflowAgentResumeSchema)
-        .handler(async (input, ctx) => {
-        const isPostPlanFollowUpRun = isPostPlanFollowUp(context);
-        if (isBuildViaPlanGuardEnabled() && !isPostPlanFollowUpRun) {
-            if (!input.bypassPlan) {
-                context.logger.warn('build-workflow-with-agent called outside plan/replan context — rejecting', {
-                    threadId: context.threadId,
-                    hasWorkflowId: Boolean(input.workflowId),
-                });
-                return rejectPlanGuardCall('STOP. Direct builder calls require `bypassPlan: true` + an existing ' +
-                    '`workflowId` + a one-sentence `reason`. Use that combination for any edit to ' +
-                    'an existing workflow. For new workflows, multi-workflow builds, or data-table ' +
-                    'schema changes, call `plan` with a `build-workflow` task instead — the planner ' +
-                    'discovers credentials, data tables, and best practices, and schedules an ' +
-                    'orchestrator-run verification checkpoint.');
-            }
-            if (!input.workflowId) {
-                return rejectPlanGuardCall('STOP. `bypassPlan: true` is for edits to an EXISTING workflow and requires a ' +
-                    '`workflowId`. New workflow builds must go through `plan` so an orchestrator-run ' +
-                    'verification checkpoint is scheduled. Call `plan` with a `build-workflow` task ' +
-                    'instead.');
-            }
-            if (!input.reason || input.reason.trim().length === 0) {
-                return rejectPlanGuardCall('STOP. `bypassPlan: true` requires a one-sentence `reason` describing the edit ' +
-                    '(e.g. "swap Slack channel", "fix Code node shape issue").');
-            }
-            context.logger.warn('build-workflow-with-agent bypassing plan with bypassPlan=true', {
-                threadId: context.threadId,
-                workflowId: input.workflowId,
-                reason: input.reason,
-            });
-        }
-        planGuardRejectionCount = 0;
-        if (input.workflowId && !isPostPlanFollowUpRun && context.domainContext) {
-            const updateWorkflowPermission = context.domainContext.permissions?.updateWorkflow ?? 'require_approval';
-            if (updateWorkflowPermission === 'blocked') {
-                return { result: 'Action blocked by admin', taskId: '' };
-            }
-            const isOwnInFlightWorkflow = context.domainContext.aiCreatedWorkflowIds?.has(input.workflowId) ?? false;
-            if (!isOwnInFlightWorkflow) {
-                const resumeData = ctx.resumeData;
-                const needsApproval = updateWorkflowPermission !== 'always_allow';
-                if (needsApproval && (resumeData === undefined || resumeData === null)) {
-                    const workflowName = await resolveWorkflowNameForEditConfirmation(context, input.workflowId);
-                    return await ctx.suspend({
-                        requestId: (0, nanoid_1.nanoid)(),
-                        message: `Edit ${workflowName} (ID: ${input.workflowId})`,
-                        severity: 'warning',
-                    });
-                }
-                if (resumeData !== undefined && resumeData !== null && !resumeData.approved) {
-                    return { result: 'User declined the workflow edit.', taskId: '' };
-                }
-            }
-        }
-        const result = await startBuildWorkflowAgentTask(context, input);
-        return { result: result.result, taskId: result.taskId };
-    })
-        .build();
-}
-//# sourceMappingURL=build-workflow-agent.tool.js.map