n8n 2.34.4 → 2.35.1

package/dist/modules/instance-ai/instance-ai.service.js

@@ -21,6 +21,7 @@ const db_1 = require("@n8n/db");
 const decorators_1 = require("@n8n/decorators");
 const di_1 = require("@n8n/di");
 const instance_ai_1 = require("@n8n/instance-ai");
+const telemetry_1 = require("@n8n/telemetry");
 const lazy_import_1 = require("@n8n/utils/lazy-import");
 const workflow_sdk_1 = require("@n8n/workflow-sdk");
 const n8n_core_1 = require("n8n-core");
@@ -36,7 +37,8 @@ const publisher_service_1 = require("../../scaling/pubsub/publisher.service");
 const ai_service_1 = require("../../services/ai.service");
 const proxy_token_manager_1 = require("../../services/proxy-token-manager");
 const url_service_1 = require("../../services/url.service");
-const telemetry_1 = require("../../telemetry");
+const telemetry_2 = require("../../telemetry");
+const utils_1 = require("../../utils");
 const agent_preview_handoff_1 = require("./agent-preview-handoff");
 const composite_local_mcp_server_1 = require("./browser/composite-local-mcp-server");
 const instance_ai_browser_session_service_1 = require("./browser/instance-ai-browser-session.service");
@@ -44,6 +46,7 @@ const thread_credential_allowlist_service_1 = require("./eval/thread-credential-
 const durable_event_log_1 = require("./event-bus/durable-event-log");
 const in_process_event_bus_1 = require("./event-bus/in-process-event-bus");
 const interrupted_run_sweeper_1 = require("./event-bus/interrupted-run-sweeper");
+const instance_ai_credit_display_1 = require("./instance-ai-credit-display");
 const instance_ai_credit_service_1 = require("./instance-ai-credit.service");
 const instance_ai_error_reporter_service_1 = require("./instance-ai-error-reporter.service");
 const instance_ai_gateway_service_1 = require("./instance-ai-gateway.service");
@@ -95,6 +98,9 @@ function buildContextResourcesBlock(contextAttachments) {
     const lines = contextAttachments.map((attachment) => {
         const name = attachment.name ? ` "${attachment.name}"` : '';
         if (attachment.type === 'agent') {
+            if (attachment.pending) {
+                return `- New unsaved Agent artifact${name} (pending id: \`${attachment.id}\`, in project \`${attachment.projectId}\`).`;
+            }
             return `- Agent${name} (id: \`${attachment.id}\`, in project \`${attachment.projectId}\`).`;
         }
         const execution = attachment.executionId
@@ -105,22 +111,35 @@ function buildContextResourcesBlock(contextAttachments) {
     const header = contextAttachments.some((attachment) => attachment.type === 'agent')
         ? 'The user opened this conversation from the agent editor, where they are looking at:'
         : 'The user opened this conversation from the workflow editor, where they are looking at:';
+    const pendingAgentGuidance = contextAttachments.some((attachment) => attachment.type === 'agent' && attachment.pending)
+        ? "Treat references such as “the agent” as this pending artifact. It has no persisted agent row yet. When the user asks to build or change it, use `build-agent`'s new-agent path with a name; do not pass its pending id as an existing `agentId`. The thread's pending target will make creation reuse that id."
+        : '';
     const prose = [
         header,
         ...lines,
+        pendingAgentGuidance,
         "Treat this purely as context. Until the user tells you what they need, don't read, inspect, run, or otherwise call tools on these resources, and don't make claims about their contents — just briefly acknowledge what they're working on and ask how you can help.",
-    ].join('\n');
+    ]
+        .filter(Boolean)
+        .join('\n');
     return `${internal_messages_1.EDITOR_CONTEXT_OPEN_TAG}\n${JSON.stringify(contextAttachments)}\n\n${prose}\n${internal_messages_1.EDITOR_CONTEXT_CLOSE_TAG}`;
 }
 function buildHandoffContextBlock(context) {
     if (!context || context.source !== 'credential-modal')
         return '';
     const { credential } = context;
+    const placeholderTitles = credential.placeholderTitles ?? [];
     const lines = [
         `- Credential type: \`${credential.credentialType}\` (${credential.displayName}).`,
         credential.id ? `- Existing credential id: \`${credential.id}\`.` : '',
         credential.nodeName ? `- Node name: "${credential.nodeName}".` : '',
         credential.nodeType ? `- Node type: \`${credential.nodeType}\`.` : '',
+        placeholderTitles.length
+            ? `- The credential form is fully pre-filled from a recipe; the user only pastes: ${placeholderTitles.map((title) => `"${title}"`).join(', ')}.`
+            : '',
+        credential.docsUrl
+            ? `- The provider page where the user creates/copies the secret (verified during recipe research): ${credential.docsUrl}`
+            : '',
         credential.documentationUrl ? `- n8n documentation URL: ${credential.documentationUrl}` : '',
         credential.oauthRedirectUrl
             ? `- OAuth redirect/callback URL shown in the modal: ${credential.oauthRedirectUrl}`
@@ -130,7 +149,12 @@ function buildHandoffContextBlock(context) {
         'The user opened this conversation from the credential setup modal and is asking for setup guidance.',
         ...lines,
         'Use this metadata only as setup context. Never ask the user to paste credential secrets into chat. For credential setup docs, load `n8n-docs-assistant` and use `n8n-docs` with `intent: "credential-setup"`.',
-    ].join('\n');
+        placeholderTitles.length
+            ? `Because the form is pre-filled, give step-by-step guidance on where to obtain the listed value(s) on the provider side${credential.docsUrl ? ' — direct the user to the provider page above rather than re-researching' : ' (research the provider if needed)'} — and do NOT suggest editing the auth template, test URL, or any other credential field.`
+            : '',
+    ]
+        .filter(Boolean)
+        .join('\n');
     return `${internal_messages_1.CREDENTIAL_CONTEXT_OPEN_TAG}\n${JSON.stringify(context)}\n\n${prose}\n${internal_messages_1.CREDENTIAL_CONTEXT_CLOSE_TAG}`;
 }
 function isTelemetryConfigurableAgent(agent) {
@@ -141,6 +165,7 @@ function isTelemetryConfigurableAgent(agent) {
 const INSTANCE_AI_CHECKPOINT_PRUNE_RETRY_MS = 30 * 1000;
 const WORKFLOW_SETUP_ROUTING_CLAIM_TTL_MS = 15 * 60 * 1000;
 const CONFIRMATION_EXPIRED_MESSAGE = 'This confirmation has expired. Send a new message to continue.';
+const RESUME_REJECTED_MESSAGE = 'I could not apply that confirmation. Send a new message to continue.';
 const INSTANCE_AI_SHUTDOWN_DRAIN_TIMEOUT_MS = 5 * 1000;
 function isTextMessagePart(part) {
     return (typeof part === 'object' &&
@@ -157,10 +182,12 @@ function isStaleResumeError(error) {
     return error instanceof Error && error.name === 'StaleResumeError';
 }
 exports.QUOTA_EXHAUSTED_USER_MESSAGE = "You've run out of AI credits. Upgrade your plan to continue using the AI assistant.";
+const OPERATIONAL_ERROR_USER_MESSAGE = 'I hit an operational error before I could finish that response. Please try again.';
+const GENERIC_ERROR_USER_MESSAGE = 'Something went wrong before I could finish that response. Please try again.';
 function getUserFacingErrorCode(error) {
     return (0, instance_ai_1.isQuotaExhaustedError)(error) ? 'quota_exhausted' : undefined;
 }
-function getUserFacingErrorMessage(error) {
+function getUserFacingErrorMessage(error, fallback = GENERIC_ERROR_USER_MESSAGE) {
     if ((0, instance_ai_1.isQuotaExhaustedError)(error)) {
         return exports.QUOTA_EXHAUSTED_USER_MESSAGE;
     }
@@ -174,12 +201,9 @@ function getUserFacingErrorMessage(error) {
         return "I couldn't finish preparing the workspace sandbox. Please try again in a moment.";
     }
     if (error instanceof n8n_workflow_1.OperationalError) {
-        return 'I hit an operational error before I could finish that response. Please try again.';
+        return OPERATIONAL_ERROR_USER_MESSAGE;
     }
-    if (error instanceof n8n_workflow_1.UnexpectedError) {
-        return 'Something went wrong before I could finish that response. Please try again.';
-    }
-    return 'Something went wrong before I could finish that response. Please try again.';
+    return fallback;
 }
 function isMaskedStreamFailure(error) {
     if (!(error instanceof Error))
@@ -212,6 +236,18 @@ function getAbortReason(signal) {
         return reason.message;
     return typeof reason === 'string' ? reason : 'user_cancelled';
 }
+function classifyUnclaimedResume(error, flags) {
+    if (isStaleResumeError(error))
+        return { kind: 'stale' };
+    if (flags.aborted)
+        return flags.preserveHitl ? { kind: 'preserve-hitl' } : { kind: 'cancelled' };
+    return {
+        kind: 'errored',
+        reason: getUserFacingErrorMessage(error, RESUME_REJECTED_MESSAGE),
+        errorCode: getUserFacingErrorCode(error),
+        errorMessage: getErrorMessage(error),
+    };
+}
 const MAX_CONCURRENT_BACKGROUND_TASKS_PER_THREAD = 5;
 const MAX_CONSECUTIVE_FAILED_INTERNAL_FOLLOW_UPS = 3;
 const TITLE_REFINE_HISTORY_LIMIT = 50;
@@ -462,14 +498,16 @@ let InstanceAiService = class InstanceAiService {
         return this.modelService.isProxyEnabled();
     }
     async getCredits(user) {
-        return await this.modelService.getCredits(user);
+        await this.creditService.ensureQuotaLockApplied(user);
+        const credits = await this.modelService.getCredits(user);
+        return (0, instance_ai_credit_display_1.maskCreditsForDisplay)(credits, this.settingsService.isActivationCapped());
     }
     async reclassifyMaskedStreamFailure(error, user, context) {
         if (!isMaskedStreamFailure(error))
             return error;
         try {
-            const { creditsQuota, creditsClaimed } = await this.modelService.getCredits(user);
-            if (creditsQuota < 0 || creditsClaimed < creditsQuota)
+            const { creditsQuota, creditsClaimed, quotaLocked } = await this.modelService.getCredits(user);
+            if (!quotaLocked && (creditsQuota < 0 || creditsClaimed < creditsQuota))
                 return error;
         }
         catch (creditsError) {
@@ -1291,11 +1329,13 @@ let InstanceAiService = class InstanceAiService {
         const browserUseEnabledGlobally = adminSettings.browserUseEnabled;
         const localGatewayDisabledForUser = await this.settingsService.isLocalGatewayDisabledForUser(user.id);
         const userGateway = this.gatewayService.findGateway(user.id);
+        await this.creditService.ensureQuotaLockApplied(user);
         const { searchProxyConfig, tracingProxyConfig, tokenManager, proxyBaseUrl } = proxyRunConfig ?? (await this.createProxyRunConfig(user));
         const modelId = proxyBaseUrl && tokenManager
             ? await this.modelService.resolveProxyModel(user, proxyBaseUrl, tokenManager)
             : await this.modelService.resolveAgentModelConfig(user);
         const configEvalsEnabled = await this.adapterService.isConfigEvalsEnabled(user);
+        const mcpConnectionsEnabled = await this.adapterService.isMcpConnectionsEnabled(user);
         const context = this.adapterService.createContext(user, {
             searchProxyConfig,
             pushRef,
@@ -1304,6 +1344,7 @@ let InstanceAiService = class InstanceAiService {
             credentialIdAllowlist: this.evalCredentialAllowlists.get(threadId),
             shouldBypassCredentialTest: (credentialId) => this.evalCredentialAllowlists.shouldBypassTest(threadId, credentialId),
             configEvalsEnabled,
+            mcpConnectionsEnabled,
             modelId,
         });
         this.gatewayService.applyToolPolicy(user.id);
@@ -1430,6 +1471,7 @@ let InstanceAiService = class InstanceAiService {
             }
         }
         context.workspace = runtimeWorkspace;
+        context.workspaceRoot = workspaceRoot;
         context.threadId = threadId;
         context.threadMemory = memory;
         context.trackTelemetry = (eventName, properties) => {
@@ -2057,18 +2099,31 @@ let InstanceAiService = class InstanceAiService {
         try {
             errorReporterExecutionToken = this.instanceAiErrorReporter.beginRun(runId);
             messageId = (0, nanoid_1.nanoid)();
-            const traceInput = {
-                message,
-                ...(fileAttachments.length
-                    ? {
-                        attachments: fileAttachments.map((attachment) => ({
-                            mimeType: attachment.mimeType,
-                            size: attachment.data.length,
-                        })),
+            const traceInput = { message };
+            if (fileAttachments.length) {
+                traceInput.attachments = fileAttachments.map((attachment) => ({
+                    mimeType: attachment.mimeType,
+                    size: attachment.data.length,
+                }));
+            }
+            if (contextAttachments.length) {
+                traceInput.resourceAttachments = contextAttachments.map((attachment) => {
+                    const resource = {
+                        type: attachment.type,
+                        id: attachment.id,
+                    };
+                    if (attachment.type === 'agent') {
+                        resource.projectId = attachment.projectId;
                     }
-                    : {}),
-                ...(messageGroupId ? { messageGroupId } : {}),
-            };
+                    if (attachment.type === 'workflow' && attachment.executionId) {
+                        resource.executionId = attachment.executionId;
+                    }
+                    return resource;
+                });
+            }
+            if (messageGroupId) {
+                traceInput.messageGroupId = messageGroupId;
+            }
             const proxyRunConfig = await this.createProxyRunConfig(user);
             if (resumeReason) {
                 tracing = await this.tracing.createOrchestratorResumeTraceContext({
@@ -2192,6 +2247,7 @@ let InstanceAiService = class InstanceAiService {
                     this.tracing.storeTraceContext(runId, threadId, tracing, messageGroupId);
                 }
             }
+            await this.snapshotAttachedAgents(contextAttachments, orchestrationContext, tracing);
             const enrichedMessage = await this.buildMessageWithRunningTasks(threadId, message);
             const contextResourcesBlock = buildContextResourcesBlock(contextAttachments);
             let handoffContextBlock = '';
@@ -3027,6 +3083,16 @@ let InstanceAiService = class InstanceAiService {
         const { agent, runId, agentRunId, threadId, user, toolCallId, toolName, suspendPayload, abortController, tracing, modelId, messageGroupId, checkpoint, plannedBuild, runHandoff, orchestrationContext, } = suspended;
         if (user.id !== requestingUserId)
             return null;
+        const activeRun = this.runState.getActiveRun(threadId);
+        if (activeRun) {
+            this.logger.warn('Rejecting suspended-run confirmation: thread already has an active run', {
+                requestId,
+                threadId,
+                suspendedRunId: runId,
+                activeRunId: activeRun.runId,
+            });
+            return null;
+        }
         const activeUser = await this.revalidateActiveUser(user.id);
         if (!activeUser) {
             this.logger.warn('Cancelling suspended run: user no longer authorized for AI Assistant', {
@@ -3096,12 +3162,24 @@ let InstanceAiService = class InstanceAiService {
         if (data.autoSetup) {
             const rebuilt = await this.rebuildAgentForAutoSetupResume(activeUser, threadId, runId, abortController, effectiveTracing, runHandoff, messageGroupId);
             if (!rebuilt) {
+                const rebuildFailure = 'Agent rebuild failed';
                 await this.tracing.finalizeDetachedTraceRun(`resume-rebuild:${runId}`, unregisteredResumeTracing, {
                     status: 'failed',
-                    error: 'Agent rebuild failed',
+                    error: rebuildFailure,
                     metadata: { completion_source: 'resume_rebuild' },
                 });
                 this.cancelRun(threadId, 'agent_rebuild_failed');
+                await this.emitTerminalRun({
+                    threadId,
+                    runId,
+                    status: 'errored',
+                    reason: OPERATIONAL_ERROR_USER_MESSAGE,
+                    errorInfo: { errorMessage: rebuildFailure, errorSource: 'exception' },
+                    messageGroupId,
+                    user: activeUser,
+                    snapshotStorage: this.dbSnapshotStorage,
+                });
+                this.runState.clearActiveRun(threadId, resumeExecutionToken);
                 return null;
             }
             resumeAgent = rebuilt.agent;
@@ -3128,7 +3206,7 @@ let InstanceAiService = class InstanceAiService {
             resumeExecutionToken,
             messageGroupId,
             resumeTracing,
-            discardTracingOnStale: unregisteredResumeTracing,
+            unregisteredResumeTracing,
         });
         return { ok: true, runId };
     }
@@ -3205,20 +3283,7 @@ let InstanceAiService = class InstanceAiService {
             if (!resumeClaimed) {
                 skipPostRunCleanup = true;
                 const claimError = result.error ?? new Error('Resume checkpoint claim did not complete');
-                this.instanceAiErrorReporter.report(claimError, {
-                    component: 'instance-ai-resume-claim',
-                    threadId: opts.threadId,
-                    runId: opts.runId,
-                    tracing: opts.tracing,
-                    agentId: (0, instance_ai_1.orchestratorAgentId)(opts.runId),
-                    userId: opts.user.id,
-                    messageGroupId: opts.messageGroupId,
-                });
-                await this.tracing.finalizeDetachedTraceRun(`unclaimed-resume:${opts.runId}`, opts.discardTracingOnStale, {
-                    status: 'failed',
-                    error: getErrorMessage(claimError),
-                    metadata: { completion_source: 'resume_claim' },
-                });
+                await this.settleUnclaimedResume(opts, claimError, 'stream');
                 return;
             }
             if (result.status === 'suspended') {
@@ -3398,31 +3463,9 @@ let InstanceAiService = class InstanceAiService {
             }
         }
         catch (error) {
-            if (!resumeClaimed && isStaleResumeError(error)) {
-                skipPostRunCleanup = true;
-                await this.tracing.finalizeDetachedTraceRun(`stale-resume:${opts.runId}`, opts.discardTracingOnStale, {
-                    status: 'cancelled',
-                    outputs: { runId: opts.runId },
-                    metadata: { completion_source: 'stale_resume' },
-                });
-                return;
-            }
             if (!resumeClaimed) {
                 skipPostRunCleanup = true;
-                this.instanceAiErrorReporter.report(error, {
-                    component: 'instance-ai-resume-claim',
-                    threadId: opts.threadId,
-                    runId: opts.runId,
-                    tracing: opts.tracing,
-                    agentId: (0, instance_ai_1.orchestratorAgentId)(opts.runId),
-                    userId: opts.user.id,
-                    messageGroupId: opts.messageGroupId,
-                });
-                await this.tracing.finalizeDetachedTraceRun(`unclaimed-resume:${opts.runId}`, opts.discardTracingOnStale, {
-                    status: 'failed',
-                    error: getErrorMessage(error),
-                    metadata: { completion_source: 'resume_claim' },
-                });
+                await this.settleUnclaimedResume(opts, error, 'exception');
                 return;
             }
             if (opts.signal.aborted) {
@@ -3547,6 +3590,92 @@ let InstanceAiService = class InstanceAiService {
             }
         }
     }
+    async settleUnclaimedResume(opts, error, errorSource) {
+        const outcome = classifyUnclaimedResume(error, {
+            aborted: opts.signal.aborted,
+            preserveHitl: this.shouldPreserveHitlOnShutdown(opts.runId),
+        });
+        switch (outcome.kind) {
+            case 'preserve-hitl':
+                return;
+            case 'stale':
+                await this.tracing.finalizeDetachedTraceRun(`stale-resume:${opts.runId}`, opts.unregisteredResumeTracing, {
+                    status: 'cancelled',
+                    outputs: { runId: opts.runId },
+                    metadata: { completion_source: 'stale_resume' },
+                });
+                return;
+            case 'cancelled': {
+                const reason = this.liveness.consumeRunTimeout(opts.runId).timedOut
+                    ? liveness_1.INSTANCE_AI_RUN_TIMEOUT_REASON
+                    : getAbortReason(opts.signal);
+                await this.tracing.finalizeDetachedTraceRun(`cancelled-resume:${opts.runId}`, opts.unregisteredResumeTracing, {
+                    status: 'cancelled',
+                    outputs: { runId: opts.runId },
+                    metadata: { completion_source: 'resume_cancelled', cancellation_reason: reason },
+                });
+                await this.emitTerminalRun({
+                    threadId: opts.threadId,
+                    runId: opts.runId,
+                    status: 'cancelled',
+                    reason,
+                    messageGroupId: opts.messageGroupId,
+                    user: opts.user,
+                    snapshotStorage: opts.snapshotStorage,
+                });
+                return;
+            }
+            case 'errored':
+                this.instanceAiErrorReporter.report(error, {
+                    component: 'instance-ai-resume-claim',
+                    threadId: opts.threadId,
+                    runId: opts.runId,
+                    tracing: opts.tracing,
+                    agentId: (0, instance_ai_1.orchestratorAgentId)(opts.runId),
+                    userId: opts.user.id,
+                    messageGroupId: opts.messageGroupId,
+                });
+                await this.tracing.finalizeDetachedTraceRun(`unclaimed-resume:${opts.runId}`, opts.unregisteredResumeTracing, {
+                    status: 'failed',
+                    error: outcome.errorMessage,
+                    metadata: { completion_source: 'resume_claim' },
+                });
+                await this.emitTerminalRun({
+                    threadId: opts.threadId,
+                    runId: opts.runId,
+                    status: 'errored',
+                    reason: outcome.reason,
+                    errorCode: outcome.errorCode,
+                    errorInfo: { errorMessage: outcome.errorMessage, errorSource },
+                    messageGroupId: opts.messageGroupId,
+                    user: opts.user,
+                    snapshotStorage: opts.snapshotStorage,
+                });
+                return;
+            default:
+                (0, utils_1.assertNever)(outcome);
+        }
+    }
+    async emitTerminalRun(args) {
+        const { threadId, runId, status } = args;
+        const context = { threadId, runId };
+        await this.bestEffort('Failed to evaluate the terminal response for a settling run', context, async () => await this.terminalOutcome.evaluateTerminalResponse(threadId, runId, status, {
+            messageGroupId: args.messageGroupId,
+            ...(status === 'errored' ? { errorMessage: args.reason, errorCode: args.errorCode } : {}),
+        }));
+        const archivedWorkflowIds = (await this.bestEffort('Failed to reap temporary workflows for a settling run', context, async () => await this.temporaryWorkflowService.reapForRun(threadId, args.user, undefined, this.backgroundTasks.getRunningTasks(threadId).length))) ?? [];
+        this.publishRunFinish(threadId, runId, status, args.reason, archivedWorkflowIds, args.user.id, args.errorInfo);
+        await this.bestEffort('Failed to save the agent tree snapshot for a settling run', context, async () => await this.saveAgentTreeSnapshot(threadId, runId, args.snapshotStorage));
+    }
+    async bestEffort(failureMessage, context, step) {
+        try {
+            return await step();
+        }
+        catch (error) {
+            this.logger.warn(failureMessage, { ...context, error: getErrorMessage(error) });
+            return undefined;
+        }
+    }
     spawnBackgroundTask(runId, opts, snapshotStorage, messageGroupIdOverride) {
         const outcome = this.backgroundTasks.spawn({
             taskId: opts.taskId,
@@ -3732,6 +3861,32 @@ let InstanceAiService = class InstanceAiService {
         }
         return { status: 'limit-reached' };
     }
+    async snapshotAttachedAgents(attachments, orchestrationContext, tracing) {
+        const delegate = orchestrationContext.domainContext?.builderDelegate;
+        if (!delegate || !tracing)
+            return;
+        for (const attachment of attachments) {
+            if (attachment.type !== 'agent')
+                continue;
+            let artifact = null;
+            try {
+                artifact = (await delegate.readAgentArtifact?.(attachment.id)) ?? null;
+            }
+            catch (error) {
+                this.logger.debug(`[agent-snapshot] attached read for ${attachment.id} failed: ${error instanceof Error ? error.message : String(error)}`);
+                continue;
+            }
+            if (!artifact)
+                continue;
+            await (0, instance_ai_1.emitAgentSnapshotTraceEvent)(tracing, {
+                agentId: attachment.id,
+                projectId: attachment.projectId,
+                reason: 'attached',
+                artifact,
+                logger: this.logger,
+            });
+        }
+    }
     async buildMessageWithRunningTasks(threadId, message) {
         return await (0, instance_ai_1.enrichMessageWithBackgroundTasks)(message, this.backgroundTasks.getRunningTasks(threadId), {
             formatTask: async (task) => `[Running task — ${task.role}]: taskId=${task.taskId}`,
@@ -3773,13 +3928,33 @@ let InstanceAiService = class InstanceAiService {
                 numSteps = payload.planItems.length;
             }
         }
+        const credentialRequests = (Array.isArray(payload.credentialRequests) ? payload.credentialRequests : []).filter((request) => typeof request === 'object' && request !== null);
+        const containsTemplatedCred = credentialRequests.some((request) => request.credentialType === api_types_1.TEMPLATED_CUSTOM_AUTH_CREDENTIAL_TYPE ||
+            (request.setupHint !== null && request.setupHint !== undefined));
         this.telemetry.track('Builder asked for input', {
             user_id: userId,
             thread_id: threadId,
             input_thread_id: inputThreadId,
             type,
             num_steps: numSteps,
+            contains_templated_cred: containsTemplatedCred,
         });
+        for (const request of credentialRequests) {
+            const parsedHint = api_types_1.credentialSetupHintSchema.safeParse(request.setupHint);
+            if (!parsedHint.success)
+                continue;
+            const hint = parsedHint.data;
+            this.telemetry.track(telemetry_1.TELEMETRY_EVENT.INSTANCE_AI.BUILDER_SPECCED_TEMPLATED_CRED, {
+                thread_id: threadId,
+                input_thread_id: inputThreadId,
+                template: hint.template,
+                placeholders: hint.placeholders,
+                test_url: hint.testUrl,
+                docs_url: hint.docsUrl,
+                service_host: hint.serviceHost,
+                accepted_status_codes: hint.acceptedStatusCodes,
+            });
+        }
     }
     async finalizeCancelledSuspendedRun(suspended, reason = 'user_cancelled') {
         const runTimeout = reason === liveness_1.INSTANCE_AI_RUN_TIMEOUT_REASON
@@ -4067,6 +4242,6 @@ __decorate([
 ], InstanceAiService.prototype, "stopCheckpointPruning", null);
 exports.InstanceAiService = InstanceAiService = __decorate([
     (0, di_1.Service)(),
-    __metadata("design:paramtypes", [backend_common_1.Logger, config_1.GlobalConfig, n8n_core_1.InstanceSettings, instance_ai_adapter_service_1.InstanceAiAdapterService, in_process_event_bus_1.InProcessEventBus, durable_event_log_1.DurableEventLog, interrupted_run_sweeper_1.InterruptedRunSweeper, instance_ai_settings_service_1.InstanceAiSettingsService, instance_ai_gateway_service_1.InstanceAiGatewayService, instance_ai_browser_session_service_1.InstanceAiBrowserSessionService, instance_ai_memory_service_1.InstanceAiMemoryService, typeorm_agent_memory_1.TypeORMAgentMemory, typeorm_agent_checkpoint_store_1.TypeORMAgentCheckpointStore, ai_service_1.AiService, instance_ai_thread_grant_repository_1.InstanceAiThreadGrantRepository, instance_ai_pending_confirmation_repository_1.InstanceAiPendingConfirmationRepository, url_service_1.UrlService, db_snapshot_storage_1.DbSnapshotStorage, db_iteration_log_storage_1.DbIterationLogStorage, source_control_preferences_service_ee_1.SourceControlPreferencesService, telemetry_1.Telemetry, mcp_1.InstanceAiMcpRegistryService, db_1.UserRepository, instance_ai_temporary_workflow_service_1.InstanceAiTemporaryWorkflowService, n8n_core_1.ErrorReporter, config_1.SsrfProtectionConfig, backend_network_1.SsrfProtectionService, event_service_1.EventService, thread_credential_allowlist_service_1.EvalThreadCredentialAllowlistService, instance_ai_run_probe_1.InstanceAiRunProbe, instance_ai_model_service_1.InstanceAiModelService, instance_ai_credit_service_1.InstanceAiCreditService, publisher_service_1.Publisher, instance_ai_error_reporter_service_1.InstanceAiErrorReporterService])
+    __metadata("design:paramtypes", [backend_common_1.Logger, config_1.GlobalConfig, n8n_core_1.InstanceSettings, instance_ai_adapter_service_1.InstanceAiAdapterService, in_process_event_bus_1.InProcessEventBus, durable_event_log_1.DurableEventLog, interrupted_run_sweeper_1.InterruptedRunSweeper, instance_ai_settings_service_1.InstanceAiSettingsService, instance_ai_gateway_service_1.InstanceAiGatewayService, instance_ai_browser_session_service_1.InstanceAiBrowserSessionService, instance_ai_memory_service_1.InstanceAiMemoryService, typeorm_agent_memory_1.TypeORMAgentMemory, typeorm_agent_checkpoint_store_1.TypeORMAgentCheckpointStore, ai_service_1.AiService, instance_ai_thread_grant_repository_1.InstanceAiThreadGrantRepository, instance_ai_pending_confirmation_repository_1.InstanceAiPendingConfirmationRepository, url_service_1.UrlService, db_snapshot_storage_1.DbSnapshotStorage, db_iteration_log_storage_1.DbIterationLogStorage, source_control_preferences_service_ee_1.SourceControlPreferencesService, telemetry_2.Telemetry, mcp_1.InstanceAiMcpRegistryService, db_1.UserRepository, instance_ai_temporary_workflow_service_1.InstanceAiTemporaryWorkflowService, n8n_core_1.ErrorReporter, config_1.SsrfProtectionConfig, backend_network_1.SsrfProtectionService, event_service_1.EventService, thread_credential_allowlist_service_1.EvalThreadCredentialAllowlistService, instance_ai_run_probe_1.InstanceAiRunProbe, instance_ai_model_service_1.InstanceAiModelService, instance_ai_credit_service_1.InstanceAiCreditService, publisher_service_1.Publisher, instance_ai_error_reporter_service_1.InstanceAiErrorReporterService])
 ], InstanceAiService);
 //# sourceMappingURL=instance-ai.service.js.map