@agent-native/core 0.114.16 → 0.115.1

package/src/deploy/build.ts

@@ -2345,6 +2345,83 @@ export function isDurableBackgroundDeployEnabled(): boolean {
   return v === "1" || v === "true" || v === "yes" || v === "on";
 }
 
+const NETLIFY_KEEP_WARM_FUNCTION_NAME = "agent-native-keep-warm";
+
+/**
+ * Emit a site-local Netlify Scheduled Function that wakes the public server
+ * function and its database every minute. GitHub Actions schedules can be
+ * delayed by tens of minutes, which is longer than a scale-to-zero database's
+ * autosuspend window and leaves the next visitor to pay the cold-start cost.
+ */
+export function emitSingleTemplateNetlifyKeepWarmFunction(
+  projectCwd: string,
+): void {
+  const internalDir = path.join(projectCwd, ".netlify", "functions-internal");
+  const serverBundle = path.join(internalDir, "server", "main.mjs");
+  if (!fs.existsSync(serverBundle)) {
+    console.warn(
+      "[build] Keep-warm emit skipped: expected Nitro Netlify function at " +
+        ".netlify/functions-internal/server/main.mjs was not found.",
+    );
+    return;
+  }
+
+  const dest = path.join(internalDir, NETLIFY_KEEP_WARM_FUNCTION_NAME);
+  fs.rmSync(dest, { recursive: true, force: true });
+  fs.mkdirSync(dest, { recursive: true });
+
+  const entry = `const HEALTH_PATH = "/_agent-native/health";
+const REQUEST_TIMEOUT_MS = 25_000;
+
+function siteOrigin(request) {
+  const configured = process.env.URL || process.env.DEPLOY_URL;
+  if (configured) return configured;
+  return new URL(request.url).origin;
+}
+
+export default async function handler(request) {
+  const url = new URL(HEALTH_PATH, siteOrigin(request));
+  let response;
+  try {
+    response = await fetch(url, {
+      headers: { "user-agent": "agent-native-netlify-keep-warm" },
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+    });
+  } catch (error) {
+    console.error("[agent-native-keep-warm] Health request failed:", url.toString(), error);
+    throw error;
+  }
+
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    throw new Error(
+      "[agent-native-keep-warm] Health request failed with " +
+        response.status +
+        ": " +
+        body.slice(0, 500),
+    );
+  }
+
+  console.log("[agent-native-keep-warm] Warmed", url.toString());
+  return new Response(null, { status: 204 });
+}
+
+export const config = {
+  name: "agent-native server keep warm",
+  generator: "agent-native build",
+  schedule: "* * * * *",
+};
+`;
+
+  fs.writeFileSync(
+    path.join(dest, `${NETLIFY_KEEP_WARM_FUNCTION_NAME}.mjs`),
+    entry,
+  );
+  console.log(
+    `[build] Emitted Netlify scheduled keep-warm function "${NETLIFY_KEEP_WARM_FUNCTION_NAME}".`,
+  );
+}
+
 /**
  * Single-template Netlify build: emit an async (background) function INSIDE the
  * scanned functions dir so the chat `_process-run` worker runs on Netlify's
@@ -3528,24 +3605,26 @@ export default bundle;
     bundleYjsRuntimeForServerlessOutput(nitro.options.output.serverDir, cwd);
   }
 
-  // Durable background agent runs (default-OFF / opt-in; enable with a truthy
-  // AGENT_CHAT_DURABLE_BACKGROUND). Additive ONLY: emits a SECOND Netlify
-  // function whose name ends in `-background` re-exporting the same handler
-  // bundle, so the chat `_process-run` POST lands on Netlify's async (15-min)
-  // function. When not opted in this is a no-op and the single-function
-  // deploy is byte-for-byte unchanged.
-  if (preset === "netlify" && isDurableBackgroundDeployEnabled()) {
-    try {
-      emitSingleTemplateNetlifyBackgroundFunction(cwd);
-    } catch (err) {
-      console.warn(
-        "[build] Failed to emit durable-background Netlify function (non-fatal):",
-        err instanceof Error ? err.message : err,
-      );
+  if (preset === "netlify") {
+    emitSingleTemplateNetlifyKeepWarmFunction(cwd);
+
+    // Durable background agent runs (default-OFF / opt-in; enable with a truthy
+    // AGENT_CHAT_DURABLE_BACKGROUND). Additive ONLY: emits a SECOND Netlify
+    // function whose name ends in `-background` re-exporting the same handler
+    // bundle, so the chat `_process-run` POST lands on Netlify's async (15-min)
+    // function. When not opted in this is a no-op and the single-function
+    // deploy is byte-for-byte unchanged.
+    if (isDurableBackgroundDeployEnabled()) {
+      try {
+        emitSingleTemplateNetlifyBackgroundFunction(cwd);
+      } catch (err) {
+        console.warn(
+          "[build] Failed to emit durable-background Netlify function (non-fatal):",
+          err instanceof Error ? err.message : err,
+        );
+      }
     }
-  }
 
-  if (preset === "netlify") {
     writeSingleTemplateNetlifyRedirects(cwd);
     assertSingleTemplateNetlifyBuildOutput(cwd);
   }

package/src/eject/provider-api-definitions.ts

@@ -44,6 +44,7 @@ export const providerApiOverrides: ProviderApiConfig[] = [
   provider("granola"),
   provider("grafana"),
   provider("hubspot"),
+  provider("salesforce"),
   provider("jira"),
   provider("mixpanel"),
   provider("notion"),

package/src/eject/workspace-connections.ts

@@ -19,6 +19,7 @@ export const WORKSPACE_CONNECTION_PROVIDERS: WorkspaceConnectionProvider[] = [
   "gmail",
   "google_drive",
   "hubspot",
+  "salesforce",
   "jira",
   "sentry",
   "granola",

package/src/extensions/actions.ts

@@ -623,7 +623,7 @@ export function createExtensionActionEntries(): Record<string, ActionEntry> {
     "update-extension": {
       tool: {
         description:
-          'Update an existing sandboxed Alpine.js mini-app extension. If the user is viewing the extension, use the extensionId from <current-screen> or <current-url> directly; do not list extensions first just to find the current id. Prefer granular edits for surgical changes; full-body replacement is blocked by default to preserve existing layout, CSS, copy, and interactions during data-only fixes. Use `patches` or `edits` for targeted changes; set `allowFullReplacement=true` only when the user explicitly asks for a visual rewrite or supplies a complete replacement body. Supported edits include literal replace, insert-before/after marker, replace-between markers, replace-section/wrap-section/remove-section for <!-- agent-native:section name --> blocks, and regex-replace. Pass format=true to run Prettier on the final HTML. To replace the whole body with a large pasted file, pass contentFromAttachment (the attachment name, or "latest") instead of copying the file into `content` — that avoids re-emitting thousands of tokens.',
+          'Update an existing sandboxed Alpine.js mini-app extension. Pass exactly three fields: `id`, `operation`, and `payloadJson`. `payloadJson` is a JSON object encoded as a string so model gateways cannot fill its optional members with invalid empty placeholders. For operation="edit", pass {"edits":[...]} or {"patches":[...]} and optional format=true. For operation="replace", pass exactly one of content, contentFromAttachment, or contentFromWorkspaceFile; use this operation only for a user-requested broad visual rewrite or complete replacement body. For operation="metadata", pass name, description, or icon. Change sharing through set-resource-visibility instead. If the user is viewing the extension, use the extensionId from <current-screen> or <current-url> directly.',
         parameters: {
           type: "object",
           properties: {
@@ -632,72 +632,35 @@ export function createExtensionActionEntries(): Record<string, ActionEntry> {
               description:
                 "Extension id to update. Prefer the extensionId from <current-screen> or <current-url> for the current extension.",
             },
-            name: {
-              type: "string",
-              description: "Optional new display name.",
-            },
-            description: {
-              type: "string",
-              description: "Optional new description.",
-            },
-            content: {
-              type: "string",
-              description:
-                "Optional full replacement Alpine.js HTML body snippet.",
-            },
-            contentFromAttachment: {
+            operation: {
               type: "string",
+              enum: ["edit", "replace", "metadata"],
               description:
-                'Optional full replacement sourced from a pasted/attached file on the current turn, by attachment name (or the literal "latest" for the most recent pasted block). Use instead of `content` when replacing the whole body with a large pasted file so you do not have to re-type it. Ignored when `content` is provided.',
+                'The single update mode: "edit" for focused patches/edits, "replace" for an explicitly authorized complete body replacement, or "metadata" for name/description/icon.',
             },
-            contentFromWorkspaceFile: {
+            payloadJson: {
               type: "string",
+              minLength: 2,
               description:
-                'Optional full replacement sourced from a workspace/shared resource file, by resource path (e.g. "intuit-analytics-extension.html"). The server reads the full file and uses it as the replacement body. Use instead of `content` when replacing the whole body with a large file that exists as a workspace resource. Ignored when `content` is provided.',
-            },
-            allowFullReplacement: {
-              type: "boolean",
-              description:
-                "Explicitly allow replacing the entire existing body. Omit or set false for data-only repairs so the existing visual design is protected. Use true only when the user explicitly requested a broad visual rewrite or supplied a complete replacement body.",
-            },
-            patches: {
-              anyOf: [
-                { type: "string" },
-                { type: "array", items: { type: "object" } },
-              ],
-              description:
-                'Optional patches as a JSON-encoded string or native array of { "find": "...", "replace": "...", "all"?: true, "expectedMatches"?: 1, "required"?: true } objects. Missing required targets fail instead of silently no-oping.',
-            },
-            edits: {
-              anyOf: [
-                { type: "string" },
-                { type: "array", items: { type: "object" } },
-              ],
-              description:
-                'Preferred optional granular edit operations as a JSON-encoded string or native array. Examples: { "op": "insert-after", "marker": "<!-- section:metrics -->", "content": "..." }, { "op": "replace-section", "section": "npm-chart", "content": "..." }, { "op": "wrap-section", "section": "charts", "before": "<div>", "after": "</div>" }, { "op": "regex-replace", "pattern": "...", "replace": "...", "expectedMatches": 1 }.',
-            },
-            format: {
-              type: "boolean",
-              description:
-                "When true, format the final extension HTML with Prettier after applying content, patches, and edits.",
-            },
-            icon: {
-              type: "string",
-              description: "Optional icon name or short label.",
-            },
-            visibility: {
-              type: "string",
-              description:
-                "Optional sharing visibility. Public extension sharing is not supported; use private or org.",
-              enum: ["private", "org"],
+                'A non-empty JSON object encoded as a string. edit example: {"edits":[{"op":"replace","find":"old","replace":"new"}],"format":true}. replace example: {"contentFromAttachment":"latest"}. metadata example: {"name":"New name"}.',
             },
           },
-          required: ["id"],
+          required: ["id", "operation", "payloadJson"],
+          additionalProperties: false,
         },
       },
       run: async (args, ctx) => {
+        const normalizedUpdate = normalizeUpdateExtensionArgs(args);
+        if ("error" in normalizedUpdate) return normalizedUpdate.error;
+        args = normalizedUpdate.args;
         const id = String(args?.id ?? "").trim();
         if (!id) return "Error: id is required.";
+        if (
+          args?.name !== undefined &&
+          (typeof args.name !== "string" || args.name.trim().length === 0)
+        ) {
+          return "Error: extension name must be a non-empty string. No changes were applied.";
+        }
         const localMessage = await localExtensionEditMessage(id);
         if (localMessage) return localMessage;
 
@@ -722,11 +685,19 @@ export function createExtensionActionEntries(): Record<string, ActionEntry> {
           });
         }
 
+        const attachmentRef =
+          typeof args?.contentFromAttachment === "string"
+            ? args.contentFromAttachment.trim()
+            : "";
+        const workspaceFileRef =
+          typeof args?.contentFromWorkspaceFile === "string"
+            ? args.contentFromWorkspaceFile.trim()
+            : "";
         const fullReplacementRequested =
           (typeof args?.content === "string" &&
             args.content.trim().length > 0) ||
-          args?.contentFromAttachment !== undefined ||
-          args?.contentFromWorkspaceFile !== undefined;
+          attachmentRef.length > 0 ||
+          workspaceFileRef.length > 0;
         if (
           fullReplacementRequested &&
           !coerceBoolean(args?.allowFullReplacement)
@@ -748,8 +719,7 @@ export function createExtensionActionEntries(): Record<string, ActionEntry> {
             : undefined;
         if (
           replacementContent === undefined &&
-          (args?.contentFromAttachment !== undefined ||
-            args?.contentFromWorkspaceFile !== undefined)
+          (attachmentRef.length > 0 || workspaceFileRef.length > 0)
         ) {
           const resolved = await resolveExtensionContentAsync(args, ctx);
           if ("error" in resolved) return resolved.error;
@@ -757,20 +727,20 @@ export function createExtensionActionEntries(): Record<string, ActionEntry> {
         }
 
         let result = null;
+        const patches = parsePatches((args as any).patches);
+        if (args?.patches !== undefined && !patches) {
+          return "Error: patches must be a JSON array of { find, replace } objects.";
+        }
+        const edits = parseEdits((args as any).edits);
+        if (args?.edits !== undefined && !edits) {
+          return "Error: edits must be a JSON array of supported extension edit operations.";
+        }
         const hasContentUpdate =
           replacementContent !== undefined ||
-          args?.patches !== undefined ||
-          args?.edits !== undefined ||
-          args?.format !== undefined;
+          (patches?.length ?? 0) > 0 ||
+          (edits?.length ?? 0) > 0 ||
+          coerceBoolean(args?.format);
         if (hasContentUpdate) {
-          const patches = parsePatches((args as any).patches);
-          if (args?.patches !== undefined && !patches) {
-            return "Error: patches must be a JSON array of { find, replace } objects.";
-          }
-          const edits = parseEdits((args as any).edits);
-          if (args?.edits !== undefined && !edits) {
-            return "Error: edits must be a JSON array of supported extension edit operations.";
-          }
           try {
             result = await updateExtensionContent(id, {
               content: replacementContent,
@@ -806,13 +776,15 @@ export function createExtensionActionEntries(): Record<string, ActionEntry> {
           meta.description = String(args.description).trim();
         }
         if (args?.icon !== undefined) meta.icon = String(args.icon);
-        if (args?.visibility !== undefined) {
+        if (args?.visibility !== undefined)
           meta.visibility = String(args.visibility);
-        }
         if (Object.keys(meta).length > 0) {
           result = await updateExtension(id, meta as any);
         }
 
+        if (!result && !hasContentUpdate && Object.keys(meta).length === 0) {
+          return "Error: update-extension received no actual changes. Choose one operation and provide a non-empty payloadJson object; empty placeholder fields are not an update.";
+        }
         if (!result) result = await getExtension(id);
         if (!result) return `Error: extension not found: ${id}`;
         const hiddenIds = await getHiddenExtensionIdsForCurrentUser();
@@ -1444,7 +1416,7 @@ async function summarizeExtensionForAgentRead(
       reason: "unchanged-content-already-returned-this-run",
       contentHash: fingerprint,
       contentLength: row.content.length,
-      next: "Use the content already returned earlier in this run and call update-extension with focused edits/patches. Set forceContent=true only if you truly need the full body again.",
+      next: 'Use the content already returned earlier in this run and call update-extension with operation="edit" plus focused edits/patches inside payloadJson. Set forceContent=true only if you truly need the full body again.',
     },
   };
 }
@@ -1746,6 +1718,160 @@ function coerceBoolean(value: unknown): boolean {
   return value === true || value === "true";
 }
 
+function normalizeUpdateExtensionArgs(
+  args: any,
+): { args: Record<string, unknown> } | { error: string } {
+  const hasCompactContract =
+    args?.operation !== undefined || args?.payloadJson !== undefined;
+  if (!hasCompactContract) {
+    const legacyArgs = { ...((args ?? {}) as Record<string, unknown>) };
+    const hasInvalidPlaceholderSignal =
+      (typeof legacyArgs.visibility === "string" &&
+        legacyArgs.visibility.trim().length === 0) ||
+      [legacyArgs.patches, legacyArgs.edits].some(
+        (value) =>
+          value !== null &&
+          typeof value === "object" &&
+          (Array.isArray(value)
+            ? value.length > 0 &&
+              value.every(
+                (item) =>
+                  item !== null &&
+                  typeof item === "object" &&
+                  !Array.isArray(item) &&
+                  Object.keys(item).length === 0,
+              )
+            : Object.keys(value).length === 0),
+      );
+    if (hasInvalidPlaceholderSignal) {
+      for (const [key, value] of Object.entries(legacyArgs)) {
+        if (key === "id") continue;
+        const empty =
+          value === false ||
+          value === null ||
+          (typeof value === "string" && value.trim().length === 0) ||
+          (Array.isArray(value) &&
+            (value.length === 0 ||
+              value.every(
+                (item) =>
+                  item !== null &&
+                  typeof item === "object" &&
+                  !Array.isArray(item) &&
+                  Object.keys(item).length === 0,
+              ))) ||
+          (typeof value === "object" &&
+            value !== null &&
+            !Array.isArray(value) &&
+            Object.keys(value).length === 0);
+        if (empty) delete legacyArgs[key];
+      }
+      delete legacyArgs.visibility;
+    }
+    return { args: legacyArgs };
+  }
+
+  const operation = String(args?.operation ?? "").trim();
+  if (!(["edit", "replace", "metadata"] as const).includes(operation as any)) {
+    return {
+      error:
+        'Error: operation must be "edit", "replace", or "metadata". No changes were applied.',
+    };
+  }
+
+  let payload: unknown;
+  try {
+    payload = JSON.parse(String(args?.payloadJson ?? ""));
+  } catch {
+    return {
+      error:
+        "Error: payloadJson must be a valid JSON object encoded as a string. No changes were applied.",
+    };
+  }
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    return {
+      error:
+        "Error: payloadJson must decode to a non-empty JSON object. No changes were applied.",
+    };
+  }
+
+  const payloadRecord = payload as Record<string, unknown>;
+  const allowedByOperation: Record<string, Set<string>> = {
+    edit: new Set(["patches", "edits", "format"]),
+    replace: new Set([
+      "content",
+      "contentFromAttachment",
+      "contentFromWorkspaceFile",
+      "format",
+    ]),
+    metadata: new Set(["name", "description", "icon"]),
+  };
+  const unexpected = Object.keys(payloadRecord).filter(
+    (key) => !allowedByOperation[operation].has(key),
+  );
+  if (unexpected.length > 0) {
+    return {
+      error: `Error: operation=${operation} does not accept ${unexpected.join(", ")}. No changes were applied.`,
+    };
+  }
+
+  if (operation === "edit") {
+    const patches = parsePatches(payloadRecord.patches);
+    const edits = parseEdits(payloadRecord.edits);
+    const hasEdit =
+      (patches?.length ?? 0) > 0 ||
+      (edits?.length ?? 0) > 0 ||
+      coerceBoolean(payloadRecord.format);
+    if (!hasEdit) {
+      return {
+        error:
+          "Error: operation=edit requires at least one valid patch/edit or format=true. No changes were applied.",
+      };
+    }
+  }
+
+  if (operation === "replace") {
+    const replacementSources = [
+      payloadRecord.content,
+      payloadRecord.contentFromAttachment,
+      payloadRecord.contentFromWorkspaceFile,
+    ].filter((value) => typeof value === "string" && value.trim().length > 0);
+    if (replacementSources.length !== 1) {
+      return {
+        error:
+          "Error: operation=replace requires exactly one non-empty content, contentFromAttachment, or contentFromWorkspaceFile value. No changes were applied.",
+      };
+    }
+  }
+
+  if (operation === "metadata") {
+    const keys = Object.keys(payloadRecord);
+    if (keys.length === 0) {
+      return {
+        error:
+          "Error: operation=metadata requires name, description, or icon. No changes were applied.",
+      };
+    }
+    if (
+      payloadRecord.name !== undefined &&
+      (typeof payloadRecord.name !== "string" ||
+        payloadRecord.name.trim().length === 0)
+    ) {
+      return {
+        error:
+          "Error: extension name must be a non-empty string. No changes were applied.",
+      };
+    }
+  }
+
+  return {
+    args: {
+      id: String(args?.id ?? "").trim(),
+      ...payloadRecord,
+      ...(operation === "replace" ? { allowFullReplacement: true } : {}),
+    },
+  };
+}
+
 function parseInlineContext(
   value: unknown,
 ): Record<string, unknown> | undefined {

package/src/jobs/actions/list-recurring-jobs.ts

@@ -46,6 +46,7 @@ export interface RecurringJobActionItem {
   lastError: string | null;
   nextRun: string | null;
   createdBy: string | null;
+  mcpTools: string[];
   canUpdate: boolean;
 }
 
@@ -96,6 +97,7 @@ export default defineAction({
         lastError: meta.lastError ?? null,
         nextRun: nextRun(meta),
         createdBy: meta.createdBy ?? null,
+        mcpTools: meta.mcpTools ?? [],
         canUpdate,
       });
     }

package/src/jobs/scheduler.ts

@@ -42,6 +42,50 @@ export interface JobFrontmatter {
   deliveryThreadRef?: string;
   deliveryTenantId?: string;
   model?: string;
+  /** Explicit MCP tool capabilities available to this background run. */
+  mcpTools?: string[];
+}
+
+const MAX_JOB_MCP_TOOLS = 64;
+const JOB_MCP_TOOL_NAME_RE = /^mcp__[^\s]+__[^\s]+$/;
+
+/**
+ * Normalize the non-secret MCP capability references persisted with a job.
+ * Tool names are opaque framework identifiers; URLs and credentials never
+ * belong in job frontmatter.
+ */
+export function normalizeJobMcpTools(value: unknown): string[] | undefined {
+  if (value === undefined || value === null) return undefined;
+  const parsed =
+    typeof value === "string"
+      ? (() => {
+          try {
+            return JSON.parse(value);
+          } catch {
+            throw new Error("mcpTools must be a JSON array of tool names.");
+          }
+        })()
+      : value;
+  if (!Array.isArray(parsed)) {
+    throw new Error("mcpTools must be an array of MCP tool names.");
+  }
+  if (parsed.length > MAX_JOB_MCP_TOOLS) {
+    throw new Error(
+      `mcpTools may contain at most ${MAX_JOB_MCP_TOOLS} tool names.`,
+    );
+  }
+  const normalized = [...new Set(parsed)];
+  if (
+    normalized.some(
+      (toolName) =>
+        typeof toolName !== "string" || !JOB_MCP_TOOL_NAME_RE.test(toolName),
+    )
+  ) {
+    throw new Error(
+      "mcpTools must contain only framework MCP tool names such as mcp__server__tool.",
+    );
+  }
+  return normalized;
 }
 
 const FRONTMATTER_RE = /^---\n([\s\S]*?)\n---\n?([\s\S]*)$/;
@@ -129,6 +173,14 @@ export function parseJobFrontmatter(content: string): {
       case "model":
         meta.model = value;
         break;
+      case "mcpTools":
+        try {
+          meta.mcpTools = normalizeJobMcpTools(value);
+        } catch {
+          // Ignore malformed optional capability metadata and keep the job
+          // readable; newly-created jobs are validated before persistence.
+        }
+        break;
     }
   }
 
@@ -166,6 +218,8 @@ export function buildJobContent(meta: JobFrontmatter, body: string): string {
   if (meta.deliveryTenantId)
     lines.push(`deliveryTenantId: ${meta.deliveryTenantId}`);
   if (meta.model) lines.push(`model: ${meta.model}`);
+  if (meta.mcpTools?.length)
+    lines.push(`mcpTools: ${JSON.stringify(meta.mcpTools)}`);
   lines.push(`---`);
   lines.push("");
   lines.push(body);
@@ -174,8 +228,15 @@ export function buildJobContent(meta: JobFrontmatter, body: string): string {
 
 // ─── Job execution ──────────────────────────────────────────────────────────
 
+export interface RecurringJobContext {
+  name: string;
+  meta: JobFrontmatter;
+  body: string;
+  resource: Resource;
+}
+
 export interface SchedulerDeps {
-  getActions: () => Record<string, ActionEntry>;
+  getActions: (job?: RecurringJobContext) => Record<string, ActionEntry>;
   getSystemPrompt: (owner: string) => Promise<string>;
   /**
    * Tool names to expose on the FIRST engine request for a job run. When
@@ -188,7 +249,7 @@ export interface SchedulerDeps {
    * merged actions are the app's own vs. framework additions, so this must
    * be supplied explicitly rather than inferred here.
    */
-  getInitialToolNames?: () => string[] | undefined;
+  getInitialToolNames?: (job?: RecurringJobContext) => string[] | undefined;
   /** Optional engine override. Defaults to the resolved request engine. */
   engine?: AgentEngine;
   apiKey?: string;
@@ -477,9 +538,15 @@ async function executeJob(
     },
     async () => {
       try {
-        const baseActions = deps.getActions();
+        const jobContext: RecurringJobContext = {
+          name: jobName,
+          meta,
+          body,
+          resource,
+        };
+        const baseActions = deps.getActions(jobContext);
         const systemPrompt = await deps.getSystemPrompt(jobUserEmail);
-        const initialToolNames = deps.getInitialToolNames?.();
+        const initialToolNames = deps.getInitialToolNames?.(jobContext);
         // Only attach tool-search (and pay its schema cost) when the caller
         // actually supplied an initial subset to filter down to — otherwise
         // this is byte-for-byte the prior unfiltered behavior.