@agent-native/core 0.118.0 → 0.119.0

package/corpus/README.md

@@ -28,6 +28,6 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 
 ## Generated Counts
 
-- core files: 1544
+- core files: 1545
 - toolkit files: 159
-- template files: 6455
+- template files: 6296

package/corpus/core/CHANGELOG.md

@@ -1,5 +1,37 @@
 # @agent-native/core
 
+## 0.119.0
+
+### Minor Changes
+
+- 6f485ac: Remove the redundant Done action from shared share popovers and dialogs.
+- 6f485ac: Stream delegated A2A agent activity into an indented chat run with live reasoning, tool status, elapsed time, and a scroll-free final response.
+
+### Patch Changes
+
+- 6f485ac: Use GPT-5.6 Luna as the default for Builder Gateway and OpenAI connections, keep Claude Sonnet 5 for Anthropic connections, and order the model picker from lowest to highest cost.
+
+## 0.118.1
+
+### Patch Changes
+
+- c15d20f: Only show in-chat connection suggestions for exact provider brands or provider-owned URLs found in user-authored text.
+- c15d20f: Harden browser and CLI error handling and hide editor commands for disabled features.
+- c15d20f: Keep remote MCP OAuth flow state in browser-safe cookie chunks and show Granola's official provider icon.
+- c15d20f: Keep completed chat turns with interactive custom UI expanded and frame custom action UI in a padded card.
+- c15d20f: Pin Slack delivery to the app that received the event and reject legacy bot tokens from a different Slack app.
+- c15d20f: Keep healthy long-running tool and agent calls out of the stuck-run warning, add space below long-running tool hints, and prevent a hung remote status request from bypassing the A2A call timeout.
+- c15d20f: Wait for Nitro's Vite environment before serving initial development requests, and keep published Core installs from enabling framework-monorepo dependency optimization.
+- c15d20f: Consume agent-authored URL navigation commands from full-page chat surfaces.
+- c15d20f: Remove the obsolete active-tool row selector so stale styles cannot paint the shine outside the label text.
+- c15d20f: Shorten the MCP OAuth connection action label to Connect.
+- c15d20f: Show a soft rotating blue glow for live realtime voice sessions and brighten it while the agent is working.
+- c15d20f: Synchronize the chat response regenerate control and timestamp fade transitions.
+- Updated dependencies [c15d20f]
+- Updated dependencies [c15d20f]
+- Updated dependencies [c15d20f]
+  - @agent-native/toolkit@0.10.1
+
 ## 0.118.0
 
 ### Minor Changes

package/corpus/core/docs/content/a2a-protocol.mdx

@@ -434,6 +434,21 @@ Like `callAgent()`, the CLI defaults to async + poll (`invokeAgent` → `callAge
 
 The target resolves the same way as `agentNative.invoke()`: by workspace app id, by app name, or by a full URL — so the same command works against a sibling app in a multi-app workspace or an arbitrary A2A peer elsewhere.
 
+## Delegated agent activity {#delegated-agent-activity}
+
+Agent Native peers may attach an optional `data` part with
+`kind: "agent-native/agent-activity"` to task status messages. It carries a
+bounded snapshot of the user-visible reasoning summaries, tool names and
+completion states, elapsed time, and progressive response text. Calling apps
+render these updates as a nested agent run and collapse the work history when
+the delegated task finishes.
+
+The activity part never includes tool inputs, tool results, credentials, or
+hidden provider reasoning. Treat it as untrusted presentation data, never as
+identity, authorization, approval, routing, or artifact validation. External
+A2A peers can omit the extension; their ordinary status text and final response
+still render in the same delegated-agent surface.
+
 ## Task lifecycle {#task-lifecycle}
 
 Each message creates a task that moves through these states:

package/corpus/core/docs/content/template-chat.mdx

@@ -13,7 +13,7 @@ If you want a finished domain product shape, start from [Calendar](/docs/templat
   <Screen
     surface="desktop"
     html={
-      "<div style='min-height:560px;box-sizing:border-box;display:flex;align-items:center;justify-content:center;padding:56px 40px'><div style='display:flex;flex-direction:column;align-items:center;justify-content:center;gap:28px;width:min(700px,92%);min-height:430px'><div style='height:34px'></div><div style='text-align:center'><h1 style='margin:0'>How can I help?</h1><p class='wf-muted' style='margin:10px 0 0'>Chat about anything. Add actions, components, pages, jobs, or your own backend.</p></div><div class='wf-card' style='width:100%;min-height:150px;display:flex;flex-direction:column;gap:18px'><span class='wf-muted'>Message the agent...</span><div style='flex:1'></div><div style='display:flex;align-items:center;gap:10px'><span data-icon='plus' aria-label='Attach'></span><div style='flex:1'></div><span class='wf-pill'>Sonnet 5 · Auto</span><span class='wf-pill'>Act</span><button class='primary'>↑</button></div></div><div style='height:34px'></div></div></div>"
+      "<div style='min-height:560px;box-sizing:border-box;display:flex;align-items:center;justify-content:center;padding:56px 40px'><div style='display:flex;flex-direction:column;align-items:center;justify-content:center;gap:28px;width:min(700px,92%);min-height:430px'><div style='height:34px'></div><div style='text-align:center'><h1 style='margin:0'>How can I help?</h1><p class='wf-muted' style='margin:10px 0 0'>Chat about anything. Add actions, components, pages, jobs, or your own backend.</p></div><div class='wf-card' style='width:100%;min-height:150px;display:flex;flex-direction:column;gap:18px'><span class='wf-muted'>Message the agent...</span><div style='flex:1'></div><div style='display:flex;align-items:center;gap:10px'><span data-icon='plus' aria-label='Attach'></span><div style='flex:1'></div><span class='wf-pill'>GPT-5.6 Luna · Auto</span><span class='wf-pill'>Act</span><button class='primary'>↑</button></div></div><div style='height:34px'></div></div></div>"
     }
   />
 </WireframeBlock>

package/corpus/core/docs/content/template-plan.mdx

@@ -232,9 +232,9 @@ Generating a plan or recap runs a full agentic session against your coding
 agent's LLM, not a lightweight template fill, so cost scales with the size of
 the diff or plan and the model you choose.
 
-- The app's own default chat model is Sonnet 5; change it any time in
-  **Settings**. Haiku is the cheaper Claude option, and Luna is the cheaper
-  option in the GPT-5.6 family.
+- The app's default chat model is GPT-5.6 Luna. Direct Anthropic connections
+  keep Claude Sonnet 5 as their default. Change models any time in **Settings**;
+  Haiku is the cheaper Claude option.
 - Automated PR recaps from the GitHub Action run separately from the
   interactive app and have their own model and cost knobs — see
   [PR Visual Recap](/docs/pr-visual-recap) for `VISUAL_RECAP_MODEL`,

package/corpus/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.118.0",
+  "version": "0.119.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": {

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

@@ -0,0 +1,371 @@
+import { sanitizeToolErrorText } from "../agent/tool-error-redaction.js";
+import type { AgentChatEvent } from "../agent/types.js";
+import type { DataPart, Part } from "./types.js";
+
+export const A2A_AGENT_ACTIVITY_KIND = "agent-native/agent-activity";
+export const A2A_AGENT_ACTIVITY_VERSION = 1;
+export const MAX_A2A_ACTIVITY_REASONING_CHARS = 32_768;
+export const MAX_A2A_ACTIVITY_RESPONSE_CHARS = 32_768;
+export const MAX_A2A_ACTIVITY_TOTAL_CHARS = 98_304;
+export const MAX_A2A_ACTIVITY_REASONING_SEGMENTS = 128;
+export const MAX_A2A_ACTIVITY_TOOL_CALLS = 64;
+export const MAX_A2A_ACTIVITY_TOOL_NAME_CHARS = 96;
+export const MAX_A2A_ACTIVITY_TOOL_ID_CHARS = 128;
+
+export type A2AAgentActivityPhase =
+  | "reasoning"
+  | "tool"
+  | "responding"
+  | "complete"
+  | "error";
+
+export type A2AAgentActivityToolStatus = "running" | "completed" | "failed";
+
+export interface A2AAgentActivityToolCall {
+  name: string;
+  id?: string;
+  status: A2AAgentActivityToolStatus;
+}
+
+export interface A2AAgentActivitySnapshot extends Record<string, unknown> {
+  kind: typeof A2A_AGENT_ACTIVITY_KIND;
+  version: typeof A2A_AGENT_ACTIVITY_VERSION;
+  sequence: number;
+  startedAt: number;
+  updatedAt: number;
+  durationMs: number;
+  activePhase: A2AAgentActivityPhase;
+  reasoning: string[];
+  toolCalls: A2AAgentActivityToolCall[];
+  responseText?: string;
+}
+
+export interface A2AAgentActivityState {
+  sequence: number;
+  startedAt: number;
+  updatedAt: number;
+  activePhase: A2AAgentActivityPhase;
+  reasoning: string[];
+  toolCalls: A2AAgentActivityToolCall[];
+  responseText: string;
+}
+
+export function createA2AAgentActivityState(
+  startedAt = Date.now(),
+): A2AAgentActivityState {
+  return {
+    sequence: 0,
+    startedAt,
+    updatedAt: startedAt,
+    activePhase: "reasoning",
+    reasoning: [],
+    toolCalls: [],
+    responseText: "",
+  };
+}
+
+/**
+ * Converts internal loop events into a bounded activity snapshot. It carries
+ * only reasoning text already emitted to the local chat, never tool inputs or
+ * results.
+ */
+export function applyA2AAgentActivityEvent(
+  state: A2AAgentActivityState,
+  event: AgentChatEvent,
+  updatedAt = Date.now(),
+): A2AAgentActivityState {
+  const next = { ...state, updatedAt: normalizeTimestamp(updatedAt) };
+  let changed = false;
+
+  switch (event.type) {
+    case "thinking":
+      next.activePhase = "reasoning";
+      next.reasoning = appendBoundedSegment(
+        next.reasoning,
+        event.text,
+        MAX_A2A_ACTIVITY_REASONING_CHARS,
+        next.toolCalls.length,
+      );
+      changed = true;
+      break;
+    case "tool_start":
+      next.activePhase = "tool";
+      next.responseText = "";
+      next.toolCalls = appendToolCall(next.toolCalls, toolFromEvent(event));
+      changed = true;
+      break;
+    case "tool_done":
+      next.activePhase = "tool";
+      next.toolCalls = settleToolCall(next.toolCalls, toolFromEvent(event));
+      changed = true;
+      break;
+    case "text":
+      next.activePhase = "responding";
+      next.responseText = appendBoundedText(
+        next.responseText,
+        event.text,
+        MAX_A2A_ACTIVITY_RESPONSE_CHARS,
+      );
+      changed = true;
+      break;
+    case "done":
+      next.activePhase = "complete";
+      changed = true;
+      break;
+    case "error":
+      next.activePhase = "error";
+      changed = true;
+      break;
+    case "clear":
+      next.responseText = "";
+      changed = true;
+      break;
+  }
+
+  return changed ? { ...next, sequence: state.sequence + 1 } : state;
+}
+
+export function buildA2AAgentActivitySnapshot(
+  state: A2AAgentActivityState,
+): A2AAgentActivitySnapshot {
+  return {
+    kind: A2A_AGENT_ACTIVITY_KIND,
+    version: A2A_AGENT_ACTIVITY_VERSION,
+    sequence: state.sequence,
+    startedAt: state.startedAt,
+    updatedAt: state.updatedAt,
+    durationMs: Math.max(0, state.updatedAt - state.startedAt),
+    activePhase: state.activePhase,
+    reasoning: state.reasoning,
+    toolCalls: state.toolCalls,
+    ...(state.responseText ? { responseText: state.responseText } : {}),
+  };
+}
+
+export function buildA2AAgentActivityPart(
+  state: A2AAgentActivityState,
+): DataPart {
+  return { type: "data", data: buildA2AAgentActivitySnapshot(state) };
+}
+
+export function parseA2AAgentActivityPart(
+  part: Part | unknown,
+): A2AAgentActivitySnapshot | null {
+  if (!part || typeof part !== "object") return null;
+  const candidate = part as { type?: unknown; data?: unknown };
+  if (candidate.type !== "data" || !isRecord(candidate.data)) return null;
+  const data = candidate.data;
+  if (
+    data.kind !== A2A_AGENT_ACTIVITY_KIND ||
+    data.version !== A2A_AGENT_ACTIVITY_VERSION ||
+    !isSafeInteger(data.sequence) ||
+    !isSafeInteger(data.startedAt) ||
+    !isSafeInteger(data.updatedAt) ||
+    !isSafeInteger(data.durationMs) ||
+    !isPhase(data.activePhase) ||
+    data.updatedAt < data.startedAt ||
+    data.durationMs !== data.updatedAt - data.startedAt ||
+    !isSafeReasoning(data.reasoning) ||
+    !isSafeToolCalls(data.toolCalls) ||
+    (data.responseText !== undefined &&
+      !isSafeText(data.responseText, MAX_A2A_ACTIVITY_RESPONSE_CHARS)) ||
+    activityCharacterCount(data) > MAX_A2A_ACTIVITY_TOTAL_CHARS
+  ) {
+    return null;
+  }
+
+  return data as unknown as A2AAgentActivitySnapshot;
+}
+
+function toolFromEvent(
+  event: Extract<AgentChatEvent, { type: "tool_start" | "tool_done" }>,
+): A2AAgentActivityToolCall {
+  const id = sanitizeToolId(event.id);
+  return {
+    name: sanitizeToolName(event.tool),
+    ...(id ? { id } : {}),
+    status:
+      event.type === "tool_start"
+        ? "running"
+        : event.isError
+          ? "failed"
+          : "completed",
+  };
+}
+
+function appendBoundedText(
+  current: string,
+  addition: string,
+  maxChars: number,
+) {
+  return sanitizeText(`${current}${addition}`, maxChars);
+}
+
+function appendBoundedSegment(
+  current: string[],
+  addition: string,
+  maxChars: number,
+  precedingToolCount: number,
+): string[] {
+  const used = current.reduce((total, text) => total + text.length, 0);
+  if (
+    used >= maxChars ||
+    current.length >= MAX_A2A_ACTIVITY_REASONING_SEGMENTS
+  ) {
+    return current;
+  }
+  const text = sanitizeText(addition, maxChars - used);
+  if (!text) return current;
+  const next = [...current];
+  while (
+    next.length < precedingToolCount &&
+    next.length < MAX_A2A_ACTIVITY_REASONING_SEGMENTS
+  ) {
+    next.push("");
+  }
+  if (next.length === precedingToolCount) {
+    return [...next, text];
+  }
+  next[precedingToolCount] = `${next[precedingToolCount] ?? ""}${text}`;
+  return next;
+}
+
+function appendToolCall(
+  current: A2AAgentActivityToolCall[],
+  tool: A2AAgentActivityToolCall,
+): A2AAgentActivityToolCall[] {
+  return current.length < MAX_A2A_ACTIVITY_TOOL_CALLS
+    ? [...current, tool]
+    : current;
+}
+
+function settleToolCall(
+  current: A2AAgentActivityToolCall[],
+  tool: A2AAgentActivityToolCall,
+): A2AAgentActivityToolCall[] {
+  for (let index = current.length - 1; index >= 0; index -= 1) {
+    const existing = current[index];
+    if (
+      (tool.id && tool.id === existing.id) ||
+      (!tool.id && tool.name === existing.name)
+    ) {
+      return current.map((value, itemIndex) =>
+        itemIndex === index ? tool : value,
+      );
+    }
+  }
+  return appendToolCall(current, tool);
+}
+
+function sanitizeText(value: string, maxChars: number): string {
+  return sanitizeToolErrorText(value)
+    .replace(/\r\n?/g, "\n")
+    .replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, "")
+    .slice(0, maxChars);
+}
+
+function sanitizeToolName(value: string): string {
+  return sanitizeText(value, MAX_A2A_ACTIVITY_TOOL_NAME_CHARS) || "tool";
+}
+
+function sanitizeToolId(value: string | undefined): string | undefined {
+  const sanitized = value
+    ? sanitizeText(value, MAX_A2A_ACTIVITY_TOOL_ID_CHARS)
+    : "";
+  return sanitized || undefined;
+}
+
+function normalizeTimestamp(value: number): number {
+  return isSafeInteger(value) ? value : Date.now();
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+function isSafeInteger(value: unknown): value is number {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+
+function isPhase(value: unknown): value is A2AAgentActivityPhase {
+  return ["reasoning", "tool", "responding", "complete", "error"].includes(
+    value as string,
+  );
+}
+
+function isSafeReasoning(value: unknown): value is string[] {
+  return (
+    Array.isArray(value) &&
+    value.length <= MAX_A2A_ACTIVITY_REASONING_SEGMENTS &&
+    value.reduce(
+      (total, text) =>
+        total + (typeof text === "string" ? text.length : Infinity),
+      0,
+    ) <= MAX_A2A_ACTIVITY_REASONING_CHARS &&
+    value.every((text) => isSafeText(text, MAX_A2A_ACTIVITY_REASONING_CHARS))
+  );
+}
+
+function isSafeToolCalls(value: unknown): value is A2AAgentActivityToolCall[] {
+  return (
+    Array.isArray(value) &&
+    value.length <= MAX_A2A_ACTIVITY_TOOL_CALLS &&
+    value.every(isSafeToolCall)
+  );
+}
+
+function isSafeToolCall(value: unknown): value is A2AAgentActivityToolCall {
+  if (!isRecord(value) || !isSafeToolName(value.name)) return false;
+  return (
+    (value.id === undefined || isSafeToolId(value.id)) &&
+    (value.status === "running" ||
+      value.status === "completed" ||
+      value.status === "failed")
+  );
+}
+
+function isSafeText(value: unknown, maxChars: number): value is string {
+  return (
+    typeof value === "string" &&
+    value.length <= maxChars &&
+    value === sanitizeText(value, maxChars)
+  );
+}
+
+function isSafeToolName(value: unknown): value is string {
+  return (
+    typeof value === "string" &&
+    value.length <= MAX_A2A_ACTIVITY_TOOL_NAME_CHARS &&
+    value === sanitizeToolName(value)
+  );
+}
+
+function isSafeToolId(value: unknown): value is string {
+  return (
+    typeof value === "string" &&
+    value.length <= MAX_A2A_ACTIVITY_TOOL_ID_CHARS &&
+    value === sanitizeToolId(value)
+  );
+}
+
+function activityCharacterCount(data: Record<string, unknown>): number {
+  const reasoning = Array.isArray(data.reasoning)
+    ? data.reasoning.reduce(
+        (total, text) => total + (typeof text === "string" ? text.length : 0),
+        0,
+      )
+    : 0;
+  const response =
+    typeof data.responseText === "string" ? data.responseText.length : 0;
+  const tools = Array.isArray(data.toolCalls)
+    ? data.toolCalls.reduce((total, tool) => {
+        if (!isRecord(tool)) return total;
+        return (
+          total +
+          (typeof tool.name === "string" ? tool.name.length : 0) +
+          (typeof tool.id === "string" ? tool.id.length : 0)
+        );
+      }, 0)
+    : 0;
+  return reasoning + response + tools;
+}

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

@@ -14,6 +14,8 @@ import type {
   Task,
 } from "./types.js";
 
+const DEFAULT_A2A_POLL_REQUEST_TIMEOUT_MS = 15_000;
+
 export class A2ATaskTimeoutError extends Error {
   readonly taskId: string;
   readonly lastTask: Task;
@@ -171,6 +173,7 @@ export class A2AClient {
   private async rpc(
     method: string,
     params: Record<string, unknown>,
+    options?: { requestTimeoutMs?: number },
   ): Promise<JsonRpcResponse> {
     const body: JsonRpcRequest = {
       jsonrpc: "2.0",
@@ -186,7 +189,12 @@ export class A2AClient {
       for (let i = 0; i < this.apiKeyAttempts.length; i++) {
         console.log(`[A2A Client] POST ${url} method=${method}`);
         const startTime = Date.now();
-        const res = await this.postJson(url, body, this.apiKeyAttempts[i]);
+        const res = await this.postJson(
+          url,
+          body,
+          this.apiKeyAttempts[i],
+          options?.requestTimeoutMs,
+        );
         console.log(
           `[A2A Client] Response: ${res.status} in ${Date.now() - startTime}ms`,
         );
@@ -278,8 +286,15 @@ export class A2AClient {
   /**
    * Poll for a task by id. Used in async mode after `send({ async: true })`.
    */
-  async getTask(taskId: string): Promise<Task> {
-    const response = await this.rpc("tasks/get", { id: taskId });
+  async getTask(
+    taskId: string,
+    opts?: { requestTimeoutMs?: number },
+  ): Promise<Task> {
+    const response = await this.rpc(
+      "tasks/get",
+      { id: taskId },
+      { requestTimeoutMs: opts?.requestTimeoutMs },
+    );
     if (response.error) {
       throw new Error(
         `A2A error (${response.error.code}): ${response.error.message}`,
@@ -392,9 +407,17 @@ export class A2AClient {
 
     let current = submitted;
     while (Date.now() < deadline) {
-      await new Promise((r) => setTimeout(r, pollMs));
+      const sleepMs = Math.min(pollMs, Math.max(0, deadline - Date.now()));
+      await new Promise((r) => setTimeout(r, sleepMs));
+      const remainingMs = deadline - Date.now();
+      if (remainingMs <= 0) break;
       try {
-        current = await this.getTask(submitted.id);
+        current = await this.getTask(submitted.id, {
+          requestTimeoutMs: Math.min(
+            this.requestTimeoutMs ?? DEFAULT_A2A_POLL_REQUEST_TIMEOUT_MS,
+            remainingMs,
+          ),
+        });
         opts?.onUpdate?.(current);
       } catch {
         // Transient fetch failure — keep polling until the deadline.
@@ -509,13 +532,12 @@ export class A2AClient {
     url: string,
     body: JsonRpcRequest,
     apiKey = this.apiKey,
+    requestTimeoutMs = this.requestTimeoutMs,
   ): Promise<Response> {
-    const controller = this.requestTimeoutMs
-      ? new AbortController()
-      : undefined;
+    const controller = requestTimeoutMs ? new AbortController() : undefined;
     const timer =
-      controller && this.requestTimeoutMs
-        ? setTimeout(() => controller.abort(), this.requestTimeoutMs)
+      controller && requestTimeoutMs
+        ? setTimeout(() => controller.abort(), requestTimeoutMs)
         : undefined;
     try {
       return await ssrfSafeFetch(
@@ -625,6 +647,8 @@ export async function callAgent(
   text: string,
   opts?: {
     apiKey?: string;
+    /** Additional transport metadata. Receivers must not use it as identity. */
+    metadata?: Record<string, unknown>;
     contextId?: string;
     userEmail?: string;
     orgDomain?: string;
@@ -672,7 +696,7 @@ export async function callAgent(
     onUpdate?: (task: Task) => void;
   },
 ): Promise<string> {
-  const metadata: Record<string, unknown> = {};
+  const metadata: Record<string, unknown> = { ...opts?.metadata };
   if (opts?.userEmail) metadata.userEmail = opts.userEmail;
   if (opts?.orgDomain) metadata.orgDomain = opts.orgDomain;
   if (opts?.requestOrigin) metadata.requestOrigin = opts.requestOrigin;

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

@@ -2,6 +2,22 @@
 export { mountA2A, verifyA2AToken } from "./server.js";
 export type { A2ATokenPayload } from "./server.js";
 export { generateAgentCard } from "./agent-card.js";
+export {
+  A2A_AGENT_ACTIVITY_KIND,
+  A2A_AGENT_ACTIVITY_VERSION,
+  MAX_A2A_ACTIVITY_REASONING_CHARS,
+  MAX_A2A_ACTIVITY_REASONING_SEGMENTS,
+  MAX_A2A_ACTIVITY_RESPONSE_CHARS,
+  MAX_A2A_ACTIVITY_TOOL_CALLS,
+  MAX_A2A_ACTIVITY_TOTAL_CHARS,
+  MAX_A2A_ACTIVITY_TOOL_ID_CHARS,
+  MAX_A2A_ACTIVITY_TOOL_NAME_CHARS,
+  applyA2AAgentActivityEvent,
+  buildA2AAgentActivityPart,
+  buildA2AAgentActivitySnapshot,
+  createA2AAgentActivityState,
+  parseA2AAgentActivityPart,
+} from "./activity.js";
 
 // Client
 export { A2AClient, callAction, callAgent, signA2AToken } from "./client.js";
@@ -38,6 +54,11 @@ export type {
   A2ACorrelationMetadata,
   A2AReadOnlyActionInvocation,
   A2AReadOnlyActionResult,
+  A2AAgentActivityPhase,
+  A2AAgentActivitySnapshot,
+  A2AAgentActivityState,
+  A2AAgentActivityToolCall,
+  A2AAgentActivityToolStatus,
 } from "./types.js";
 export type {
   AgentInvocationErrorCode,

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

@@ -1,6 +1,14 @@
 // A2A Protocol types (spec v0.3) + framework config types
 import type { PublicAgentActionConfig } from "../action.js";
 
+export type {
+  A2AAgentActivityPhase,
+  A2AAgentActivitySnapshot,
+  A2AAgentActivityState,
+  A2AAgentActivityToolCall,
+  A2AAgentActivityToolStatus,
+} from "./activity.js";
+
 // --- Parts (content atoms) ---
 
 export interface TextPart {