@n8n/instance-ai 1.7.2 → 1.8.1

package/dist/tools/orchestration/browser-credential-setup.tool.js

@@ -1,29 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.browserCredentialSetupResumeSchema = exports.browserCredentialSetupInputSchema = exports.buildBrowserAgentPrompt = void 0;
+exports.browserCredentialSetupResumeSchema = exports.browserCredentialSetupInputSchema = exports.__testWrapBrowserToolsForDenialDetection = exports.__testHasPermanentBrowserDenial = exports.__testIsPermanentDenialResult = exports.buildBrowserAgentPrompt = void 0;
 exports.createBrowserCredentialSetupTool = createBrowserCredentialSetupTool;
-const agent_1 = require("@mastra/core/agent");
-const tools_1 = require("@mastra/core/tools");
+const agents_1 = require("@n8n/agents");
 const api_types_1 = require("@n8n/api-types");
 const nanoid_1 = require("nanoid");
 const zod_1 = require("zod");
+const agent_persistence_1 = require("./agent-persistence");
 const browser_credential_setup_nudge_1 = require("./browser-credential-setup.nudge");
 const browser_credential_setup_prompt_1 = require("./browser-credential-setup.prompt");
 const tracing_utils_1 = require("./tracing-utils");
-const register_with_mastra_1 = require("../../agent/register-with-mastra");
+const runtime_workspace_1 = require("../../agent/runtime-workspace");
 const max_steps_1 = require("../../constants/max-steps");
 const resumable_stream_executor_1 = require("../../runtime/resumable-stream-executor");
+const tool_registry_1 = require("../../tool-registry");
 const langsmith_tracing_1 = require("../../tracing/langsmith-tracing");
 const create_tools_from_mcp_server_1 = require("../filesystem/create-tools-from-mcp-server");
 const research_tool_1 = require("../research.tool");
 const ask_user_tool_1 = require("../shared/ask-user.tool");
 var browser_credential_setup_prompt_2 = require("./browser-credential-setup.prompt");
 Object.defineProperty(exports, "buildBrowserAgentPrompt", { enumerable: true, get: function () { return browser_credential_setup_prompt_2.buildBrowserAgentPrompt; } });
+const BROWSER_CREDENTIAL_AGENT_ROLE = 'credential-setup-browser-agent';
 const PERMANENT_DENIAL_MARKER = 'User permanently denied access to';
 const BROWSER_DENIED_RESULT = 'Browser access was denied by the user. Provide manual setup guidance in chat — do not try the browser flow again in this turn.';
 const browserToolErrorResultSchema = zod_1.z.object({
     isError: zod_1.z.literal(true),
-    structuredContent: zod_1.z.object({ error: zod_1.z.string().optional() }).optional(),
+    structuredContent: zod_1.z.object({ error: zod_1.z.string().optional() }).passthrough().optional(),
     content: zod_1.z.array(zod_1.z.object({ text: zod_1.z.string() }).passthrough()).optional(),
 });
 function isPermanentDenialResult(result) {
@@ -34,58 +36,74 @@ function isPermanentDenialResult(result) {
         parsed.data.structuredContent?.error ?? '',
         ...(parsed.data.content?.map((c) => c.text) ?? []),
     ];
-    return messages.some((m) => m.includes(PERMANENT_DENIAL_MARKER));
+    return messages.some((message) => message.includes(PERMANENT_DENIAL_MARKER));
+}
+function isPermanentDenialError(error) {
+    return error instanceof Error && error.message.includes(PERMANENT_DENIAL_MARKER);
+}
+function hasPermanentBrowserDenial(workSummary) {
+    return workSummary.toolCalls.some((toolCall) => toolCall.toolName.startsWith('browser_') &&
+        toolCall.errorSummary?.includes(PERMANENT_DENIAL_MARKER) === true);
 }
 function wrapToolForDenialDetection(tool, onDenied) {
-    const originalExecute = tool.execute;
-    if (!originalExecute)
+    const originalHandler = tool.handler;
+    if (!originalHandler)
         return tool;
-    const observingExecute = async (input, ctx) => {
-        const result = await originalExecute(input, ctx);
-        if (isPermanentDenialResult(result))
-            onDenied();
-        return result;
+    return {
+        ...tool,
+        handler: async (input, ctx) => {
+            try {
+                const result = await originalHandler(input, ctx);
+                if (isPermanentDenialResult(result))
+                    onDenied();
+                return result;
+            }
+            catch (error) {
+                if (isPermanentDenialError(error))
+                    onDenied();
+                throw error;
+            }
+        },
     };
-    return { ...tool, execute: observingExecute };
 }
 function wrapBrowserToolsForDenialDetection(tools, onDenied) {
-    const wrapped = {};
-    for (const [name, tool] of Object.entries(tools)) {
-        wrapped[name] = name.startsWith('browser_') ? wrapToolForDenialDetection(tool, onDenied) : tool;
+    const wrapped = (0, tool_registry_1.createToolRegistry)();
+    for (const [name, tool] of tools) {
+        wrapped.set(name, name.startsWith('browser_') ? wrapToolForDenialDetection(tool, onDenied) : tool);
     }
     return wrapped;
 }
+exports.__testIsPermanentDenialResult = isPermanentDenialResult;
+exports.__testHasPermanentBrowserDenial = hasPermanentBrowserDenial;
+exports.__testWrapBrowserToolsForDenialDetection = wrapBrowserToolsForDenialDetection;
 function createPauseForUserTool() {
-    return (0, tools_1.createTool)({
-        id: 'pause-for-user',
-        description: 'Pause and wait for the user to complete an action in the browser (e.g., sign in, ' +
-            'complete 2FA, click a button, enter values privately into n8n, download files). The user sees a message and confirms when done.',
-        inputSchema: exports.browserCredentialSetupInputSchema,
-        outputSchema: zod_1.z.object({
-            continued: zod_1.z.boolean(),
-        }),
-        suspendSchema: zod_1.z.object({
-            requestId: zod_1.z.string(),
-            message: zod_1.z.string(),
-            severity: api_types_1.instanceAiConfirmationSeveritySchema,
-            inputType: zod_1.z.literal('continue'),
-        }),
-        resumeSchema: exports.browserCredentialSetupResumeSchema,
-        execute: async (input, ctx) => {
-            const resumeData = ctx?.agent?.resumeData;
-            const suspend = ctx?.agent?.suspend;
-            if (resumeData === undefined || resumeData === null) {
-                await suspend?.({
-                    requestId: (0, nanoid_1.nanoid)(),
-                    message: input.message,
-                    severity: 'info',
-                    inputType: 'continue',
-                });
-                return { continued: false };
-            }
-            return { continued: resumeData.approved };
-        },
-    });
+    return new agents_1.Tool('pause-for-user')
+        .description('Pause and wait for the user to complete an action in the browser (e.g., sign in, ' +
+        'complete 2FA, click a button, enter values privately into n8n, download files). The user sees a message and confirms when done.')
+        .input(exports.browserCredentialSetupInputSchema)
+        .output(zod_1.z.object({
+        continued: zod_1.z.boolean(),
+    }))
+        .suspend(zod_1.z.object({
+        requestId: zod_1.z.string(),
+        message: zod_1.z.string(),
+        severity: api_types_1.instanceAiConfirmationSeveritySchema,
+        inputType: zod_1.z.literal('continue'),
+    }))
+        .resume(exports.browserCredentialSetupResumeSchema)
+        .handler(async (input, ctx) => {
+        const resumeData = ctx.resumeData;
+        if (resumeData === undefined || resumeData === null) {
+            return await ctx.suspend({
+                requestId: (0, nanoid_1.nanoid)(),
+                message: input.message,
+                severity: 'info',
+                inputType: 'continue',
+            });
+        }
+        return { continued: resumeData.approved };
+    })
+        .build();
 }
 exports.browserCredentialSetupInputSchema = zod_1.z.object({
     message: zod_1.z.string().describe('What the user needs to do (shown in the chat UI)'),
@@ -107,242 +125,253 @@ const browserCredentialSetupToolInputSchema = zod_1.z.object({
         .optional()
         .describe('Credential fields the user needs to obtain from the service'),
 });
+function buildCredentialSetupBriefing(input, context) {
+    const docsLine = input.docsUrl
+        ? `**Documentation:** ${input.docsUrl}`
+        : '**Documentation:** No URL available — use `research` (action: web-search) to find setup instructions.';
+    let fieldsSection = '';
+    if (input.requiredFields && input.requiredFields.length > 0) {
+        const fieldLines = input.requiredFields.map((field) => `- ${field.displayName} (${field.name})${field.required ? ' [REQUIRED]' : ''}${field.description ? ': ' + field.description : ''}`);
+        fieldsSection = `\n### Required Fields\n${fieldLines.join('\n')}`;
+    }
+    const isOAuth = input.credentialType.toLowerCase().includes('oauth');
+    const oauthSection = isOAuth && context.oauth2CallbackUrl
+        ? `\n### OAuth Redirect URL\n${context.oauth2CallbackUrl}\n` +
+            'Paste this into the "Authorized redirect URIs" field. ' +
+            'Do NOT navigate to the n8n instance to find it — use this URL directly.'
+        : '';
+    return [
+        `## Credential Setup: ${input.credentialType}`,
+        '',
+        docsLine,
+        fieldsSection,
+        oauthSection,
+        '',
+        '### Completion Criteria',
+        'Done ONLY when all required values are visible on screen or downloaded, and you have called `pause-for-user` telling the user where to find them and to enter them privately in n8n.',
+    ]
+        .filter(Boolean)
+        .join('\n');
+}
 function createBrowserCredentialSetupTool(context) {
-    return (0, tools_1.createTool)({
-        id: 'browser-credential-setup',
-        description: 'Run a browser agent that navigates to credential documentation and helps the user ' +
-            'set up a credential on the external service. The browser is visible to the user. ' +
-            'The agent can pause for user interaction (sign-in, 2FA, etc.).',
-        inputSchema: browserCredentialSetupToolInputSchema,
-        outputSchema: zod_1.z.object({
-            result: zod_1.z.string(),
-        }),
-        execute: async (input) => {
-            const browserTools = {};
-            let toolSource;
-            const gatewayBrowserTools = context.localMcpServer?.getToolsByCategory('browser') ?? [];
-            if (gatewayBrowserTools.length > 0 && context.localMcpServer) {
-                const gatewayBrowserNames = new Set(gatewayBrowserTools.map((t) => t.name));
-                const allGatewayTools = (0, create_tools_from_mcp_server_1.createToolsFromLocalMcpServer)(context.localMcpServer, context.logger);
-                for (const [name, tool] of Object.entries(allGatewayTools)) {
-                    if (gatewayBrowserNames.has(name)) {
-                        browserTools[name] = tool;
-                    }
-                }
-                toolSource = 'gateway';
-            }
-            else if (context.browserMcpConfig) {
-                const mcpTools = context.mcpTools ?? {};
-                for (const [name, tool] of Object.entries(mcpTools)) {
-                    browserTools[name] = tool;
+    return new agents_1.Tool('browser-credential-setup')
+        .description('Run a browser agent that navigates to credential documentation and helps the user ' +
+        'set up a credential on the external service. The browser is visible to the user. ' +
+        'The agent can pause for user interaction (sign-in, 2FA, etc.).')
+        .input(browserCredentialSetupToolInputSchema)
+        .output(zod_1.z.object({
+        result: zod_1.z.string(),
+    }))
+        .handler(async (input) => {
+        await Promise.resolve();
+        const browserTools = (0, tool_registry_1.createToolRegistry)();
+        let toolSource;
+        const gatewayBrowserTools = context.localMcpServer?.getToolsByCategory('browser') ?? [];
+        if (gatewayBrowserTools.length > 0 && context.localMcpServer) {
+            const gatewayBrowserNames = new Set(gatewayBrowserTools.map((t) => t.name));
+            const allGatewayTools = (0, create_tools_from_mcp_server_1.createToolsFromLocalMcpServer)(context.localMcpServer, context.logger);
+            for (const [name, tool] of allGatewayTools) {
+                if (gatewayBrowserNames.has(name)) {
+                    browserTools.set(name, tool);
                 }
-                toolSource = 'chrome-devtools-mcp';
             }
-            else {
-                return {
-                    result: 'Browser automation is not available. Either connect a local gateway with browser tools or set N8N_INSTANCE_AI_BROWSER_MCP=true.',
-                };
+            toolSource = 'gateway';
+        }
+        else if (context.browserMcpConfig) {
+            const mcpTools = context.mcpTools ?? (0, tool_registry_1.createToolRegistry)();
+            for (const [name, tool] of mcpTools) {
+                browserTools.set(name, tool);
             }
-            if (Object.keys(browserTools).length === 0) {
-                return {
-                    result: toolSource === 'gateway'
-                        ? 'Local gateway is connected but no browser_* tools are available. Ensure the browser module is enabled in the gateway.'
-                        : 'No browser MCP tools available. Chrome DevTools MCP may not be connected.',
-                };
-            }
-            let browserPermanentlyDenied = false;
-            const browserToolsWithDenialDetection = wrapBrowserToolsForDenialDetection(browserTools, () => {
-                browserPermanentlyDenied = true;
-            });
-            browserToolsWithDenialDetection['pause-for-user'] = createPauseForUserTool();
-            browserToolsWithDenialDetection['ask-user'] = (0, ask_user_tool_1.createAskUserTool)();
-            if (context.domainContext) {
-                browserToolsWithDenialDetection.research = (0, research_tool_1.createResearchTool)(context.domainContext);
-            }
-            const subAgentId = `agent-browser-${(0, nanoid_1.nanoid)(6)}`;
-            context.eventBus.publish(context.threadId, {
-                type: 'agent-spawned',
-                runId: context.runId,
-                agentId: subAgentId,
-                payload: {
-                    parentId: context.orchestratorAgentId,
-                    role: 'credential-setup-browser-agent',
-                    tools: Object.keys(browserToolsWithDenialDetection),
-                },
-            });
-            let traceRun;
-            try {
-                traceRun = await (0, tracing_utils_1.startSubAgentTrace)(context, {
-                    agentId: subAgentId,
-                    role: 'credential-setup-browser-agent',
-                    kind: 'browser-credential-setup',
-                    inputs: {
-                        credentialType: input.credentialType,
-                        docsUrl: input.docsUrl,
-                        requiredFields: input.requiredFields?.map((field) => ({
-                            name: field.name,
-                            type: field.type,
-                            required: field.required,
-                        })),
+            toolSource = 'chrome-devtools-mcp';
+        }
+        else {
+            return {
+                result: 'Browser automation is not available. Either connect a local gateway with browser tools or set N8N_INSTANCE_AI_BROWSER_MCP=true.',
+            };
+        }
+        if (browserTools.size === 0) {
+            return {
+                result: toolSource === 'gateway'
+                    ? 'Local gateway is connected but no browser_* tools are available. Ensure the browser module is enabled in the gateway.'
+                    : 'No browser MCP tools available. Chrome DevTools MCP may not be connected.',
+            };
+        }
+        let browserPermanentlyDenied = false;
+        const browserToolsWithDenialDetection = wrapBrowserToolsForDenialDetection(browserTools, () => {
+            browserPermanentlyDenied = true;
+        });
+        browserToolsWithDenialDetection.set('pause-for-user', createPauseForUserTool());
+        browserToolsWithDenialDetection.set('ask-user', (0, ask_user_tool_1.createAskUserTool)());
+        if (context.domainContext) {
+            browserToolsWithDenialDetection.set('research', (0, research_tool_1.createResearchTool)(context.domainContext));
+        }
+        if (!context.spawnBackgroundTask) {
+            return { result: 'Browser credential setup requires background task support.' };
+        }
+        const subAgentId = `agent-browser-${(0, nanoid_1.nanoid)(6)}`;
+        const taskId = `browser-credential-${(0, nanoid_1.nanoid)(8)}`;
+        const browserPrompt = (0, browser_credential_setup_prompt_1.buildBrowserAgentPrompt)(toolSource);
+        const tracedBrowserTools = (0, tracing_utils_1.traceSubAgentTools)(context, browserToolsWithDenialDetection, BROWSER_CREDENTIAL_AGENT_ROLE);
+        const createTraceContext = (0, tracing_utils_1.createDetachedSubAgentTraceFactory)(context, {
+            agentId: subAgentId,
+            role: BROWSER_CREDENTIAL_AGENT_ROLE,
+            kind: 'browser-credential-setup',
+            taskId,
+            inputs: {
+                credentialType: input.credentialType,
+                docsUrl: input.docsUrl,
+                requiredFields: input.requiredFields?.map((field) => ({
+                    name: field.name,
+                    type: field.type,
+                    required: field.required,
+                })),
+            },
+        });
+        const spawnOutcome = context.spawnBackgroundTask({
+            taskId,
+            threadId: context.threadId,
+            agentId: subAgentId,
+            role: BROWSER_CREDENTIAL_AGENT_ROLE,
+            createTraceContext,
+            dedupeKey: { role: BROWSER_CREDENTIAL_AGENT_ROLE },
+            parentCheckpointId: context.isCheckpointFollowUp === true ? context.checkpointTaskId : undefined,
+            run: async (signal, _drainCorrections, _waitForCorrection, { traceContext }) => await (0, tracing_utils_1.withTraceContextActor)(traceContext, async () => {
+                const subAgent = new agents_1.Agent('Browser Credential Setup Agent')
+                    .model(context.modelId)
+                    .instructions(browserPrompt, {
+                    providerOptions: {
+                        anthropic: { cacheControl: { type: 'ephemeral' } },
                     },
+                })
+                    .tool((0, tool_registry_1.toolRegistryValues)(tracedBrowserTools))
+                    .checkpoint(context.checkpointStore ?? 'memory');
+                (0, runtime_workspace_1.attachRuntimeWorkspaceCapabilities)(subAgent, {
+                    runtimeSkills: context.runtimeSkills,
                 });
-                const tracedBrowserTools = (0, tracing_utils_1.traceSubAgentTools)(context, browserToolsWithDenialDetection, 'credential-setup-browser-agent');
-                const browserPrompt = (0, browser_credential_setup_prompt_1.buildBrowserAgentPrompt)(toolSource);
-                const resultText = await (0, tracing_utils_1.withTraceRun)(context, traceRun, async () => {
-                    const subAgent = new agent_1.Agent({
-                        id: subAgentId,
-                        name: 'Browser Credential Setup Agent',
-                        instructions: {
-                            role: 'system',
-                            content: browserPrompt,
-                            providerOptions: {
-                                anthropic: { cacheControl: { type: 'ephemeral' } },
+                const telemetry = traceContext?.getTelemetry?.({
+                    agentRole: BROWSER_CREDENTIAL_AGENT_ROLE,
+                    functionId: `instance-ai.subagent.${BROWSER_CREDENTIAL_AGENT_ROLE}`,
+                    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: browserPrompt,
+                    tools: tracedBrowserTools,
+                    modelId: context.modelId,
+                }));
+                const briefing = buildCredentialSetupBriefing(input, context);
+                const persistence = await (0, agent_persistence_1.createSubAgentPersistence)(context, {
+                    agentKind: 'credential-setup-browser',
+                });
+                const stream = await subAgent.stream(briefing, {
+                    maxIterations: max_steps_1.MAX_STEPS.BROWSER,
+                    abortSignal: signal,
+                    persistence,
+                    providerOptions: {
+                        anthropic: { cacheControl: { type: 'ephemeral' } },
+                    },
+                });
+                let activeStream = (0, resumable_stream_executor_1.normalizeStreamSource)(stream);
+                let activeAgentRunId = typeof activeStream.runId === 'string' ? activeStream.runId : '';
+                let lastSuspendedToolName = '';
+                const MAX_NUDGES = 3;
+                let nudgeCount = 0;
+                while (true) {
+                    const result = await (0, resumable_stream_executor_1.executeResumableStream)({
+                        agent: subAgent,
+                        stream: activeStream,
+                        initialAgentRunId: activeAgentRunId,
+                        context: {
+                            threadId: context.threadId,
+                            runId: context.runId,
+                            agentId: subAgentId,
+                            eventBus: context.eventBus,
+                            signal,
+                            logger: context.logger,
+                        },
+                        control: {
+                            mode: 'auto',
+                            buildResumeOptions: ({ agentRunId, suspension }) => ({
+                                runId: agentRunId,
+                                toolCallId: suspension.toolCallId,
+                                maxIterations: max_steps_1.MAX_STEPS.BROWSER,
+                                persistence,
+                            }),
+                            waitForConfirmation: async (requestId) => {
+                                if (!context.waitForConfirmation) {
+                                    throw new Error('Browser agent requires user interaction but no HITL handler is available');
+                                }
+                                return await context.waitForConfirmation(requestId);
+                            },
+                            onSuspension: (suspension) => {
+                                lastSuspendedToolName = suspension.toolName ?? '';
                             },
                         },
-                        model: context.modelId,
-                        tools: tracedBrowserTools,
                     });
-                    (0, langsmith_tracing_1.mergeTraceRunInputs)(traceRun, (0, langsmith_tracing_1.buildAgentTraceInputs)({
-                        systemPrompt: browserPrompt,
-                        tools: tracedBrowserTools,
-                        modelId: context.modelId,
-                    }));
-                    (0, register_with_mastra_1.registerWithMastra)(subAgentId, subAgent, context.storage);
-                    const docsLine = input.docsUrl
-                        ? `**Documentation:** ${input.docsUrl}`
-                        : '**Documentation:** No URL available — use `research` (action: web-search) to find setup instructions.';
-                    let fieldsSection = '';
-                    if (input.requiredFields && input.requiredFields.length > 0) {
-                        const fieldLines = input.requiredFields.map((f) => `- ${f.displayName} (${f.name})${f.required ? ' [REQUIRED]' : ''}${f.description ? ': ' + f.description : ''}`);
-                        fieldsSection = `\n### Required Fields\n${fieldLines.join('\n')}`;
+                    if (result.status !== 'completed') {
+                        throw new Error(result.status === 'cancelled'
+                            ? 'Browser credential setup sub-agent was cancelled'
+                            : 'Browser credential setup sub-agent failed while streaming');
+                    }
+                    if (browserPermanentlyDenied || hasPermanentBrowserDenial(result.workSummary)) {
+                        return BROWSER_DENIED_RESULT;
                     }
-                    const isOAuth = input.credentialType.toLowerCase().includes('oauth');
-                    const oauthSection = isOAuth && context.oauth2CallbackUrl
-                        ? `\n### OAuth Redirect URL\n${context.oauth2CallbackUrl}\n` +
-                            'Paste this into the "Authorized redirect URIs" field. ' +
-                            'Do NOT navigate to the n8n instance to find it — use this URL directly.'
-                        : '';
-                    const briefing = [
-                        `## Credential Setup: ${input.credentialType}`,
-                        '',
-                        docsLine,
-                        fieldsSection,
-                        oauthSection,
-                        '',
-                        '### Completion Criteria',
-                        'Done ONLY when all required values are visible on screen or downloaded, and you have called `pause-for-user` telling the user where to find them and to enter them privately in n8n.',
-                    ]
-                        .filter(Boolean)
-                        .join('\n');
-                    const traceParent = (0, langsmith_tracing_1.getTraceParentRun)();
-                    return await (0, langsmith_tracing_1.withTraceParentContext)(traceParent, async () => {
-                        const llmStepTraceHooks = (0, resumable_stream_executor_1.createLlmStepTraceHooks)(traceParent);
-                        const stream = await subAgent.stream(briefing, {
-                            maxSteps: max_steps_1.MAX_STEPS.BROWSER,
-                            abortSignal: context.abortSignal,
+                    if (lastSuspendedToolName !== 'pause-for-user' && nudgeCount < MAX_NUDGES) {
+                        nudgeCount++;
+                        const priorMessages = subAgent.getState().messageList.messages;
+                        const nudgeInput = (0, browser_credential_setup_nudge_1.buildNudgeStreamInput)(priorMessages);
+                        const nudge = await subAgent.stream(nudgeInput, {
+                            maxIterations: max_steps_1.MAX_STEPS.BROWSER,
+                            abortSignal: signal,
+                            persistence,
                             providerOptions: {
                                 anthropic: { cacheControl: { type: 'ephemeral' } },
                             },
-                            ...(llmStepTraceHooks?.executionOptions ?? {}),
                         });
-                        let activeStream = stream;
-                        let activeMastraRunId = typeof stream.runId === 'string' ? stream.runId : '';
-                        let lastSuspendedToolName = '';
-                        const MAX_NUDGES = 3;
-                        let nudgeCount = 0;
-                        while (true) {
-                            const result = await (0, resumable_stream_executor_1.executeResumableStream)({
-                                agent: subAgent,
-                                stream: activeStream,
-                                initialMastraRunId: activeMastraRunId,
-                                context: {
-                                    threadId: context.threadId,
-                                    runId: context.runId,
-                                    agentId: subAgentId,
-                                    eventBus: context.eventBus,
-                                    signal: context.abortSignal,
-                                    logger: context.logger,
-                                },
-                                control: {
-                                    mode: 'auto',
-                                    waitForConfirmation: async (requestId) => {
-                                        if (!context.waitForConfirmation) {
-                                            throw new Error('Browser agent requires user interaction but no HITL handler is available');
-                                        }
-                                        return await context.waitForConfirmation(requestId);
-                                    },
-                                    onSuspension: (suspension) => {
-                                        lastSuspendedToolName = suspension.toolName ?? '';
-                                    },
-                                },
-                                llmStepTraceHooks,
-                            });
-                            if (result.status === 'cancelled') {
-                                throw new Error('Run cancelled while waiting for confirmation');
-                            }
-                            if (browserPermanentlyDenied) {
-                                return BROWSER_DENIED_RESULT;
-                            }
-                            if (lastSuspendedToolName !== 'pause-for-user' && nudgeCount < MAX_NUDGES) {
-                                nudgeCount++;
-                                const priorMessages = activeStream.messageList.get.all.aiV5.model();
-                                const nudgeInput = (0, browser_credential_setup_nudge_1.buildNudgeStreamInput)(priorMessages);
-                                const nudge = await subAgent.stream(nudgeInput, {
-                                    maxSteps: max_steps_1.MAX_STEPS.BROWSER,
-                                    abortSignal: context.abortSignal,
-                                    providerOptions: {
-                                        anthropic: { cacheControl: { type: 'ephemeral' } },
-                                    },
-                                    ...(llmStepTraceHooks?.executionOptions ?? {}),
-                                });
-                                activeStream = nudge;
-                                activeMastraRunId =
-                                    (typeof nudge.runId === 'string' && nudge.runId) ||
-                                        result.mastraRunId ||
-                                        activeMastraRunId;
-                                continue;
-                            }
-                            return await (result.text ?? activeStream.text ?? Promise.resolve(''));
-                        }
-                    });
-                });
-                await (0, tracing_utils_1.finishTraceRun)(context, traceRun, {
-                    outputs: {
-                        result: resultText,
-                        agentId: subAgentId,
-                        role: 'credential-setup-browser-agent',
-                    },
-                });
-                context.eventBus.publish(context.threadId, {
-                    type: 'agent-completed',
-                    runId: context.runId,
-                    agentId: subAgentId,
-                    payload: {
-                        role: 'credential-setup-browser-agent',
-                        result: resultText,
-                    },
-                });
-                return { result: resultText };
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                await (0, tracing_utils_1.failTraceRun)(context, traceRun, error, {
-                    agent_id: subAgentId,
-                    agent_role: 'credential-setup-browser-agent',
-                });
-                context.eventBus.publish(context.threadId, {
-                    type: 'agent-completed',
-                    runId: context.runId,
-                    agentId: subAgentId,
-                    payload: {
-                        role: 'credential-setup-browser-agent',
-                        result: '',
-                        error: errorMessage,
-                    },
-                });
-                return { result: `Browser agent error: ${errorMessage}` };
-            }
-        },
-    });
+                        activeStream = (0, resumable_stream_executor_1.normalizeStreamSource)(nudge);
+                        activeAgentRunId =
+                            (typeof activeStream.runId === 'string' && activeStream.runId) ||
+                                result.agentRunId ||
+                                activeAgentRunId;
+                        continue;
+                    }
+                    return await (result.text ?? activeStream.text ?? Promise.resolve(''));
+                }
+            }),
+        });
+        if (spawnOutcome.status === 'duplicate') {
+            return {
+                result: `Browser credential setup is already running (task: ${spawnOutcome.existing.taskId}). Wait for the background-task follow-up before dispatching another one.`,
+            };
+        }
+        if (spawnOutcome.status === 'limit-reached') {
+            return {
+                result: 'Could not start browser credential setup: concurrent background-task limit reached. Wait for an existing task to finish and try again.',
+            };
+        }
+        context.eventBus.publish(context.threadId, {
+            type: 'agent-spawned',
+            runId: context.runId,
+            agentId: subAgentId,
+            payload: {
+                parentId: context.orchestratorAgentId,
+                role: BROWSER_CREDENTIAL_AGENT_ROLE,
+                tools: (0, tool_registry_1.toolRegistryKeys)(browserToolsWithDenialDetection),
+                taskId,
+                kind: 'browser-setup',
+                title: 'Setting up credential',
+                subtitle: input.credentialType,
+                goal: `Set up ${input.credentialType}`,
+                targetResource: { type: 'credential' },
+            },
+        });
+        return {
+            result: `Browser credential setup started (task: ${taskId}). Wait for the background-task follow-up before summarizing the result.`,
+        };
+    })
+        .build();
 }
 //# sourceMappingURL=browser-credential-setup.tool.js.map