@agent-native/core 0.118.0 → 0.119.0

package/corpus/core/src/scripts/call-agent.ts

@@ -1,5 +1,6 @@
 import { createHash, randomUUID } from "node:crypto";
 
+import { parseA2AAgentActivityPart } from "../a2a/activity.js";
 import {
   A2ATaskTimeoutError,
   callAgent,
@@ -271,8 +272,15 @@ export async function run(
       : undefined;
 
   if (action) {
+    const agentCallId = randomUUID();
+    const startedAt = Date.now();
     if (context?.send) {
-      context.send({ type: "agent_call", agent: agent.name, status: "start" });
+      context.send({
+        type: "agent_call",
+        agent: agent.name,
+        status: "start",
+        agentCallId,
+      });
     }
     try {
       const output = await invokeReadOnlyAppAction(
@@ -281,10 +289,24 @@ export async function run(
         input as Record<string, unknown>,
         buildDelegationCorrelation(context, selfAppId, randomUUID()),
       );
+      if (context?.send && output) {
+        context.send({
+          type: "agent_call_text",
+          agent: agent.name,
+          text: output,
+          agentCallId,
+        });
+      }
       return output;
     } finally {
       if (context?.send) {
-        context.send({ type: "agent_call", agent: agent.name, status: "done" });
+        context.send({
+          type: "agent_call",
+          agent: agent.name,
+          status: "done",
+          agentCallId,
+          durationMs: Date.now() - startedAt,
+        });
       }
     }
   }
@@ -363,6 +385,7 @@ export async function run(
 
       let responseText = "";
       let lastSentLength = 0;
+      const agentCallId = randomUUID();
       const existingContinuationText = taskId
         ? null
         : await formatExistingIntegrationContinuationIfRetry(agent, message);
@@ -372,6 +395,7 @@ export async function run(
         type: "agent_call",
         agent: agent.name,
         status: "start",
+        agentCallId,
       });
 
       const emitNewText = (newText: string) => {
@@ -380,6 +404,7 @@ export async function run(
             type: "agent_call_text",
             agent: agent.name,
             text: newText.slice(lastSentLength),
+            agentCallId,
           });
           lastSentLength = newText.length;
         }
@@ -395,9 +420,10 @@ export async function run(
       // time we get to the sync fallback, Lambda is dead and the second fetch
       // errors out as "fetch failed". Async+poll has its own short fetches
       // with their own budgets, so it works reliably across hosts. The
-      // trade-off is we lose progressive in-UI text streaming for cross-app
-      // A2A calls, but the receiving agent's full response still surfaces via
-      // the tool_result event below.
+      // trade-off is that cross-app activity arrives at the poll cadence rather
+      // than token-by-token. Agent Native peers attach their current reasoning,
+      // tool status, and response preview to each task checkpoint, and the
+      // receiver's full response still surfaces below.
       //
       // That trade-off has a second-order cost: callAgent()'s poll (see
       // A2AClient.sendAndWait in a2a/client.ts) can legitimately run for
@@ -450,8 +476,22 @@ export async function run(
       ]);
       const callStartedAt = Date.now();
       let lastProgressEmitAt = callStartedAt;
+      let lastActivitySequence = -1;
       const onRemotePollUpdate = (task: Task) => {
         const state = task?.status?.state;
+        const parts = task.status?.message?.parts;
+        const snapshot = Array.isArray(parts)
+          ? parts.map(parseA2AAgentActivityPart).find((value) => value !== null)
+          : undefined;
+        if (snapshot && snapshot.sequence > lastActivitySequence) {
+          lastActivitySequence = snapshot.sequence;
+          context.send!({
+            type: "agent_call_activity",
+            agent: agent.name,
+            agentCallId,
+            snapshot,
+          });
+        }
         if (!state || !ACTIVELY_WORKING_STATES.has(state)) return;
         const now = Date.now();
         if (now - lastProgressEmitAt < PROGRESS_MIN_INTERVAL_MS) return;
@@ -462,6 +502,7 @@ export async function run(
           agent: agent.name,
           state,
           elapsedSeconds: Math.round((now - callStartedAt) / 1000),
+          agentCallId,
           ...(detail ? { detail } : {}),
         });
       };
@@ -549,6 +590,8 @@ export async function run(
         type: "agent_call",
         agent: agent.name,
         status: "done",
+        agentCallId,
+        durationMs: Date.now() - callStartedAt,
       });
 
       return responseText || "(empty response)";
@@ -718,7 +761,7 @@ async function enqueueIntegrationContinuationIfPossible(
 const MAX_PROGRESS_DETAIL_CHARS = 200;
 function extractRemoteProgressDetail(task: Task): string | undefined {
   const parts = task.status?.message?.parts;
-  if (!parts) return undefined;
+  if (!Array.isArray(parts)) return undefined;
   const text = parts
     .filter((p): p is { type: "text"; text: string } => p.type === "text")
     .map((p) => p.text)

package/corpus/core/src/server/agent-chat-plugin.ts

@@ -13,6 +13,11 @@ import {
   type H3Event,
 } from "h3";
 
+import {
+  applyA2AAgentActivityEvent,
+  buildA2AAgentActivityPart,
+  createA2AAgentActivityState,
+} from "../a2a/activity.js";
 import {
   appendA2AArtifactLinks,
   buildA2ARecoverableArtifactMessage,
@@ -400,6 +405,8 @@ export function createSerializedA2ATaskStatusWriter(
   };
 }
 
+const A2A_ACTIVITY_CHECKPOINT_MIN_INTERVAL_MS = 2_000;
+
 export async function resolveA2ARecoverableArtifactSecret(
   orgId: string | null | undefined = getRequestOrgId(),
 ): Promise<string | undefined> {
@@ -1656,10 +1663,36 @@ export function createAgentChatPlugin(
           const a2aEvents: AgentChatEvent[] = [];
           const a2aToolResults: A2AToolResultSummary[] = [];
           let lastRecoverableArtifactText = "";
+          let activityState = createA2AAgentActivityState();
+          let lastActivityCheckpointAt = 0;
           const recoverableArtifactSecret =
             await resolveA2ARecoverableArtifactSecret();
           const recoverableArtifactStatusWriter =
             createSerializedA2ATaskStatusWriter(context.taskId);
+          const activityStatusMessage = (): A2AMessage => ({
+            role: "agent",
+            ...(lastRecoverableArtifactText
+              ? { metadata: { agentNativeRecoverableArtifacts: true } }
+              : {}),
+            parts: [
+              buildA2AAgentActivityPart(activityState),
+              ...(lastRecoverableArtifactText
+                ? [{ type: "text" as const, text: lastRecoverableArtifactText }]
+                : []),
+            ],
+          });
+          const checkpointActivity = (force = false) => {
+            const now = Date.now();
+            if (
+              !force &&
+              now - lastActivityCheckpointAt <
+                A2A_ACTIVITY_CHECKPOINT_MIN_INTERVAL_MS
+            ) {
+              return;
+            }
+            lastActivityCheckpointAt = now;
+            recoverableArtifactStatusWriter.enqueue(activityStatusMessage());
+          };
           const controller = new AbortController();
           const correlation = sanitizeA2ACorrelationMetadata(context.metadata);
           const telemetryThreadId =
@@ -1697,6 +1730,12 @@ export function createAgentChatPlugin(
               turnId: context.taskId,
               send: (event) => {
                 a2aEvents.push(event);
+                const nextActivityState = applyA2AAgentActivityEvent(
+                  activityState,
+                  event,
+                );
+                const activityChanged = nextActivityState !== activityState;
+                activityState = nextActivityState;
                 if (event.type === "tool_start") {
                   console.log(`[A2A] Tool call: ${event.tool}`);
                 } else if (event.type === "tool_done") {
@@ -1727,22 +1766,20 @@ export function createAgentChatPlugin(
                     recoverableArtifactText !== lastRecoverableArtifactText
                   ) {
                     lastRecoverableArtifactText = recoverableArtifactText;
-                    recoverableArtifactStatusWriter.enqueue({
-                      role: "agent",
-                      metadata: { agentNativeRecoverableArtifacts: true },
-                      parts: [
-                        {
-                          type: "text",
-                          text: recoverableArtifactText,
-                        },
-                      ],
-                    });
                   }
                 } else if (event.type === "error") {
                   console.error(`[A2A] Error: ${event.error}`);
                 } else if (event.type === "done") {
                   console.log(`[A2A] Done. Events: ${a2aEvents.length}`);
                 }
+                if (activityChanged) {
+                  checkpointActivity(
+                    event.type === "tool_start" ||
+                      event.type === "tool_done" ||
+                      event.type === "error" ||
+                      event.type === "done",
+                  );
+                }
               },
               signal: controller.signal,
             },
@@ -1779,6 +1816,7 @@ export function createAgentChatPlugin(
 
           // The continuation can observe terminal output immediately, so make
           // its latest mutation checkpoint durable first.
+          checkpointActivity(true);
           await recoverableArtifactStatusWriter.flush();
 
           const approval = [...a2aEvents]
@@ -1817,6 +1855,7 @@ export function createAgentChatPlugin(
                 },
               },
               parts: [
+                buildA2AAgentActivityPart(activityState),
                 {
                   type: "text" as const,
                   text:
@@ -1851,6 +1890,7 @@ export function createAgentChatPlugin(
           yield {
             role: "agent" as const,
             parts: [
+              buildA2AAgentActivityPart(activityState),
               {
                 type: "text" as const,
                 text: finalText || "(no response)",

package/corpus/core/src/server/realtime-voice.ts

@@ -201,7 +201,10 @@ export function resolveRealtimeVoiceReasoningEffort(
 ): "minimal" | "low" | "medium" {
   const normalized = value?.trim().toLowerCase();
   return normalized &&
-    Object.hasOwn(REALTIME_VOICE_REASONING_EFFORT, normalized)
+    Object.prototype.hasOwnProperty.call(
+      REALTIME_VOICE_REASONING_EFFORT,
+      normalized,
+    )
     ? REALTIME_VOICE_REASONING_EFFORT[
         normalized as keyof typeof REALTIME_VOICE_REASONING_EFFORT
       ]

package/corpus/core/src/templates/workspace-core/.agents/skills/a2a-protocol/SKILL.md

@@ -195,6 +195,22 @@ for await (const update of client.stream({
 }
 ```
 
+### Agent activity in delegated chat
+
+Agent Native peers attach a bounded `data` part with
+`kind: "agent-native/agent-activity"` to in-progress and terminal task status
+messages. It contains the same user-visible reasoning summaries shown in the
+receiving app, tool names and completion states, elapsed time, and progressive
+response text. It never includes tool inputs, tool results, credentials, or
+hidden provider reasoning.
+
+`call-agent` reads this optional part while it polls an asynchronous task and
+renders the remote work as a nested agent run. Unknown A2A peers do not need to
+implement the extension: their ordinary status and final text still render in
+the same nested block. Treat activity data as untrusted presentation content;
+never use it for identity, authorization, approval, routing, or artifact
+validation.
+
 ### Carrying explicit chat authorization
 
 When the authenticated caller has an exact consequential action that the user

package/corpus/core/src/templates/workspace-core/.agents/skills/voice-transcription/SKILL.md

@@ -57,11 +57,13 @@ action before requesting microphone permission.
   controls contain only settings and the separate end-session action.
 - The orb's compact waveform stays visible for the full session and reflects
   actual microphone or assistant audio activity. At silence it rests at its
-  baseline instead of turning into a loading spinner. While connecting, show a
-  distinct compact spinner; when the session becomes live, the assistant gives
-  one brief spoken greeting so readiness is unambiguous. Do not apply a
-  text-sized `max_output_tokens` cap to that audio greeting because audio tokens
-  can truncate it mid-sentence.
+  baseline instead of turning into a loading spinner. Once connected, a soft,
+  slowly rotating blue glow marks the live session; brighten and speed up the
+  glow while the agent is working, and keep it static under reduced motion.
+  While connecting, show a distinct compact spinner; when the session becomes
+  live, the assistant gives one brief spoken greeting so readiness is
+  unambiguous. Do not apply a text-sized `max_output_tokens` cap to that audio
+  greeting because audio tokens can truncate it mid-sentence.
 - The orb settings cog opens in place without ending voice mode or navigating
   away. Nested pickers must not dismiss the settings popover. Language and
   intelligence update the active Realtime session; the microphone picker swaps

package/corpus/core/src/terminal/cli-registry.ts

@@ -42,7 +42,7 @@ export const CLI_REGISTRY: Record<string, CliEntry> = {
 
 /** Check if a command name is in the CLI_REGISTRY allowlist */
 export function isAllowedCommand(cmd: string): boolean {
-  return Object.hasOwn(CLI_REGISTRY, cmd);
+  return Object.prototype.hasOwnProperty.call(CLI_REGISTRY, cmd);
 }
 
 /** Check if a CLI command exists on PATH (safe — no shell interpolation) */

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

@@ -732,7 +732,6 @@ function findCorePackageRoot(cwd: string): string | null {
   const candidates = [
     path.resolve(cwd, "../../packages/core"), // templates/<name>/
     path.resolve(cwd, "../core"), // packages/<name>/
-    path.resolve(cwd, "node_modules/@agent-native/core"),
   ];
   for (const candidate of candidates) {
     try {
@@ -2315,6 +2314,165 @@ function portExposer(): Plugin {
   };
 }
 
+function isNitroEnvironmentUnavailable(error: unknown): boolean {
+  const candidate = error as {
+    name?: unknown;
+    status?: unknown;
+    statusCode?: unknown;
+    message?: unknown;
+  };
+  return (
+    candidate?.name === "NitroViteError" &&
+    (candidate.status === 503 || candidate.statusCode === 503) &&
+    typeof candidate.message === "string" &&
+    /Vite environment .+ is unavailable/.test(candidate.message)
+  );
+}
+
+type NitroModuleNode = {
+  id: string | null;
+  ssrError?: Error | null;
+  transformResult: unknown | null;
+};
+
+type NitroModuleGraph = {
+  idToModuleMap: Map<string, NitroModuleNode>;
+};
+
+const NITRO_STARTUP_SETTLE_MS = 1_000;
+const NITRO_STARTUP_TIMEOUT_MS = 30_000;
+
+function nitroModuleGraphSignature(environment: unknown): string | null {
+  const graph = (environment as { moduleGraph?: NitroModuleGraph } | undefined)
+    ?.moduleGraph;
+  if (!graph) return null;
+
+  const modules = [...graph.idToModuleMap.values()];
+  const entry = modules.find((module) =>
+    module.id
+      ?.replaceAll("\\", "/")
+      .endsWith("/nitro/dist/runtime/internal/vite/dev-entry.mjs"),
+  );
+  if (!entry?.transformResult && !entry?.ssrError) return null;
+
+  let transformed = 0;
+  let errors = 0;
+  for (const module of modules) {
+    if (module.transformResult) transformed += 1;
+    if (module.ssrError) errors += 1;
+  }
+  return `${modules.length}:${transformed}:${errors}`;
+}
+
+function isHtmlDocumentRequest(req: IncomingMessage): boolean {
+  return (
+    (req.method === "GET" || req.method === "HEAD") &&
+    (req.headers.accept ?? "").includes("text/html")
+  );
+}
+
+function sendNitroStartingResponse(
+  req: IncomingMessage,
+  res: ServerResponse,
+): void {
+  res.statusCode = 503;
+  res.setHeader("cache-control", "no-store");
+  res.setHeader("content-type", "text/html; charset=utf-8");
+  res.setHeader("retry-after", "1");
+  if (req.method === "HEAD") {
+    res.end();
+    return;
+  }
+  res.end(
+    '<!doctype html><html><head><meta charset="utf-8"><meta http-equiv="refresh" content="0.25"><title>Starting…</title></head><body></body></html>',
+  );
+}
+
+function nitroStartupGate(
+  options: {
+    now?: () => number;
+    settleMs?: number;
+    timeoutMs?: number;
+  } = {},
+): Plugin {
+  return {
+    name: "agent-native-nitro-startup-gate",
+    apply: "serve",
+    enforce: "pre",
+    configureServer(server) {
+      const now = options.now ?? Date.now;
+      const settleMs = options.settleMs ?? NITRO_STARTUP_SETTLE_MS;
+      const timeoutMs = options.timeoutMs ?? NITRO_STARTUP_TIMEOUT_MS;
+      const startedAt = now();
+      let graphSignature: string | null = null;
+      let graphStableAt: number | undefined;
+      let startupComplete = false;
+
+      server.middlewares.use((req, res, next) => {
+        if (startupComplete || !isHtmlDocumentRequest(req)) {
+          next();
+          return;
+        }
+
+        const timestamp = now();
+        if (timestamp - startedAt >= timeoutMs) {
+          startupComplete = true;
+          next();
+          return;
+        }
+
+        const nextGraphSignature = nitroModuleGraphSignature(
+          server.environments?.nitro,
+        );
+        if (nextGraphSignature) {
+          if (nextGraphSignature !== graphSignature) {
+            graphSignature = nextGraphSignature;
+            graphStableAt = timestamp;
+          } else if (
+            graphStableAt !== undefined &&
+            timestamp - graphStableAt >= settleMs
+          ) {
+            startupComplete = true;
+            next();
+            return;
+          }
+        } else {
+          graphSignature = null;
+          graphStableAt = undefined;
+        }
+
+        sendNitroStartingResponse(req, res);
+      });
+    },
+  };
+}
+
+function nitroStartupRecovery(): Plugin {
+  return {
+    name: "agent-native-nitro-startup-recovery",
+    apply: "serve",
+    configureServer(server) {
+      server.middlewares.use(function nitroStartupErrorRecovery(
+        error: unknown,
+        req: IncomingMessage,
+        res: ServerResponse,
+        next: (error?: unknown) => void,
+      ) {
+        if (
+          !isNitroEnvironmentUnavailable(error) ||
+          !isHtmlDocumentRequest(req) ||
+          res.headersSent
+        ) {
+          next(error);
+          return;
+        }
+
+        sendNitroStartingResponse(req, res);
+      });
+    },
+  };
+}
+
 /**
  * Silence benign connection-reset noise from Vite's dev middleware.
  * Fires when a browser closes/reloads/navigates mid-request — the peer has
@@ -2693,6 +2851,7 @@ function createAgentNativePlugins(
     embedDevFrameHeaders(),
     baseRedirectGuard(),
     portExposer(),
+    nitroStartupGate(),
     silenceConnectionResets(),
     rolldownInputFix(),
     // Nitro Vite plugin for dev-mode API route serving and HMR.
@@ -2702,6 +2861,9 @@ function createAgentNativePlugins(
       : includeNitro
         ? [nitroPlugin]
         : []),
+    // Nitro can reject the first document request while its Vite environment
+    // is still importing. This error handler must follow Nitro's middleware.
+    nitroStartupRecovery(),
     includeReactTransform ? createReactTransformPlugin() : null,
     createDesignSystemThemePlugin(options.designSystemTheme),
     createTailwindPlugin(options),
@@ -3096,5 +3258,8 @@ export {
   getDefaultOptimizeDeps as _getDefaultOptimizeDeps,
   findCorePackageRoot as _findCorePackageRoot,
   getReactRouterAliases as _getReactRouterAliases,
+  nitroStartupGate as _nitroStartupGate,
+  nitroStartupRecovery as _nitroStartupRecovery,
+  nitroModuleGraphSignature as _nitroModuleGraphSignature,
   debounceNitroFullReloadHotUpdate as _debounceNitroFullReloadHotUpdate,
 };

package/corpus/templates/analytics/app/hooks/use-dashboard-views.ts

@@ -23,6 +23,18 @@ async function fetchWithAuth(url: string, options?: RequestInit) {
   });
 }
 
+async function responseError(res: Response, fallback: string): Promise<Error> {
+  try {
+    const body = (await res.json()) as { error?: unknown };
+    if (typeof body.error === "string" && body.error.trim()) {
+      return new Error(body.error.trim());
+    }
+  } catch {
+    // Keep the status fallback when the server did not return JSON.
+  }
+  return new Error(`${fallback}: ${res.status}`);
+}
+
 export function useDashboardViews(dashboardId: string | undefined) {
   const queryClient = useQueryClient();
   const queryKey = ["dashboard-views", dashboardId];
@@ -53,7 +65,7 @@ export function useDashboardViews(dashboardId: string | undefined) {
           body: JSON.stringify(view),
         },
       );
-      if (!res.ok) throw new Error(`Save failed: ${res.status}`);
+      if (!res.ok) throw await responseError(res, "Save failed");
     },
     onSettled: () => {
       queryClient.invalidateQueries({ queryKey });

package/corpus/templates/analytics/app/pages/adhoc/sql-dashboard/ViewsMenu.tsx

@@ -7,6 +7,7 @@ import {
 } from "@tabler/icons-react";
 import { useMemo, useState } from "react";
 import { useSearchParams } from "react-router";
+import { toast } from "sonner";
 
 import { ResourceLoadError } from "@/components/ResourceLoadError";
 import {
@@ -147,6 +148,15 @@ export function ViewsMenu({ dashboardId, canEdit = true }: ViewsMenuProps) {
       });
       setViewName("");
       setSaveDialogOpen(false);
+    } catch (error) {
+      toast.error(
+        t("sqlDashboard.saveFailedWithMessage", {
+          message:
+            error instanceof Error
+              ? error.message
+              : t("sqlDashboard.saveFailed"),
+        }),
+      );
     } finally {
       setSavingView(false);
     }

package/corpus/templates/analytics/changelog/2026-07-22-show-a-useful-error-when-saving-a-dashboard-view-fails.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-22
+---
+
+Show a useful error when saving a dashboard view fails