@agent-native/core 0.92.12 → 0.94.0

package/corpus/core/docs/content/workspace.mdx

@@ -5,7 +5,11 @@ description: "Claude-Code-level customization per user — skills, memory, instr
 
 # Workspace
 
-> **Which workspace doc?** This page covers the **customization layer** — what a workspace _is_. For the deployment shape (one monorepo, many apps) see [Multi-App Workspaces](/docs/multi-app-workspace); for governance (who reviews, approves, and owns what) see [Workspace Governance](/docs/workspace-management).
+<Callout tone="info">
+
+**Which workspace doc?** This page covers the **customization layer** — what a workspace _is_. For the deployment shape (one monorepo, many apps) see [Multi-App Workspaces](/docs/multi-app-workspace); for governance (who reviews, approves, and owns what) see [Workspace Governance](/docs/workspace-management).
+
+</Callout>
 
 Every agent-native app ships with a **workspace**: the customization layer that makes the agent yours. It contains team instructions (`AGENTS.md`), shared learnings (`LEARNINGS.md`), personal structured memory (`memory/MEMORY.md`), skills the agent pulls in on demand, custom sub-agents, scheduled jobs, and connected MCP servers — everything you'd expect from a Claude Code / Codex setup.
 
@@ -82,7 +86,7 @@ The twist: **it's SQL rows, not filesystem files.** Each user gets their own wor
 | Per-project `CLAUDE.md` / skills | Per-app `AGENTS.md` + workspace memory resources   |
 | MCP config in a JSON file        | MCP config in JSON _or_ the settings UI, per scope |
 
-Same capabilities. Different economics. See [Templates](/docs/cloneable-saas) for why this matters for SaaS.
+Same capabilities. Different economics. See [Apps](/docs/cloneable-saas) for why this matters for SaaS.
 
 ## Overview {#overview}
 
@@ -219,11 +223,9 @@ workspace context/brand.md
 -> personal context/brand.md
 ```
 
-Keep `context/` files short and factual — a few bullets the agent can skim:
-
-```text
-<!-- context/brand.md -->
+For example:
 
+```text filename="context/brand.md"
 # Brand
 
 - Voice: direct, warm, concrete
@@ -386,15 +388,9 @@ There are two agent types in Workspace:
 
 Use custom agents for delegation within one app. Use connected agents when you need to call another app over A2A.
 
-## @ Tagging {#at-tagging}
-
-Type `@` in the chat input to reference workspace items. A dropdown appears at the cursor showing matching agents and files. Use arrow keys to navigate and Enter to select. The selected item appears as an inline chip in the input.
-
-When you send a message, **files/resources** are passed as references the agent can read, **custom agents** run locally with their profile instructions, and **connected agents** are called over A2A.
+## @ Tagging and / Slash Commands {#at-tagging}
 
-## / Slash Commands {#slash-commands}
-
-Type `/` at the start of a line to invoke a skill. A dropdown shows available skills with their names and descriptions; selecting one adds an inline chip and includes its content as context when the message is sent. If no skills are configured, the dropdown links to these docs.
+Type `@` in the chat input to reference an agent, file, or resource, or `/` to invoke a skill — both open a dropdown at the cursor and add an inline chip when you select an item. See [Agent Mentions](/docs/agent-mentions) for the full mechanics (routing, `MentionProvider`, sub-agent selection) and [Skills Guide](/docs/skills-guide) for how skills are authored and discovered.
 
 ## Code vs App Mode {#dev-vs-prod}
 
@@ -414,10 +410,6 @@ Workspace Connections let apps share the same provider account (Slack, GitHub, H
 
 See [Workspace Connections](/docs/workspace-connections) for the quickstart, connection/grant/credentialRef API, and concrete Slack, HubSpot, and GitHub examples.
 
----
-
-# Reference
-
 ## Resource API {#resource-api}
 
 Resources can be managed from server code, actions, or the REST API.
@@ -461,3 +453,12 @@ pnpm action resource-write --path "notes/meeting.md" --content "# Meeting Notes.
 # Delete a resource
 pnpm action resource-delete --path "notes/old.md"
 ```
+
+## What's next {#whats-next}
+
+- [**Skills Guide**](/docs/skills-guide) — author and scope the skill files referenced from `skills/`
+- [**Agent Mentions**](/docs/agent-mentions) — `@`-mention and `/`-command mechanics in full
+- [**Recurring Jobs**](/docs/recurring-jobs) — schedule the prompts created from Scheduled Tasks
+- [**Workspace Governance**](/docs/workspace-management) — who reviews, approves, and owns workspace changes
+- [**Multi-App Workspaces**](/docs/multi-app-workspace) — the deployment shape one workspace spans
+- [**Workspace Connections**](/docs/workspace-connections) — share provider credentials across apps

package/corpus/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.92.12",
+  "version": "0.94.0",
   "description": "Framework for agent-native application development — where AI agents and UI share SQL state, actions, and context",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {
@@ -46,6 +46,8 @@
     "./server/agent-discovery": "./dist/server/agent-discovery.js",
     "./server/request-context": "./dist/server/request-context.js",
     "./server/design-token-utils": "./dist/server/design-token-utils.js",
+    "./integrations": "./dist/integrations/index.js",
+    "./automation": "./dist/automation/index.js",
     "./brand-kit": "./dist/brand-kit/index.js",
     "./brand-kit/fig": "./dist/brand-kit/fig/index.js",
     "./data-widgets": "./dist/data-widgets/index.js",
@@ -289,6 +291,7 @@
     "ajv": "^8.20.0",
     "better-auth": "1.6.16",
     "better-sqlite3": "^12.8.0",
+    "botframework-connector": "^4.23.3",
     "clsx": "^2.1.1",
     "cron-parser": "^5.5.0",
     "diff-match-patch": "^1.0.5",
@@ -321,6 +324,7 @@
     "tiptap-markdown": "^0.9.0",
     "turndown": "7.2.4",
     "tw-animate-css": "1.4.0",
+    "tweetnacl": "^1.0.3",
     "y-protocols": "^1.0.7",
     "yjs": "^13.6.31",
     "zod": "^4.3.6"

package/corpus/core/src/a2a/artifact-response.ts

@@ -49,6 +49,19 @@ interface CreatedImageArtifact {
   url?: string;
 }
 
+interface CreatedMonitorArtifact {
+  id: string;
+  name?: string;
+  url: string;
+}
+
+interface CreatedFormArtifact {
+  id: string;
+  title?: string;
+  url: string;
+  anonymous: boolean;
+}
+
 type ReferencedArtifactKind =
   | "deck"
   | "design"
@@ -181,6 +194,40 @@ function imageIdValue(parsed: Record<string, unknown>): string | undefined {
   );
 }
 
+function contentDatabaseSubmissionArtifact(
+  parsed: Record<string, unknown>,
+): CreatedDocumentArtifact | null {
+  const id = stringValue(parsed.createdDocumentId);
+  if (!id) return null;
+
+  const verification = asRecord(parsed.verification);
+  const candidates = [
+    stringValue(parsed.url),
+    stringValue(parsed.urlPath),
+    stringValue(parsed.createdDocumentUrl),
+    stringValue(verification?.url),
+    stringValue(verification?.urlPath),
+  ].filter((value): value is string => !!value);
+  const url = candidates.find((candidate) =>
+    artifactUrlReferencesId(candidate, "document", id),
+  );
+
+  const items = Array.isArray(parsed.items) ? parsed.items : [];
+  const createdItem = items.map(asRecord).find((item) => {
+    const document = asRecord(item?.document);
+    return stringValue(document?.id) === id;
+  });
+  const createdDocument = asRecord(createdItem?.document);
+
+  return {
+    id,
+    title:
+      stringValue(parsed.createdDocumentTitle) ??
+      stringValue(createdDocument?.title),
+    url,
+  };
+}
+
 function addImageArtifact(
   images: Map<string, CreatedImageArtifact>,
   parsed: Record<string, unknown>,
@@ -241,6 +288,8 @@ function collectArtifacts(results: A2AToolResultSummary[]): {
   images: CreatedImageArtifact[];
   designShells: CreatedDesignShell[];
   generatedDesigns: GeneratedDesignArtifact[];
+  monitors: CreatedMonitorArtifact[];
+  forms: CreatedFormArtifact[];
 } {
   const documents = new Map<string, CreatedDocumentArtifact>();
   const decks = new Map<string, CreatedDeckArtifact>();
@@ -249,6 +298,8 @@ function collectArtifacts(results: A2AToolResultSummary[]): {
   const images = new Map<string, CreatedImageArtifact>();
   const designShells = new Map<string, CreatedDesignShell>();
   const generatedDesigns = new Map<string, GeneratedDesignArtifact>();
+  const monitors = new Map<string, CreatedMonitorArtifact>();
+  const forms = new Map<string, CreatedFormArtifact>();
 
   for (const toolResult of results) {
     if (toolResult.tool === "call-agent") {
@@ -297,6 +348,43 @@ function collectArtifacts(results: A2AToolResultSummary[]): {
     const parsed = parseToolResultJson(toolResult.result);
     if (!parsed) continue;
 
+    if (toolResult.tool === "save-monitor") {
+      const id = stringValue(parsed.id);
+      const url = stringValue(parsed.monitorAppUrl);
+      if (id && url) {
+        monitors.set(id, {
+          id,
+          name: stringValue(parsed.name),
+          url,
+        });
+      }
+      continue;
+    }
+
+    if (toolResult.tool === "create-form") {
+      const id = stringValue(parsed.id);
+      const url = stringValue(parsed.publicUrl);
+      if (id && url && stringValue(parsed.status) === "published") {
+        const settings = asRecord(parsed.settings);
+        forms.set(id, {
+          id,
+          title: stringValue(parsed.title),
+          url,
+          anonymous: settings?.anonymous === true,
+        });
+      }
+      continue;
+    }
+
+    if (
+      toolResult.tool === "submit-content-database-form" ||
+      toolResult.tool === "add-database-item"
+    ) {
+      const artifact = contentDatabaseSubmissionArtifact(parsed);
+      if (artifact) documents.set(artifact.id, artifact);
+      continue;
+    }
+
     if (
       toolResult.tool === "create-document" ||
       toolResult.tool === "get-document" ||
@@ -484,6 +572,8 @@ function collectArtifacts(results: A2AToolResultSummary[]): {
     images: [...images.values()],
     designShells: [...designShells.values()],
     generatedDesigns: [...generatedDesigns.values()],
+    monitors: [...monitors.values()],
+    forms: [...forms.values()],
   };
 }
 
@@ -713,6 +803,17 @@ function formatDesignLine(
   return `- Design: ${artifactUrlFromResult({ url: design.url }, `/design/${design.id}`, baseUrl)} (ID: ${design.id}, ${fileLabel})`;
 }
 
+function formatMonitorLine(monitor: CreatedMonitorArtifact): string {
+  const label = monitor.name ? `Monitor "${monitor.name}"` : "Monitor";
+  return `- ${label}: ${monitor.url} (ID: ${monitor.id})`;
+}
+
+function formatFormLine(form: CreatedFormArtifact): string {
+  const kind = form.anonymous ? "Anonymous form" : "Public form";
+  const label = form.title ? `${kind} "${form.title}"` : kind;
+  return `- ${label}: ${form.url} (ID: ${form.id})`;
+}
+
 function formatIncompleteDesignMessage(shells: CreatedDesignShell[]): string {
   const ids = shells.map((shell) => shell.id).join(", ");
   const noun = shells.length === 1 ? "project shell" : "project shells";
@@ -885,6 +986,8 @@ export function appendA2AArtifactLinks(
     images,
     designShells,
     generatedDesigns,
+    monitors,
+    forms,
   } = collectArtifacts(toolResults);
   const generatedDesignIds = new Set(
     generatedDesigns.map((design) => design.id),
@@ -985,6 +1088,22 @@ export function appendA2AArtifactLinks(
       missingLines.push(formatDesignLine(design, baseUrl));
     }
   }
+  for (const monitor of monitors) {
+    if (
+      includeReferencedArtifacts ||
+      !responseAlreadyMentionsPath(text, monitor.url)
+    ) {
+      missingLines.push(formatMonitorLine(monitor));
+    }
+  }
+  for (const form of forms) {
+    if (
+      includeReferencedArtifacts ||
+      !responseAlreadyMentionsPath(text, form.url)
+    ) {
+      missingLines.push(formatFormLine(form));
+    }
+  }
 
   if (missingLines.length === 0) return text;
   const artifactBlock = `Artifacts:\n${missingLines.join("\n")}`;
@@ -996,8 +1115,16 @@ export function buildA2ARecoverableArtifactMessage(
   options: A2AArtifactResponseOptions = {},
 ): string | null {
   const baseUrl = normalizeBaseUrl(options.baseUrl);
-  const { documents, decks, dashboards, analyses, images, generatedDesigns } =
-    collectArtifacts(toolResults);
+  const {
+    documents,
+    decks,
+    dashboards,
+    analyses,
+    images,
+    generatedDesigns,
+    monitors,
+    forms,
+  } = collectArtifacts(toolResults);
   const lines = [
     ...documents.map((document) => formatDocumentLine(document, baseUrl)),
     ...decks.map((deck) => formatDeckLine(deck, baseUrl)),
@@ -1005,6 +1132,8 @@ export function buildA2ARecoverableArtifactMessage(
     ...analyses.map((analysis) => formatAnalysisLine(analysis, baseUrl)),
     ...images.map((image) => formatImageLine(image, baseUrl)),
     ...generatedDesigns.map((design) => formatDesignLine(design, baseUrl)),
+    ...monitors.map(formatMonitorLine),
+    ...forms.map(formatFormLine),
   ];
 
   if (lines.length === 0) return null;

package/corpus/core/src/a2a/client.ts

@@ -550,6 +550,15 @@ export async function callAgent(
     timeoutMs?: number;
     /** Poll interval for async calls. Primarily useful for tests/retries. */
     pollIntervalMs?: number;
+    /**
+     * Called with each successfully polled task while an async call is still
+     * in flight (see `A2AClient.sendAndWait`). Fires once per real poll
+     * round-trip that returns a task — including the terminal poll — so
+     * callers can surface genuine remote liveness/progress. Not called when a
+     * poll fetch throws (remote unresponsive) or when the task completes
+     * synchronously on submit. Only threaded through for async calls.
+     */
+    onUpdate?: (task: Task) => void;
   },
 ): Promise<string> {
   const metadata: Record<string, unknown> = {};
@@ -585,6 +594,7 @@ export async function callAgent(
           metadata,
           timeoutMs: opts?.timeoutMs,
           pollIntervalMs: opts?.pollIntervalMs,
+          onUpdate: opts?.onUpdate,
         });
       } else {
         task = await client.send(message, {

package/corpus/core/src/a2a/handlers.ts

@@ -1,7 +1,14 @@
 import { setResponseHeader, setResponseStatus } from "h3";
 
-import { signInternalToken } from "../integrations/internal-token.js";
+import {
+  AGENT_BACKGROUND_PROCESSOR_A2A,
+  AGENT_BACKGROUND_PROCESSOR_FIELD,
+  dispatchPathTargetsNetlifyBackgroundFunction,
+  isAgentChatDurableBackgroundEnabled,
+  resolveAgentChatProcessRunDispatchPath,
+} from "../agent/durable-background.js";
 import { withConfiguredAppBasePath } from "../server/app-base-path.js";
+import { fireInternalDispatch } from "../server/self-dispatch.js";
 import { agentChat } from "../shared/agent-chat.js";
 import {
   hasConfiguredA2ASecret,
@@ -37,79 +44,33 @@ const A2A_PROCESSING_STUCK_AFTER_MS = 5 * 60 * 1000;
 const A2A_PROCESSING_HEARTBEAT_MS = 30_000;
 
 /**
- * Resolve the base URL we should fire the A2A processor request to. Mirrors
- * the integration-webhook resolveBaseUrl pattern — prefer explicit env vars
- * (most reliable on serverless), fall back to inbound request headers.
- */
-function resolveSelfBaseUrl(event: any | undefined): string {
-  const fromEnv =
-    process.env.APP_URL ||
-    process.env.URL ||
-    process.env.DEPLOY_URL ||
-    process.env.BETTER_AUTH_URL;
-  if (fromEnv) return withConfiguredAppBasePath(String(fromEnv));
-  if (isA2AProductionRuntime()) {
-    throw new Error(
-      "A2A self-dispatch requires APP_URL, URL, DEPLOY_URL, or BETTER_AUTH_URL in production.",
-    );
-  }
-
-  try {
-    const headers = event?.node?.req?.headers ?? event?.headers;
-    const get = (name: string): string | undefined => {
-      if (!headers) return undefined;
-      if (typeof headers.get === "function") {
-        return headers.get(name) ?? undefined;
-      }
-      const map = headers as Record<string, string | undefined>;
-      return map[name] ?? map[String(name).toLowerCase()];
-    };
-    const proto = get("x-forwarded-proto") || "http";
-    const host = get("host") || `localhost:${process.env.PORT || 3000}`;
-    return withConfiguredAppBasePath(`${proto}://${host}`);
-  } catch {
-    return withConfiguredAppBasePath(
-      `http://localhost:${process.env.PORT || 3000}`,
-    );
-  }
-}
-
-/**
- * Fire-and-forget POST to the A2A processor route on the same deployment.
- * Used when an A2A send is requested in async mode — the processor runs the
- * handler in a fresh function execution so it gets its own full timeout.
+ * Dispatch an async A2A task to a fresh function execution. Apps that opted
+ * into durable background runs reuse the emitted Netlify 15-minute worker;
+ * other hosts and apps retain the normal portable self-webhook route.
  */
 async function fireProcessTaskDispatch(
   event: any,
   taskId: string,
+  config: A2AConfig,
 ): Promise<void> {
-  const baseUrl = resolveSelfBaseUrl(event);
-  const url = `${baseUrl}${A2A_PROCESS_TASK_PATH}`;
-  const headers: Record<string, string> = {
-    "Content-Type": "application/json",
-  };
-  try {
-    headers["Authorization"] = `Bearer ${signInternalToken(taskId)}`;
-  } catch {
-    // No A2A_SECRET configured — self-fire unsigned. The processor accepts
-    // unsigned dispatches when no secret is set (mirrors the integration
-    // webhook flow).
-  }
-  // Race the fetch against a short timer. On Netlify Lambda, returning
-  // immediately can freeze the function before the outbound TCP handshake
-  // starts, leaving the request stuck. This gives it ~250ms to leave the
-  // box at the cost of slightly higher response latency on async A2A sends.
-  const dispatchPromise = fetch(url, {
-    method: "POST",
-    headers,
-    body: JSON.stringify({ taskId }),
-  }).catch((err) => {
-    console.error("[a2a] Process-task dispatch fetch failed:", err);
+  const backgroundPath = resolveAgentChatProcessRunDispatchPath();
+  const useBackgroundWorker =
+    isAgentChatDurableBackgroundEnabled({
+      appOptIn: config.durableBackgroundRuns === true,
+    }) && dispatchPathTargetsNetlifyBackgroundFunction(backgroundPath);
+
+  await fireInternalDispatch({
+    event,
+    path: useBackgroundWorker ? backgroundPath : A2A_PROCESS_TASK_PATH,
+    taskId,
+    ...(useBackgroundWorker
+      ? {
+          body: {
+            [AGENT_BACKGROUND_PROCESSOR_FIELD]: AGENT_BACKGROUND_PROCESSOR_A2A,
+          },
+        }
+      : {}),
   });
-  await Promise.race([
-    dispatchPromise,
-    new Promise<void>((resolve) => setTimeout(resolve, 250)),
-  ]);
 }
 
 /**
@@ -522,7 +483,7 @@ async function handleSend(
     );
     const working = await updateTask(task.id, { state: "working" });
 
-    fireProcessTaskDispatch(event, task.id).catch((err) => {
+    fireProcessTaskDispatch(event, task.id, config).catch((err) => {
       console.error("[a2a] Failed to dispatch process-task:", err);
     });
 
@@ -764,12 +725,14 @@ async function handleGet(
   if (!task) {
     return jsonRpcError(0, -32001, "Task not found");
   }
-  const taskChanged = await refireStuckAsyncTaskIfNeeded(id, event).catch(
-    (err) => {
-      console.error("[a2a] Failed to refire stuck async task:", err);
-      return false;
-    },
-  );
+  const taskChanged = await refireStuckAsyncTaskIfNeeded(
+    id,
+    event,
+    config,
+  ).catch((err) => {
+    console.error("[a2a] Failed to refire stuck async task:", err);
+    return false;
+  });
   if (taskChanged) {
     const updated = await getTask(id);
     if (updated) return jsonRpcResult(0, sanitizeTaskForResponse(updated));
@@ -780,6 +743,7 @@ async function handleGet(
 async function refireStuckAsyncTaskIfNeeded(
   taskId: string,
   event: any,
+  config: A2AConfig,
 ): Promise<boolean> {
   const state = await getA2ATaskDispatchState(taskId);
   if (!state) return false;
@@ -791,7 +755,7 @@ async function refireStuckAsyncTaskIfNeeded(
     state.updatedAt <= now - A2A_QUEUED_DISPATCH_STUCK_AFTER_MS
   ) {
     if (await touchQueuedA2ATaskDispatch(taskId)) {
-      await fireProcessTaskDispatch(event, taskId);
+      await fireProcessTaskDispatch(event, taskId, config);
       return true;
     }
     return false;

package/corpus/core/src/a2a/types.ts

@@ -158,4 +158,6 @@ export interface A2AConfig {
   handler?: A2AHandler;
   apiKeyEnv?: string;
   streaming?: boolean;
+  /** Route async A2A work through the app's durable background worker when available. */
+  durableBackgroundRuns?: boolean;
 }

package/corpus/core/src/agent/context-xray/tokenize.ts

@@ -4,10 +4,15 @@ import type { EngineContentPart, EngineMessage } from "../engine/types.js";
 type TokenCounter = (text: string) => number;
 
 let tokenizerPromise: Promise<TokenCounter | null> | undefined;
+const TOKENIZER_MODULE_ID = "@anthropic-ai/tokenizer";
 
 async function loadTokenizer(): Promise<TokenCounter | null> {
   if (!tokenizerPromise) {
-    tokenizerPromise = import("@anthropic-ai/tokenizer")
+    // Token counting is server-only. Keep this optional dependency out of
+    // browser bundles: tiktoken's WASM entry cannot be loaded by Rolldown's
+    // browser fallback, while the documented estimate below is sufficient
+    // when an edge runtime cannot resolve the tokenizer.
+    tokenizerPromise = import(/* @vite-ignore */ TOKENIZER_MODULE_ID)
       .then((mod) =>
         typeof mod.countTokens === "function"
           ? (mod.countTokens as TokenCounter)

package/corpus/core/src/agent/durable-background.ts

@@ -77,6 +77,18 @@ export const AGENT_BACKGROUND_FUNCTION_NAME = "server-agent-background";
  */
 export const AGENT_BACKGROUND_FUNCTION_URL_PATH = `/.netlify/functions/${AGENT_BACKGROUND_FUNCTION_NAME}`;
 
+/**
+ * Marker carried in a Netlify background-function body when the shared
+ * long-running worker should route to a processor other than agent chat.
+ * The emitted wrapper defaults to the normal agent-chat `_process-run` route;
+ * A2A uses this marker to reuse the same 15-minute function for async tasks.
+ */
+export const AGENT_BACKGROUND_PROCESSOR_FIELD = "__agentNativeProcessor";
+export const AGENT_BACKGROUND_PROCESSOR_A2A = "a2a";
+export const AGENT_BACKGROUND_PROCESSOR_ROUTE = "route";
+export const AGENT_BACKGROUND_PROCESSOR_ROUTE_FIELD =
+  "__agentNativeProcessorRoute";
+
 /**
  * The per-app workspace background function URL path. Workspace deploy emits one
  * background function per app named `<app>-agent-background`, reachable at its
@@ -149,6 +161,18 @@ export function resolveAgentChatProcessRunDispatchPath(): string {
   return AGENT_CHAT_PROCESS_RUN_PATH;
 }
 
+export function resolveDurableBackgroundDispatchPath(
+  fallbackPath: string,
+): string {
+  if (isNetlifyHostedRuntimeForDispatch()) {
+    return (
+      resolveWorkspaceBackgroundFunctionUrlPath() ??
+      AGENT_BACKGROUND_FUNCTION_URL_PATH
+    );
+  }
+  return fallbackPath;
+}
+
 export function dispatchPathTargetsNetlifyBackgroundFunction(
   dispatchPath: string,
 ): boolean {

package/corpus/core/src/agent/engine/ai-sdk-engine.ts

@@ -175,7 +175,8 @@ function googleThinkingBudget(effort: string) {
  */
 function gemini3ThinkingLevel(effort: string): string {
   if (effort === "low") return "low";
-  // medium/high/xhigh/max all map to the strongest available level for Gemini 3
+  if (effort === "medium") return "medium";
+  // high/xhigh/max map to the strongest available level for Gemini 3.
   return "high";
 }
 
@@ -309,12 +310,15 @@ class AISDKEngine implements AgentEngine {
     );
     if (reasoningEffort) {
       if (this.provider === "anthropic") {
+        const explicitThinking = (
+          providerOpts.anthropic as { thinking?: unknown } | undefined
+        )?.thinking;
         providerOpts.anthropic = {
           ...((providerOpts.anthropic as object) ?? {}),
-          thinking: (
-            providerOpts.anthropic as { thinking?: unknown } | undefined
-          )?.thinking ?? { type: "adaptive" },
-          outputConfig: { effort: reasoningEffort },
+          thinking: explicitThinking ?? { type: "adaptive" },
+          ...(explicitThinking
+            ? {}
+            : { outputConfig: { effort: reasoningEffort } }),
         };
       } else if (this.provider === "openai") {
         providerOpts.openai = {

package/corpus/core/src/agent/engine/anthropic-engine.ts

@@ -104,10 +104,8 @@ class AnthropicEngine implements AgentEngine {
       opts.model,
       opts.reasoningEffort,
     );
-    if (reasoningEffort) {
-      if (!extra.thinking) {
-        extra.thinking = { type: "adaptive" };
-      }
+    if (reasoningEffort && !extra.thinking) {
+      extra.thinking = { type: "adaptive" };
       extra.output_config = { effort: reasoningEffort };
     }
 

package/corpus/core/src/agent/engine/builder-engine.ts

@@ -150,15 +150,13 @@ class BuilderEngine implements AgentEngine {
     const tools = engineToolsToAnthropic(opts.tools);
     const thinkingBudget =
       opts.providerOptions?.anthropic?.thinking?.budgetTokens;
-    const explicitReasoningEffort = normalizeReasoningEffortForModel(
+    const reasoningEffort = normalizeReasoningEffortForModel(
       opts.model,
-      opts.reasoningEffort,
+      opts.reasoningEffort ??
+        (typeof thinkingBudget === "number"
+          ? mapReasoningEffort(thinkingBudget)
+          : undefined),
     );
-    const reasoningEffort =
-      explicitReasoningEffort ??
-      (typeof thinkingBudget === "number"
-        ? mapReasoningEffort(thinkingBudget)
-        : undefined);
 
     // Apply prompt caching to system + tools (stable prefix) and to the last
     // user message (moving cache breakpoint so growing history gets cached

package/corpus/core/src/agent/engine/index.ts

@@ -22,6 +22,7 @@ export {
   getAgentEngineEntry,
   listAgentEngines,
   resolveEngine,
+  getConfiguredEngineNameForRequest,
   getStoredModelForEngine,
   normalizeModelForEngine,
   detectEngineFromEnv,