n8n 2.40.5 → 2.41.1

package/dist/modules/instance-ai/instance-context.service.d.ts

@@ -1,12 +1,29 @@
 import { Logger } from '@n8n/backend-common';
-import { GlobalConfig } from '@n8n/config';
-import { ActivityEventRepository, ExecutionRepository, WorkflowRepository } from '@n8n/db';
-import type { User } from '@n8n/db';
+import { ActivityEventRepository, ExecutionRepository, ProjectRepository, WorkflowRepository } from '@n8n/db';
+import type { ActivityEventCategory, User } from '@n8n/db';
 import type { InstanceAiActivityEntry, InstanceAiActivityExpansion } from '@n8n/instance-ai';
+import { ProjectService } from '../../services/project.service.ee';
+export type InstanceContextScope = {
+    surface: 'conversation';
+    projectId?: string;
+} | {
+    surface: 'mcp';
+    projectId?: string;
+    credentialGranted: boolean;
+    executionGranted: boolean;
+};
+export type ActivityPage = {
+    entries: InstanceAiActivityEntry[];
+    hasMore: boolean;
+    nextBeforeId?: number;
+};
 export declare const INSTANCE_CONTEXT_CURSOR = "instanceContext";
 export type InstanceContextCursor = {
     activityMark: number;
+    activityFloor: number;
+    activityCategories: ActivityEventCategory[];
     activitySeen: number[];
+    activitySeenFloor?: number;
     runsThrough: string;
 };
 export declare function readInstanceContextCursor(metadata: Record<string, unknown> | undefined): InstanceContextCursor | null;
@@ -16,33 +33,45 @@ export type InstanceContextBlock = {
 };
 export declare class InstanceContextService {
     private readonly logger;
-    private readonly globalConfig;
     private readonly activityEventRepository;
     private readonly executionRepository;
     private readonly workflowRepository;
-    constructor(logger: Logger, globalConfig: GlobalConfig, activityEventRepository: ActivityEventRepository, executionRepository: ExecutionRepository, workflowRepository: WorkflowRepository);
-    get enabled(): boolean;
+    private readonly projectRepository;
+    private readonly projectService;
+    constructor(logger: Logger, activityEventRepository: ActivityEventRepository, executionRepository: ExecutionRepository, workflowRepository: WorkflowRepository, projectRepository: ProjectRepository, projectService: ProjectService);
     buildBlock(input: {
         user: User;
-        projectId?: string;
+        scope: InstanceContextScope;
         cursor: InstanceContextCursor | null;
         isMachineFollowUp?: boolean;
+        enabled: boolean;
         now?: Date;
     }): Promise<InstanceContextBlock | null>;
     list(input: {
         user: User;
-        projectId?: string;
+        scope: InstanceContextScope;
         limit: number;
         category?: string;
         resourceId?: string;
         beforeId?: number;
     }): Promise<InstanceAiActivityEntry[]>;
+    listPage(input: {
+        user: User;
+        scope: InstanceContextScope;
+        limit: number;
+        category?: string;
+        resourceId?: string;
+        beforeId?: number;
+    }): Promise<ActivityPage>;
     expand(input: {
         id: number;
         user: User;
-        projectId?: string;
+        scope: InstanceContextScope;
     }): Promise<InstanceAiActivityExpansion | null>;
     private readEntries;
     private readRuns;
-    private readableProjectIds;
+    private resolveScope;
+    private credentialReadableProjectIds;
+    hasWithheldWorkflows(user: User, scope: InstanceContextScope): Promise<boolean>;
+    private withoutWithheldWorkflows;
 }

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

@@ -12,72 +12,91 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.InstanceContextService = exports.INSTANCE_CONTEXT_CURSOR = void 0;
 exports.readInstanceContextCursor = readInstanceContextCursor;
 const backend_common_1 = require("@n8n/backend-common");
-const config_1 = require("@n8n/config");
 const constants_1 = require("@n8n/constants");
 const db_1 = require("@n8n/db");
 const di_1 = require("@n8n/di");
+const permissions_1 = require("@n8n/permissions");
 const is_record_1 = require("@n8n/utils/is-record");
 const check_access_1 = require("../../permissions.ee/check-access");
+const project_service_ee_1 = require("../../services/project.service.ee");
 const internal_messages_1 = require("./internal-messages");
 const windowSize = 40;
 const fetchMultiplier = 4;
+const withheldFetchMultiplier = 4;
 const maxAgeMs = 7 * constants_1.Time.days.toMilliseconds;
+const mcpRunWindowMs = 24 * constants_1.Time.hours.toMilliseconds;
 const runWorkflowCap = 12;
 const inventorySize = 8;
 const resourceHistoryLimit = 20;
-const activityLagIds = 200;
-const seenIdsCap = activityLagIds;
+const seenIdsCap = 200;
 const entryFetchLimit = windowSize * fetchMultiplier;
 exports.INSTANCE_CONTEXT_CURSOR = 'instanceContext';
 function readInstanceContextCursor(metadata) {
     const value = metadata?.[exports.INSTANCE_CONTEXT_CURSOR];
     if (!(0, is_record_1.isRecord)(value))
         return null;
-    const { activityMark, activitySeen, runsThrough } = value;
+    const { activityMark, activityFloor, activityCategories, activitySeen, runsThrough } = value;
     if (typeof activityMark !== 'number' || !Number.isFinite(activityMark))
         return null;
+    if (typeof activityFloor !== 'number' || !Number.isFinite(activityFloor))
+        return null;
+    if (!Array.isArray(activityCategories))
+        return null;
     if (typeof runsThrough !== 'string' || Number.isNaN(Date.parse(runsThrough)))
         return null;
     return {
         activityMark,
+        activityFloor,
+        activityCategories: activityCategories.filter(isKnownCategory),
         activitySeen: Array.isArray(activitySeen)
             ? activitySeen.filter((id) => typeof id === 'number' && Number.isFinite(id))
             : [],
+        ...(typeof value.activitySeenFloor === 'number' && Number.isFinite(value.activitySeenFloor)
+            ? { activitySeenFloor: value.activitySeenFloor }
+            : {}),
         runsThrough,
     };
 }
 let InstanceContextService = class InstanceContextService {
-    constructor(logger, globalConfig, activityEventRepository, executionRepository, workflowRepository) {
+    constructor(logger, activityEventRepository, executionRepository, workflowRepository, projectRepository, projectService) {
         this.logger = logger;
-        this.globalConfig = globalConfig;
         this.activityEventRepository = activityEventRepository;
         this.executionRepository = executionRepository;
         this.workflowRepository = workflowRepository;
+        this.projectRepository = projectRepository;
+        this.projectService = projectService;
         this.logger = this.logger.scoped('instance-ai');
     }
-    get enabled() {
-        return this.globalConfig.instanceAi.instanceContextEnabled;
-    }
     async buildBlock(input) {
-        if (!this.enabled || input.isMachineFollowUp)
+        if (!input.enabled)
+            return null;
+        if (input.isMachineFollowUp)
             return null;
         try {
             const now = input.now ?? new Date();
-            const isUpdate = input.cursor !== null;
-            const projectIds = await this.readableProjectIds(input.user, input.projectId);
-            if (projectIds.length === 0)
+            const resolved = await this.resolveScope(input.user, input.scope);
+            if (resolved === null)
                 return null;
+            const projectIds = resolved.projectIds;
+            const mcpVisibleOnly = resolved.surface === 'mcp';
+            const cursor = input.cursor;
+            const isUpdate = cursor !== null;
             const [entries, runs, inventory] = await Promise.all([
-                this.readEntries({ projectIds, cursor: input.cursor, now }),
-                this.readRuns({ projectIds, cursor: input.cursor, now }),
+                this.readEntries({ cursor, now, scope: resolved }),
+                resolved.surface === 'mcp' && !resolved.runsVisible
+                    ? Promise.resolve([])
+                    : this.readRuns({ projectIds, cursor, now, mcpVisibleOnly }),
                 isUpdate
                     ? Promise.resolve(undefined)
-                    : this.workflowRepository.findRecentForProjects(projectIds, inventorySize),
+                    : this.workflowRepository.findRecentForProjects(projectIds, inventorySize, {
+                        mcpVisibleOnly,
+                    }),
             ]);
             if (entries.rows.length === 0 && runs.length === 0 && !inventory?.total)
                 return null;
             return {
                 block: renderBlock({
+                    surface: resolved.surface,
                     entries: entries.rows.map((row) => toFeedEntry(row, input.user.id, now)),
                     entriesTruncated: entries.truncated,
                     runs,
@@ -87,38 +106,77 @@ let InstanceContextService = class InstanceContextService {
                 }),
                 cursor: {
                     activityMark: entries.mark,
+                    activityFloor: entries.floor,
+                    activityCategories: resolved.allowedCategories,
                     activitySeen: entries.seen,
+                    activitySeenFloor: entries.seenFloor,
                     runsThrough: now.toISOString(),
                 },
             };
         }
         catch (error) {
             this.logger.warn('Failed to build the instance-context block', { error });
+            if (input.scope.surface === 'mcp')
+                throw error;
             return null;
         }
     }
     async list(input) {
+        return (await this.listPage(input)).entries;
+    }
+    async listPage(input) {
+        const empty = { entries: [], hasMore: false };
         if (input.category !== undefined && !isKnownCategory(input.category))
-            return [];
-        const projectIds = await this.readableProjectIds(input.user, input.projectId);
-        if (projectIds.length === 0)
-            return [];
+            return empty;
+        const resolved = await this.resolveScope(input.user, input.scope);
+        if (resolved === null)
+            return empty;
+        const category = resolveCategory(input.category, resolved);
+        if (category === null)
+            return empty;
+        const filtersWithheld = resolved.surface === 'mcp';
+        const fetchLimit = filtersWithheld ? input.limit * withheldFetchMultiplier : input.limit;
         const rows = await this.activityEventRepository.findFeed({
-            limit: input.limit,
-            projectIds,
-            ...(input.category !== undefined ? { category: input.category } : {}),
+            limit: fetchLimit,
+            projectIds: resolved.projectIds,
+            allowedCategories: resolved.allowedCategories,
+            ...(category !== undefined ? { filterCategory: category } : {}),
             ...(input.resourceId !== undefined ? { resourceId: input.resourceId } : {}),
             ...(input.beforeId !== undefined ? { beforeId: input.beforeId } : {}),
         });
-        return rows.map((row) => toActivityEntry(row, input.user.id));
+        const visible = filtersWithheld ? await this.withoutWithheldWorkflows(rows, resolved) : rows;
+        if (input.resourceId !== undefined && rows.length > 0 && visible.length === 0) {
+            return empty;
+        }
+        const hasMore = visible.length > input.limit || rows.length === fetchLimit;
+        const shown = visible.slice(0, input.limit);
+        const resumeFrom = shown.length === input.limit ? shown.at(-1)?.id : rows.at(-1)?.id;
+        return {
+            entries: shown.map((row) => toActivityEntry(row, input.user.id)),
+            hasMore,
+            ...(hasMore && resumeFrom !== undefined ? { nextBeforeId: resumeFrom } : {}),
+        };
     }
     async expand(input) {
-        const projectIds = await this.readableProjectIds(input.user, input.projectId);
-        if (projectIds.length === 0)
+        const resolved = await this.resolveScope(input.user, input.scope);
+        if (resolved === null)
             return null;
-        const row = await this.activityEventRepository.findEntry({ id: input.id, projectIds });
+        const projectIds = resolved.projectIds;
+        const row = await this.activityEventRepository.findEntry({
+            id: input.id,
+            projectIds,
+            allowedCategories: resolved.allowedCategories,
+        });
         if (!row)
             return null;
+        if (resolved.surface === 'mcp') {
+            const touchesCredential = row.category === 'credential' || row.resourceType === 'credential';
+            if (touchesCredential && !isCredentialVisible(row, resolved))
+                return null;
+            const [visible] = await this.withoutWithheldWorkflows([row], resolved);
+            if (!visible)
+                return null;
+        }
         const history = row.resourceType && row.resourceId
             ? await this.activityEventRepository.findByResource({
                 resourceType: row.resourceType,
@@ -127,7 +185,7 @@ let InstanceContextService = class InstanceContextService {
                 limit: resourceHistoryLimit,
             })
             : [];
-        const hint = liveRecordHint(row);
+        const hint = liveRecordHint(row, input.scope.surface);
         return {
             entry: toActivityEntry(row, input.user.id),
             resourceHistory: history
@@ -137,85 +195,232 @@ let InstanceContextService = class InstanceContextService {
         };
     }
     async readEntries(input) {
-        const cursor = input.cursor;
+        const fetchLimit = input.scope.surface === 'mcp' ? entryFetchLimit * withheldFetchMultiplier : entryFetchLimit;
         const arrivals = await this.activityEventRepository.findFeed({
-            limit: entryFetchLimit,
-            projectIds: input.projectIds,
-            ...(cursor ? { afterId: cursor.activityMark } : {}),
+            limit: fetchLimit,
+            projectIds: input.scope.projectIds,
+            allowedCategories: input.scope.allowedCategories,
+            ...(input.cursor ? { afterId: input.cursor.activityMark } : {}),
         });
+        const cursor = input.cursor;
         const band = cursor
             ? await this.activityEventRepository.findFeed({
-                limit: activityLagIds,
-                projectIds: input.projectIds,
-                afterId: Math.max(0, cursor.activityMark - activityLagIds),
+                limit: seenIdsCap,
+                projectIds: input.scope.projectIds,
+                allowedCategories: input.scope.allowedCategories,
+                afterId: Math.max(cursor.activityFloor, cursor.activitySeenFloor ?? 0),
                 beforeId: cursor.activityMark,
             })
             : [];
-        const rows = [...arrivals, ...band];
+        const addedCategories = input.scope.allowedCategories.filter((category) => cursor && !cursor.activityCategories.includes(category));
+        const reopened = cursor && addedCategories.length > 0
+            ? await this.activityEventRepository.findFeed({
+                limit: seenIdsCap,
+                projectIds: input.scope.projectIds,
+                allowedCategories: addedCategories,
+                afterId: cursor.activitySeenFloor ?? 0,
+                beforeId: cursor.activityFloor + 1,
+            })
+            : [];
+        const read = [...arrivals, ...band, ...reopened];
+        const rows = input.scope.surface === 'mcp' ? await this.withoutWithheldWorkflows(read, input.scope) : read;
         const alreadyShown = new Set(cursor?.activitySeen ?? []);
         const fresh = rows.filter((row) => !alreadyShown.has(row.id) && input.now.getTime() - row.createdAt.getTime() <= maxAgeMs);
         const shown = fresh.slice(0, windowSize);
-        const mark = rows.reduce((highest, row) => Math.max(highest, row.id), cursor?.activityMark ?? 0);
-        const seen = [...alreadyShown, ...shown.map((row) => row.id)]
-            .filter((id) => id > mark - activityLagIds)
-            .sort((a, b) => b - a)
-            .slice(0, seenIdsCap);
+        const mark = read.reduce((highest, row) => Math.max(highest, row.id), cursor?.activityMark ?? 0);
+        const cut = fresh[windowSize];
+        const floor = Math.max(cursor?.activityFloor ?? 0, cut?.id ?? 0);
+        const seen = [...alreadyShown, ...shown.map((row) => row.id)].sort((a, b) => b - a);
+        const seenFloor = Math.max(cursor?.activitySeenFloor ?? 0, seen[seenIdsCap] ?? 0);
         return {
             rows: shown,
             mark,
-            seen,
-            truncated: fresh.length > windowSize || arrivals.length === entryFetchLimit,
+            floor,
+            seen: seen.filter((id) => id > seenFloor).slice(0, seenIdsCap),
+            seenFloor,
+            truncated: fresh.length > windowSize || arrivals.length === fetchLimit,
         };
     }
     async readRuns(input) {
+        const windowMs = input.mcpVisibleOnly ? mcpRunWindowMs : maxAgeMs;
         const stoppedAfter = input.cursor
             ? new Date(Date.parse(input.cursor.runsThrough))
-            : new Date(input.now.getTime() - maxAgeMs);
+            : new Date(input.now.getTime() - windowMs);
         return await this.executionRepository.summariseRunsForProjects({
             projectIds: input.projectIds,
             stoppedAfter,
             stoppedBefore: input.now,
             workflowLimit: runWorkflowCap,
+            ...(input.mcpVisibleOnly ? { mcpVisibleOnly: true } : {}),
         });
     }
-    async readableProjectIds(user, projectId) {
-        if (projectId === undefined)
+    async resolveScope(user, scope) {
+        if (scope.projectId !== undefined) {
+            const projectId = scope.projectId;
+            const allowed = await (0, check_access_1.userHasScopes)(user, ['workflow:read'], false, { projectId });
+            if (!allowed)
+                return null;
+            if (scope.surface === 'conversation') {
+                const credentials = await (0, check_access_1.userHasScopes)(user, ['credential:read'], false, { projectId });
+                return {
+                    surface: 'conversation',
+                    projectIds: [projectId],
+                    allowedCategories: credentials ? ['workflow', 'credential'] : ['workflow'],
+                };
+            }
+            const credentialProjectIds = scope.credentialGranted
+                ? await this.credentialReadableProjectIds(user, [projectId], (await this.projectRepository.getPersonalProjectForUser(user.id))?.id)
+                : [];
+            return {
+                surface: 'mcp',
+                projectIds: [projectId],
+                credentialProjectIds,
+                allowedCategories: credentialProjectIds.length > 0 ? ['workflow', 'credential'] : ['workflow'],
+                runsVisible: scope.executionGranted,
+            };
+        }
+        if (scope.surface === 'conversation')
+            return null;
+        if ((0, permissions_1.hasGlobalScope)(user, ['workflow:read'], { mode: 'allOf' })) {
+            const credentialProjectIds = !scope.credentialGranted
+                ? []
+                : (0, permissions_1.hasGlobalScope)(user, ['credential:read'], { mode: 'allOf' })
+                    ? 'all-projects'
+                    : await this.credentialReadableProjectIds(user, null, undefined);
+            return {
+                surface: 'mcp',
+                projectIds: 'all-projects',
+                credentialProjectIds,
+                allowedCategories: credentialProjectIds.length > 0 ? ['workflow', 'credential'] : ['workflow'],
+                runsVisible: scope.executionGranted,
+            };
+        }
+        const [scopedIds, personalProject] = await Promise.all([
+            this.projectService.getProjectIdsWithScope(user, ['workflow:read']),
+            this.projectRepository.getPersonalProjectForUser(user.id),
+        ]);
+        const projectIds = personalProject
+            ? [...new Set([...scopedIds, personalProject.id])]
+            : scopedIds;
+        if (projectIds.length === 0)
+            return null;
+        const credentialProjectIds = scope.credentialGranted
+            ? await this.credentialReadableProjectIds(user, projectIds, personalProject?.id)
+            : [];
+        return {
+            surface: 'mcp',
+            projectIds,
+            credentialProjectIds,
+            allowedCategories: credentialProjectIds.length > 0 ? ['workflow', 'credential'] : ['workflow'],
+            runsVisible: scope.executionGranted,
+        };
+    }
+    async credentialReadableProjectIds(user, projectIds, personalProjectId) {
+        if (projectIds !== null && projectIds.length === 0)
             return [];
-        const allowed = await (0, check_access_1.userHasScopes)(user, ['workflow:read'], false, { projectId });
-        return allowed ? [projectId] : [];
+        const readable = await this.projectService.getProjectIdsWithScope(user, ['credential:read'], projectIds ?? undefined);
+        const readableSet = new Set(readable);
+        if (personalProjectId)
+            readableSet.add(personalProjectId);
+        if (projectIds === null)
+            return [...readableSet];
+        return projectIds.filter((projectId) => readableSet.has(projectId));
+    }
+    async hasWithheldWorkflows(user, scope) {
+        const resolved = await this.resolveScope(user, scope);
+        if (resolved === null)
+            return false;
+        const { total } = await this.workflowRepository.findRecentForProjects(resolved.projectIds, 1, {
+            mcpVisibleOnly: false,
+        });
+        return total > 0;
+    }
+    async withoutWithheldWorkflows(rows, scope) {
+        rows = rows.filter((row) => isCredentialVisible(row, scope));
+        const workflowIds = [
+            ...new Set(rows.flatMap((row) => row.resourceType === 'workflow' && row.resourceId ? [row.resourceId] : [])),
+        ];
+        if (workflowIds.length === 0)
+            return rows;
+        const availability = await this.workflowRepository.findMcpAvailabilityByIds(workflowIds);
+        return rows.filter((row) => {
+            if (row.resourceType !== 'workflow' || !row.resourceId)
+                return true;
+            const available = availability.get(row.resourceId);
+            if (available === undefined)
+                return row.action === 'deleted';
+            return available;
+        });
     }
 };
 exports.InstanceContextService = InstanceContextService;
 exports.InstanceContextService = InstanceContextService = __decorate([
     (0, di_1.Service)(),
-    __metadata("design:paramtypes", [backend_common_1.Logger, config_1.GlobalConfig, db_1.ActivityEventRepository, db_1.ExecutionRepository, db_1.WorkflowRepository])
+    __metadata("design:paramtypes", [backend_common_1.Logger, db_1.ActivityEventRepository, db_1.ExecutionRepository, db_1.WorkflowRepository, db_1.ProjectRepository, project_service_ee_1.ProjectService])
 ], InstanceContextService);
-const initialPreamble = [
+function resolveCategory(requested, scope) {
+    const category = isKnownCategory(requested) ? requested : undefined;
+    if (category !== undefined && !scope.allowedCategories.includes(category))
+        return null;
+    if (scope.surface !== 'mcp')
+        return category;
+    const seesSomeCredentials = scope.credentialProjectIds === 'all-projects' || scope.credentialProjectIds.length > 0;
+    if (seesSomeCredentials)
+        return category;
+    if (category === 'credential')
+        return null;
+    return category ?? 'workflow';
+}
+function isCredentialVisible(row, scope) {
+    if (scope.surface !== 'mcp')
+        return true;
+    if (row.category !== 'credential' && row.resourceType !== 'credential')
+        return true;
+    if (scope.credentialProjectIds === 'all-projects')
+        return true;
+    return scope.credentialProjectIds.includes(row.projectId);
+}
+const toolNames = {
+    conversation: {
+        expand: '`activity(action="expand", id=N)`',
+        list: '`activity(action="list")`',
+        workflows: '`workflows(action="list")`',
+    },
+    mcp: {
+        expand: '`expand_instance_activity(id=N)`',
+        list: '`get_instance_activity`',
+        workflows: '`search_workflows`',
+    },
+};
+const initialPreamble = (tools) => [
     'What is going on in this instance. This is work that already exists and that you can pick up:',
     'when the user is vague ("fix it", "carry on", "what should I look at"), the answer is usually',
     'the most recent thing here, and often the most recent failure. Name what you think they mean',
     'and act on it rather than asking them to choose from a list they can already see.',
     'Do not narrate this back to them — unless they asked what has been happening, let it change',
     'what you do rather than what you say.',
-    'Call `activity(action="expand", id=N)` on a bracketed id to see that entry in full along with',
-    'everything else that happened to the same resource, or `activity(action="list")` to look',
+    `Call ${tools.expand} on a bracketed id to see that entry in full along with`,
+    `everything else that happened to the same resource, or ${tools.list} to look`,
     'further back than this window. An entry may name a resource that no longer exists.',
 ];
-const updatePreamble = [
+const updatePreamble = (tools) => [
     'What has happened since the list earlier in this conversation. Those earlier entries still',
     'stand — these are additions, not a replacement. Read them the same way: context on what the',
     'user has been doing, not a task list or something to comment on unprompted.',
-    '`activity(action="expand", id=N)` and `activity(action="list")` work on these ids too.',
+    `${tools.expand} and ${tools.list} work on these ids too.`,
 ];
-function renderInventory(inventory) {
-    if (inventory.total === 0)
-        return ['Nothing has been built here yet.', ''];
+function renderInventory(inventory, tools, surface) {
+    if (inventory.total === 0) {
+        return surface === 'mcp'
+            ? ['No workflows here are exposed to MCP, so none can be named.', '']
+            : ['Nothing has been built here yet.', ''];
+    }
     const named = inventory.workflows.map((workflow) => `  - "${sanitiseForBlock(workflow.name)}" (workflow:${workflow.id})${workflow.active ? ' [published]' : ''}`);
     const more = inventory.total - inventory.workflows.length;
     return [
         `Workflows that already exist here: ${inventory.total}. Most recently worked on:`,
         ...named,
-        ...(more > 0 ? [`  ... and ${more} more — \`workflows(action="list")\` for the rest.`] : []),
+        ...(more > 0 ? [`  ... and ${more} more — ${tools.workflows} for the rest.`] : []),
         '',
     ];
 }
@@ -241,22 +446,25 @@ function renderRuns(runs, isUpdate, now) {
     return [isUpdate ? 'Runs since then:' : 'Recent runs:', ...lines, ''];
 }
 function renderBlock(input) {
+    const tools = toolNames[input.surface];
     const prose = [
-        ...(input.isUpdate ? updatePreamble : initialPreamble),
+        ...(input.isUpdate ? updatePreamble(tools) : initialPreamble(tools)),
         '',
-        ...(input.inventory ? renderInventory(input.inventory) : []),
+        ...(input.inventory ? renderInventory(input.inventory, tools, input.surface) : []),
         ...renderRuns(input.runs, input.isUpdate, input.now),
         ...(input.entries.length > 0
             ? [
                 input.isUpdate ? 'Changes since then:' : 'What changed recently:',
                 ...input.entries,
                 ...(input.entriesTruncated
-                    ? ['  ... and more than these — `activity(action="list")` for the rest.']
+                    ? [`  ... and more than these — ${tools.list} for the rest.`]
                     : []),
             ]
             : []),
     ].join('\n');
-    return `${internal_messages_1.INSTANCE_CONTEXT_OPEN_TAG}\n${prose}\n${internal_messages_1.INSTANCE_CONTEXT_CLOSE_TAG}`;
+    return input.surface === 'mcp'
+        ? prose
+        : `${internal_messages_1.INSTANCE_CONTEXT_OPEN_TAG}\n${prose}\n${internal_messages_1.INSTANCE_CONTEXT_CLOSE_TAG}`;
 }
 const knownCategories = new Set(db_1.activityEventCategories);
 function isKnownCategory(category) {
@@ -275,14 +483,20 @@ function toActivityEntry(row, currentUserId) {
         ...(row.data ? { detail: row.data } : {}),
     };
 }
-function liveRecordHint(row) {
-    const resourceTypeHints = {
-        workflow: row.resourceId
-            ? `workflows(action="get", workflowId="${row.resourceId}")`
-            : undefined,
-        credential: 'credentials(action="list")',
+function liveRecordHint(row, surface) {
+    const hints = {
+        conversation: {
+            workflow: row.resourceId
+                ? `workflows(action="get", workflowId="${row.resourceId}")`
+                : undefined,
+            credential: 'credentials(action="list")',
+        },
+        mcp: {
+            workflow: row.resourceId ? `get_workflow_details(workflowId="${row.resourceId}")` : undefined,
+            credential: 'list_credentials()',
+        },
     };
-    return row.resourceType ? resourceTypeHints[row.resourceType] : undefined;
+    return row.resourceType ? hints[surface][row.resourceType] : undefined;
 }
 function toFeedEntry(row, currentUserId, now) {
     return [