@agent-native/core 0.97.0 → 0.98.1

package/corpus/core/src/client/use-db-sync.ts

@@ -5,6 +5,7 @@ import {
   refreshDemoModeFetchInterceptor,
 } from "../demo/fetch-interceptor.js";
 import { agentNativePath } from "./api-path.js";
+import { getBrowserTabId } from "./browser-tab-id.js";
 import {
   ensureEmbedAuthFetchInterceptor,
   isEmbedAuthActive,
@@ -16,15 +17,25 @@ interface Query {
 }
 
 interface QueryClient {
-  invalidateQueries(opts?: {
+  invalidateQueries(
+    opts?: {
+      queryKey?: string[];
+      predicate?: (query: Query) => boolean;
+    },
+    options?: { cancelRefetch?: boolean },
+  ): unknown;
+  isFetching?(filters?: {
     queryKey?: string[];
     predicate?: (query: Query) => boolean;
-  }): void;
+  }): number;
 }
 
 const POLL_ABORT_MIN_MS = 10_000;
-const SSE_FALLBACK_INTERVAL_MS = 15_000;
-const IDLE_POLL_INTERVAL_MS = 15_000;
+// SSE delivers changes immediately in the normal path. The poll is a
+// cross-process/serverless safety net, so an idle tab should not bill the host
+// four times per minute forever. Focus and active agent work still poll now.
+const SSE_FALLBACK_INTERVAL_MS = 60_000;
+const IDLE_POLL_INTERVAL_MS = 60_000;
 const POLL_AUTH_FAILURE_COOLDOWN_MS = 60_000;
 /**
  * Max cadence for SSE/poll-driven query invalidation in `useDbSync`. Events
@@ -356,7 +367,7 @@ class SyncTransport {
     // full cadence. Resets on the first successful poll.
     const delay =
       this.consecutiveFailures > 0
-        ? Math.min(base * 2 ** Math.min(this.consecutiveFailures, 5), 30_000)
+        ? Math.min(base * 2 ** Math.min(this.consecutiveFailures, 5), 300_000)
         : base;
     this.timer = setTimeout(() => {
       this.timer = null;
@@ -675,7 +686,7 @@ export function subscribeSyncEvents(
  * @param options.onEvent - Optional callback for each change event
  * @param options.interval - Poll interval in ms. Default: 2000
  * @param options.fallbackInterval - Poll interval while SSE is connected.
- *   Default: 15000
+ *   Default: 60000
  * @param options.pauseWhenHidden - Pause polling while the tab is hidden.
  *   Default: true
  * @param options.ignoreSource - Skip events whose `requestSource` matches this
@@ -798,9 +809,15 @@ export function useDbSync(
 
     function invalidateForEvents(events: SyncEvent[]) {
       const ignore = ignoreSourceRef.current;
-      const relevant = ignore
-        ? events.filter((e) => e.requestSource !== ignore)
-        : events;
+      const ownBrowserSource = getBrowserTabId();
+      const relevant = events.filter(
+        (event) =>
+          !(
+            event.source === "action" &&
+            event.requestSource === ownBrowserSource
+          ) &&
+          (!ignore || event.requestSource !== ignore),
+      );
       const suppressedActions = new Set(
         suppressActionInvalidationForRef.current ?? [],
       );
@@ -838,18 +855,43 @@ export function useDbSync(
       const invalidating = relevant.filter((e) => e.source !== "awareness");
 
       if (invalidating.length > 0 && queryClient) {
+        // Sync events describe completed writes. If a matching read is already
+        // in flight, let it finish instead of aborting and immediately
+        // launching the same request again. Repeated action events otherwise
+        // turn a slow endpoint into a cancel/restart loop that never settles.
+        const invalidateWithoutCancel = (filters?: {
+          queryKey?: string[];
+          predicate?: (query: Query) => boolean;
+        }) => {
+          const needsTrailingRefresh =
+            (queryClient.isFetching?.(filters) ?? 0) > 0;
+          const completion = queryClient.invalidateQueries(filters, {
+            cancelRefetch: false,
+          });
+          // TanStack Query deliberately leaves an in-flight fetch alone when
+          // cancelRefetch is false. Queue one post-settlement invalidation so
+          // a write that landed after that read began cannot be cleared as
+          // fresh by the older response.
+          if (needsTrailingRefresh && completion instanceof Promise) {
+            void completion.then(
+              () => queryClient.invalidateQueries(filters),
+              () => {},
+            );
+          }
+        };
         const hasActionEvent = invalidating.some(
           (evt) => evt.source === "action" && !isSuppressedActionEvent(evt),
         );
         if (hasActionEvent) {
-          // Custom apps frequently start with raw `useQuery` calls before
-          // graduating to `useActionQuery` or source-versioned query keys.
-          // A successful mutating action is the core "agent changed app data"
-          // signal, so refresh active queries broadly as a compatibility
-          // safety net. Other event sources stay targeted to avoid request
-          // storms from noisy domain-specific writes.
+          // Action-backed reads share the ["action"] prefix. Keep the default
+          // refresh targeted to those queries; invalidating every active query
+          // makes one agent write fan out across unrelated provider reads,
+          // dashboards, and background status checks. Older apps that still
+          // need broad compatibility can opt in with a predicate.
           const predicate = actionInvalidatePredicateRef.current;
-          queryClient.invalidateQueries(predicate ? { predicate } : undefined);
+          invalidateWithoutCancel(
+            predicate ? { predicate } : { queryKey: ["action"] },
+          );
         }
 
         // Framework-level invalidate: a small, fixed list of query-key
@@ -880,32 +922,40 @@ export function useDbSync(
           const hasDataChangingEvent = invalidating.some(
             (evt) => evt.source !== "app-state",
           );
-          // The broad action invalidate above already covers every fixed
-          // framework prefix. Re-invalidating ["action"] immediately after it
-          // cancels/restarts the same active reads and creates a duplicate
-          // request wave. Keep the fixed-prefix pass for non-action sources;
-          // action batches get exactly one compatibility invalidation.
-          if (hasDataChangingEvent && !hasActionEvent) {
-            queryClient.invalidateQueries({ queryKey: ["action"] });
-            queryClient.invalidateQueries({ queryKey: ["extension"] });
-            queryClient.invalidateQueries({ queryKey: ["extensions"] });
-            queryClient.invalidateQueries({ queryKey: ["extension-slots"] });
-            queryClient.invalidateQueries({ queryKey: ["slot-installs"] });
-            queryClient.invalidateQueries({ queryKey: ["slot-available"] });
-            queryClient.invalidateQueries({ queryKey: ["tool"] });
-            queryClient.invalidateQueries({ queryKey: ["tools"] });
+          if (hasDataChangingEvent) {
+            const hasFrameworkPrefixEvent = invalidating.some((evt) =>
+              ["extensions", "extension", "tool", "tools", "slots"].includes(
+                evt.source ?? "",
+              ),
+            );
+            // The action-specific invalidation above already refreshed
+            // ["action"]. A mixed action + extension/tool batch still needs
+            // the independent framework prefixes, while pure action batches
+            // retain their narrow storm-resistant invalidation.
+            if (!hasActionEvent) {
+              invalidateWithoutCancel({ queryKey: ["action"] });
+            }
+            if (!hasActionEvent || hasFrameworkPrefixEvent) {
+              invalidateWithoutCancel({ queryKey: ["extension"] });
+              invalidateWithoutCancel({ queryKey: ["extensions"] });
+              invalidateWithoutCancel({ queryKey: ["extension-slots"] });
+              invalidateWithoutCancel({ queryKey: ["slot-installs"] });
+              invalidateWithoutCancel({ queryKey: ["slot-available"] });
+              invalidateWithoutCancel({ queryKey: ["tool"] });
+              invalidateWithoutCancel({ queryKey: ["tools"] });
+            }
           }
           if (invalidating.some((evt) => evt.source === "app-state")) {
-            queryClient.invalidateQueries({ queryKey: ["app-state"] });
+            invalidateWithoutCancel({ queryKey: ["app-state"] });
           }
           if (hasAppStateEvent(invalidating, "navigate")) {
-            queryClient.invalidateQueries({ queryKey: ["navigate-command"] });
+            invalidateWithoutCancel({ queryKey: ["navigate-command"] });
           }
           if (hasAppStateEvent(invalidating, "show-questions")) {
-            queryClient.invalidateQueries({ queryKey: ["show-questions"] });
+            invalidateWithoutCancel({ queryKey: ["show-questions"] });
           }
           if (hasAppStateEvent(invalidating, "__set_url__")) {
-            queryClient.invalidateQueries({ queryKey: ["__set_url__"] });
+            invalidateWithoutCancel({ queryKey: ["__set_url__"] });
           }
         }
       }

package/corpus/core/src/client/use-pausing-interval.ts

@@ -17,9 +17,19 @@ export function usePausingInterval(
   useEffect(() => {
     if (pollMs <= 0) return;
     let id: ReturnType<typeof setInterval> | null = null;
+    let running = false;
     const isHidden = () => typeof document !== "undefined" && document.hidden;
+    const run = async () => {
+      if (running) return;
+      running = true;
+      try {
+        await callback();
+      } finally {
+        running = false;
+      }
+    };
     const start = () => {
-      if (id == null) id = setInterval(callback, pollMs);
+      if (id == null) id = setInterval(() => void run(), pollMs);
     };
     const stop = () => {
       if (id != null) {
@@ -29,7 +39,7 @@ export function usePausingInterval(
     };
 
     if (!pauseWhenHidden) {
-      callback();
+      void run();
       start();
       return () => stop();
     }
@@ -38,12 +48,12 @@ export function usePausingInterval(
       if (document.hidden) {
         stop();
       } else {
-        callback();
+        void run();
         start();
       }
     };
     if (!isHidden()) {
-      callback();
+      void run();
       start();
     }
     document.addEventListener("visibilitychange", onVisibility);

package/corpus/core/src/client/visual-style-controls.tsx

@@ -336,7 +336,7 @@ export function VisualSwatchControl({
             aria-label={option.label}
             onClick={() => onChange(option.value)}
             className={cn(
-              "size-5 cursor-pointer rounded-md border border-border/70 transition-all hover:scale-105 hover:border-foreground/40 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring",
+              "size-5 cursor-pointer rounded-md border border-border/70 transition-[transform,border-color] hover:scale-105 hover:border-foreground/40 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring",
               value === option.value &&
                 "border-foreground/70 ring-2 ring-foreground/40 ring-offset-1 ring-offset-card",
             )}

package/corpus/core/src/deploy/build.ts

@@ -763,6 +763,7 @@ export function generateWorkerEntry(
 import { H3, defineEventHandler, readBody, toResponse } from "h3";
 ${includeReactRouterSsr ? 'import { createRequestHandler } from "react-router";' : ""}
 ${includeReactRouterSsr ? 'import * as serverBuild from "./server-build.js";' : ""}
+${includeReactRouterSsr ? `import { runWithRequestContext } from "${EDGE_SERVER_ENTRYPOINT}";` : ""}
 
 function normalizeAppBasePath(value) {
   if (!value || value === "/") return "";
@@ -984,20 +985,25 @@ function isSsrHtmlOrDataResponse(headers, status, pathname) {
 /**
  * Apply the SSR cache policy to the response headers.
  *
- * Unannotated SSR HTML and React Router .data responses share a public
- * stale-while-revalidate cache policy. Preserve an explicit route policy,
- * though: token-gated and personalized routes can opt out with private or
- * no-store policies.
+ * SSR HTML and React Router .data responses are one impersonal public shell.
+ * Always overwrite route cache hints so generated edge workers cannot drift
+ * from the canonical Nitro/Netlify handler or send normal pages to origin.
  */
 function applyDefaultSsrCacheHeader(headers, status, pathname) {
   if (!isSsrHtmlOrDataResponse(headers, status, pathname)) return;
-  // React Router marks every .data response as no-cache, but those loader
-  // payloads are safe to cache at the shared edge. Preserve only explicit
-  // private/no-store policies, which token-gated and personalized routes use
-  // to opt out of shared caching.
-  const cacheControl = headers.get("cache-control")?.toLowerCase() ?? "";
-  if (cacheControl.includes("private") || cacheControl.includes("no-store")) {
-    return;
+
+  headers.delete("set-cookie");
+  const vary = headers.get("vary");
+  if (vary) {
+    const publicVary = vary
+      .split(",")
+      .map((value) => value.trim())
+      .filter((value) => {
+        const normalized = value.toLowerCase();
+        return normalized && normalized !== "*" && normalized !== "cookie" && normalized !== "authorization";
+      });
+    if (publicVary.length > 0) headers.set("vary", publicVary.join(", "));
+    else headers.delete("vary");
   }
 
   headers.set("cache-control", DEFAULT_SSR_CACHE_CONTROL);
@@ -1096,6 +1102,13 @@ function requestWithPathname(request, pathname) {
   return new Request(url, request);
 }
 
+function requestForAnonymousSsr(request) {
+  const headers = new Headers(request.headers);
+  headers.delete("cookie");
+  headers.delete("authorization");
+  return new Request(request, { headers });
+}
+
 function isStaticAppShellRequest(request) {
   if (request.method !== "GET" && request.method !== "HEAD") return false;
   const p = stripAppBasePath(new URL(request.url).pathname);
@@ -1214,10 +1227,14 @@ ${
     ) {
       return new Response(null, { status: 404 });
     }
-    const request = requestWithPathname(event.req, p);
+    const request = requestForAnonymousSsr(requestWithPathname(event.req, p));
+    const anonymousContext = { userEmail: undefined, orgId: undefined };
     if (event.req.method === "HEAD") {
       const getRequest = requestWithMethod(request, "GET");
-      const response = await rrHandler(getRequest);
+      const response = await runWithRequestContext(
+        anonymousContext,
+        () => rrHandler(getRequest)
+      );
       return rewriteMountedResponse(
         new Response(null, {
           status: response.status,
@@ -1229,7 +1246,12 @@ ${
         getRequest
       );
     }
-    return rewriteMountedResponse(await rrHandler(request), basePath, p, request);
+    return rewriteMountedResponse(
+      await runWithRequestContext(anonymousContext, () => rrHandler(request)),
+      basePath,
+      p,
+      request
+    );
   }));`
     : ""
 }

package/corpus/core/src/integrations/google-docs-poller.ts

@@ -3,6 +3,7 @@ import type { EngineMessage } from "../agent/engine/types.js";
 import {
   runAgentLoop,
   actionsToEngineTools,
+  filterInitialEngineTools,
   type ActionEntry,
 } from "../agent/production-agent.js";
 import { startRun, type ActiveRun } from "../agent/run-manager.js";
@@ -10,6 +11,7 @@ import {
   buildAssistantMessage,
   extractThreadMeta,
 } from "../agent/thread-data-builder.js";
+import { attachToolSearch } from "../agent/tool-search.js";
 import {
   createThread,
   getThread,
@@ -46,6 +48,13 @@ export interface GoogleDocsPollerOptions {
   systemPrompt: string;
   /** Action entries for the agent */
   actions: Record<string, ActionEntry>;
+  /**
+   * Tool names to expose on the FIRST engine request. See
+   * `WebhookHandlerOptions.initialToolNames` (`webhook-handler.ts`) — same
+   * semantics, shared `actions` source from `createIntegrationsPlugin`. Omit
+   * to keep the full `actions` set visible up front (current behavior).
+   */
+  initialToolNames?: string[];
   /** Model to use */
   model: string;
   /** Anthropic API key */
@@ -466,7 +475,18 @@ async function processComment(
   ];
 
   const engine = createAnthropicEngine({ apiKey: options.apiKey });
-  const tools = actionsToEngineTools(options.actions);
+  // Attach tool-search on a shallow copy so framework additions merged in by
+  // `createIntegrationsPlugin` (integration memory, `call-agent`) can be
+  // deferred behind it without mutating the plugin's long-lived registry.
+  // `runAgentLoop`'s `expandActiveTools` re-expands from `availableTools`
+  // after a tool-search call, so anything filtered out of the initial
+  // `tools` list stays reachable.
+  const runnableActions = attachToolSearch({ ...options.actions });
+  const availableTools = actionsToEngineTools(runnableActions);
+  const tools = filterInitialEngineTools(
+    availableTools,
+    options.initialToolNames,
+  );
   const runId = `gdocs-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
   const capturedThreadId = threadId;
   const orgId = (await resolveOrgIdForEmail(options.ownerEmail)) ?? undefined;
@@ -483,8 +503,9 @@ async function processComment(
             model: options.model,
             systemPrompt: options.systemPrompt,
             tools,
+            availableTools,
             messages,
-            actions: options.actions,
+            actions: runnableActions,
             send,
             signal,
           }),

package/corpus/core/src/integrations/plugin.ts

@@ -617,6 +617,13 @@ export function createIntegrationsPlugin(
       ...localActions,
       ...callAgentEntry,
     } as typeof localActions;
+    // Keep the app's own actions visible on the first request to the model;
+    // defer the framework additions merged in above (integration memory,
+    // call-agent) behind the tool-search entry `handleWebhook` /
+    // `startGoogleDocsPoller` attach to `actions`. The run loop's mid-run
+    // tool expansion still lets the model discover and call them after a
+    // search — see `filterInitialEngineTools` / `expandActiveTools`.
+    const initialToolNames = Object.keys(localActions);
 
     const h3 = getH3App(nitroApp);
     const P = `${FRAMEWORK_ROUTE_PREFIX}/integrations`;
@@ -1544,6 +1551,7 @@ export function createIntegrationsPlugin(
                 adapter,
                 systemPrompt: baseSystemPrompt + resources,
                 actions,
+                initialToolNames,
                 model,
                 apiKey: getApiKey(),
                 engine: options?.engine,
@@ -2385,6 +2393,7 @@ export function createIntegrationsPlugin(
             // where providers such as Discord enforce a 3-second deadline.
             systemPrompt: baseSystemPrompt,
             actions,
+            initialToolNames,
             model,
             apiKey: getApiKey(),
             engine: options?.engine,
@@ -2509,6 +2518,7 @@ export function createIntegrationsPlugin(
         void startGoogleDocsPoller({
           systemPrompt: baseSystemPrompt,
           actions,
+          initialToolNames,
           model: model ?? "",
           apiKey: getApiKey(),
           ownerEmail: "integration@google-docs",

package/corpus/core/src/integrations/scope-store.ts

@@ -216,7 +216,7 @@ function serviceOwnerForScope(
 
 function authorizationSql(alias = ""): string {
   const prefix = alias ? `${alias}.` : "";
-  return `((${prefix}org_id = ? AND ? IS NOT NULL) OR (${prefix}org_id IS NULL AND ${prefix}owner_email = ?))`;
+  return `((${prefix}org_id = ? AND CAST(? AS TEXT) IS NOT NULL) OR (${prefix}org_id IS NULL AND ${prefix}owner_email = ?))`;
 }
 
 function authorizationArgs(

package/corpus/core/src/integrations/usage-budget-store.ts

@@ -232,7 +232,7 @@ function requirePeriod(
 
 function authorizationSql(alias = ""): string {
   const prefix = alias ? `${alias}.` : "";
-  return `((${prefix}subject_type = 'user' AND ${prefix}owner_email = ?) OR (${prefix}subject_type <> 'user' AND ((${prefix}org_id = ? AND ? IS NOT NULL) OR (${prefix}org_id IS NULL AND ${prefix}owner_email = ?))))`;
+  return `((${prefix}subject_type = 'user' AND ${prefix}owner_email = ?) OR (${prefix}subject_type <> 'user' AND ((${prefix}org_id = ? AND CAST(? AS TEXT) IS NOT NULL) OR (${prefix}org_id IS NULL AND ${prefix}owner_email = ?))))`;
 }
 
 function authorizationArgs(

package/corpus/core/src/integrations/webhook-handler.ts

@@ -21,6 +21,7 @@ import type { AgentEngine, EngineMessage } from "../agent/engine/types.js";
 import {
   runAgentLoop,
   actionsToEngineTools,
+  filterInitialEngineTools,
   getOwnerActiveApiKey,
   getOwnerApiKey,
   engineToProvider,
@@ -35,6 +36,7 @@ import {
   buildAssistantMessage,
   extractThreadMeta,
 } from "../agent/thread-data-builder.js";
+import { attachToolSearch } from "../agent/tool-search.js";
 import { createThread, getThread } from "../chat-threads/store.js";
 import { updateThreadData } from "../chat-threads/store.js";
 import { isLocalDatabase } from "../db/client.js";
@@ -113,6 +115,17 @@ export interface WebhookHandlerOptions {
   systemPrompt: string;
   /** Action entries for the agent */
   actions: Record<string, ActionEntry>;
+  /**
+   * Tool names to expose on the FIRST engine request. When provided, every
+   * other name in `actions` (framework additions such as
+   * `list-integration-memory` / `call-agent` merged in by
+   * `createIntegrationsPlugin`) is deferred behind the attached `tool-search`
+   * entry instead of being serialized on every inbound message — the run
+   * loop's mid-run tool expansion (`expandActiveTools` in `runAgentLoop`)
+   * still lets the model discover and call them after a search. Omit to keep
+   * the full `actions` set visible up front (current behavior).
+   */
+  initialToolNames?: string[];
   /** Model to use. Defaults to the resolved engine's default model. */
   model?: string;
   /** Anthropic API key */
@@ -573,6 +586,7 @@ async function processIncomingMessage(
     adapter,
     systemPrompt,
     actions,
+    initialToolNames,
     model,
     apiKey,
     ownerEmail,
@@ -763,10 +777,20 @@ async function processIncomingMessage(
   // A2A delegation. Without this, getRequestOrgId() returns undefined and
   // call-agent can't look up the org's a2a_secret or org_domain.
   let orgId: string | null | undefined;
+  let runnableActions: Record<string, ActionEntry>;
   let tools: ReturnType<typeof actionsToEngineTools>;
+  let availableTools: ReturnType<typeof actionsToEngineTools>;
   try {
     orgId = opts.orgId ?? (await resolveOrgIdForEmail(ownerEmail));
-    tools = actionsToEngineTools(actions);
+    // Attach tool-search on a shallow copy so framework additions merged in
+    // by `createIntegrationsPlugin` (integration memory, `call-agent`) can be
+    // deferred behind it without mutating the plugin's long-lived registry.
+    // `runAgentLoop`'s `expandActiveTools` re-expands from `availableTools`
+    // after a tool-search call, so anything filtered out of the initial
+    // `tools` list stays reachable.
+    runnableActions = attachToolSearch({ ...actions });
+    availableTools = actionsToEngineTools(runnableActions);
+    tools = filterInitialEngineTools(availableTools, initialToolNames);
   } catch (error) {
     await releaseApplicableIntegrationBudgets(budgetReservations.reservations);
     throw error;
@@ -855,8 +879,9 @@ async function processIncomingMessage(
               model: resolvedModel,
               systemPrompt: effectiveSystemPrompt,
               tools,
+              availableTools,
               messages,
-              actions,
+              actions: runnableActions,
               send: async (event) => {
                 if (progress) {
                   await Promise.resolve(progress.onEvent(event)).catch(

package/corpus/core/src/jobs/scheduler.ts

@@ -8,10 +8,12 @@ import type { AgentEngine } from "../agent/engine/types.js";
 import {
   runAgentLoop,
   actionsToEngineTools,
+  filterInitialEngineTools,
   getOwnerActiveApiKey,
   type ActionEntry,
 } from "../agent/production-agent.js";
 import { startRun, resolveRunSoftTimeoutMs } from "../agent/run-manager.js";
+import { attachToolSearch } from "../agent/tool-search.js";
 import { createThread } from "../chat-threads/store.js";
 import {
   organizationIdFromResourceOwner,
@@ -175,6 +177,18 @@ export function buildJobContent(meta: JobFrontmatter, body: string): string {
 export interface SchedulerDeps {
   getActions: () => Record<string, ActionEntry>;
   getSystemPrompt: (owner: string) => Promise<string>;
+  /**
+   * Tool names to expose on the FIRST engine request for a job run. When
+   * provided, every other action returned by `getActions()` is deferred
+   * behind an attached `tool-search` entry instead of being serialized on
+   * every scheduled tick — `runAgentLoop`'s mid-run tool expansion
+   * (`expandActiveTools`) still lets the model discover and call them after
+   * a search. Omit to keep the full `getActions()` set visible up front
+   * (current behavior). The caller (not this module) knows which of the
+   * merged actions are the app's own vs. framework additions, so this must
+   * be supplied explicitly rather than inferred here.
+   */
+  getInitialToolNames?: () => string[] | undefined;
   /** Optional engine override. Defaults to the resolved request engine. */
   engine?: AgentEngine;
   apiKey?: string;
@@ -463,9 +477,20 @@ async function executeJob(
     },
     async () => {
       try {
-        const actions = deps.getActions();
+        const baseActions = deps.getActions();
         const systemPrompt = await deps.getSystemPrompt(jobUserEmail);
-        const tools = actionsToEngineTools(actions);
+        const initialToolNames = deps.getInitialToolNames?.();
+        // 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.
+        const actions = initialToolNames
+          ? attachToolSearch({ ...baseActions })
+          : baseActions;
+        const availableTools = actionsToEngineTools(actions);
+        const tools = filterInitialEngineTools(
+          availableTools,
+          initialToolNames,
+        );
 
         // Prefer the job runner's saved Anthropic key so recurring jobs
         // don't silently bill the shared platform key once a user has
@@ -537,6 +562,7 @@ async function executeJob(
                   model,
                   systemPrompt,
                   tools,
+                  availableTools,
                   messages,
                   actions,
                   send,