@agent-native/core 0.118.0 → 0.119.0

package/corpus/toolkit/src/conformance/runner.tsx

@@ -122,6 +122,87 @@ function elementWithText(document: Document, selector: string, text: string) {
   );
 }
 
+function assertInlineLayout(
+  container: Element,
+  iconSelector: string,
+  labelSelector: string,
+  message: string,
+) {
+  const icon = container.querySelector<HTMLElement>(iconSelector);
+  const label = container.querySelector<HTMLElement>(labelSelector);
+  invariant(icon && label, message);
+
+  const iconRect = icon.getBoundingClientRect();
+  const labelRect = label.getBoundingClientRect();
+  const hasGeometry =
+    iconRect.width > 0 ||
+    iconRect.height > 0 ||
+    labelRect.width > 0 ||
+    labelRect.height > 0;
+  if (hasGeometry) {
+    const verticalOverlap =
+      Math.min(iconRect.bottom, labelRect.bottom) -
+      Math.max(iconRect.top, labelRect.top);
+    invariant(
+      verticalOverlap > 0 || Math.abs(iconRect.top - labelRect.top) <= 2,
+      message,
+    );
+    return;
+  }
+
+  // happy-dom does not calculate layout. Still reject adapters that explicitly
+  // stack the tab contents, while browser-backed runs use the geometry check.
+  const commonAncestor = (() => {
+    let candidate: Element | null = icon;
+    while (candidate && !candidate.contains(label)) {
+      candidate = candidate.parentElement;
+    }
+    return candidate;
+  })();
+  const styles = [
+    container,
+    commonAncestor,
+    icon.parentElement,
+    label.parentElement,
+  ]
+    .filter((element): element is Element => Boolean(element))
+    .map((element) =>
+      element.ownerDocument.defaultView?.getComputedStyle(element),
+    );
+  invariant(
+    !styles.some(
+      (style) => style?.display === "flex" && style.flexDirection === "column",
+    ),
+    message,
+  );
+}
+
+function assertContainedFooter(dialog: Element, footerSelector: string) {
+  const footer = dialog.querySelector<HTMLElement>(footerSelector);
+  invariant(
+    footer,
+    "Dialog footer controls must be rendered inside the dialog surface.",
+  );
+
+  const dialogRect = (dialog as HTMLElement).getBoundingClientRect();
+  const footerRect = footer.getBoundingClientRect();
+  const hasGeometry =
+    dialogRect.width > 0 ||
+    dialogRect.height > 0 ||
+    footerRect.width > 0 ||
+    footerRect.height > 0;
+  if (!hasGeometry) return;
+
+  const epsilon = 2;
+  invariant(
+    footerRect.top >= dialogRect.top - epsilon &&
+      footerRect.bottom <= dialogRect.bottom + epsilon &&
+      footerRect.left >= dialogRect.left - epsilon &&
+      footerRect.right <= dialogRect.right + epsilon,
+    "Dialog footer controls must remain within the dialog surface bounds.",
+  );
+}
+
 const checks: readonly ConformanceCheck[] = [
   {
     id: "contract.components",
@@ -308,6 +389,21 @@ const checks: readonly ConformanceCheck[] = [
         "Tooltip must honor controlled open and portalContainer.",
       );
       unmount(probe);
+
+      const defaultOpenProbe = mount(
+        <components.Tooltip
+          trigger={<button>Help by default</button>}
+          content="Default tooltip"
+          defaultOpen
+          portalContainer={portal}
+        />,
+      );
+      await settle();
+      invariant(
+        portal.textContent?.includes("Default tooltip"),
+        "Tooltip must honor defaultOpen and portalContainer.",
+      );
+      unmount(defaultOpenProbe);
       portal.remove();
     },
   },
@@ -331,6 +427,21 @@ const checks: readonly ConformanceCheck[] = [
       click(item, document);
       invariant(selected === "archive", "Menu must report selected item ids.");
       unmount(probe);
+
+      const defaultOpenProbe = mount(
+        <components.Menu
+          trigger={<button>Default actions</button>}
+          items={[{ id: "restore", label: "Restore" }]}
+          defaultOpen
+          onAction={() => {}}
+        />,
+      );
+      await settle();
+      invariant(
+        elementWithText(document, '[role="menuitem"]', "Restore"),
+        "Menu must honor defaultOpen.",
+      );
+      unmount(defaultOpenProbe);
     },
   },
   {
@@ -393,6 +504,30 @@ const checks: readonly ConformanceCheck[] = [
         "Dialog must not invent actions when footer is omitted.",
       );
       unmount(probe);
+
+      const footerProbe = mount(
+        <components.Dialog
+          open
+          onOpenChange={() => {}}
+          title="Footer probe"
+          portalContainer={portal}
+          footer={
+            <button data-conformance-dialog-footer-action="true" type="button">
+              Save
+            </button>
+          }
+        >
+          Footer content
+        </components.Dialog>,
+      );
+      await settle();
+      const footerDialog = portal.querySelector('[role="dialog"]');
+      invariant(footerDialog, "Dialog footer probe did not render a dialog.");
+      assertContainedFooter(
+        footerDialog,
+        '[data-conformance-dialog-footer-action="true"]',
+      );
+      unmount(footerProbe);
       portal.remove();
     },
   },
@@ -466,7 +601,16 @@ const checks: readonly ConformanceCheck[] = [
           orientation="vertical"
           onChange={(next) => (value = next)}
           items={[
-            { value: "first", label: "First", content: "One" },
+            {
+              value: "first",
+              label: <span data-conformance-tab-label="true">First</span>,
+              icon: (
+                <span data-conformance-tab-icon="true" aria-hidden="true">
+                  ●
+                </span>
+              ),
+              content: "One",
+            },
             { value: "second", label: "Second", content: "Two" },
           ]}
         />,
@@ -477,6 +621,14 @@ const checks: readonly ConformanceCheck[] = [
         tabList.getAttribute("aria-orientation") === "vertical",
         "Tabs must honor vertical orientation in their tablist semantics.",
       );
+      const first = elementWithText(document, '[role="tab"]', "First");
+      invariant(first, "Tabs must expose the icon-bearing tab.");
+      assertInlineLayout(
+        first,
+        '[data-conformance-tab-icon="true"]',
+        '[data-conformance-tab-label="true"]',
+        "Tabs must lay out an icon and its label on the same row.",
+      );
       const second = elementWithText(document, '[role="tab"]', "Second");
       invariant(second, "Tabs must expose tab semantics.");
       click(second, document);

package/corpus/toolkit/src/editor/SharedRichEditor.tsx

@@ -14,7 +14,12 @@ import {
   type SharedEditorFeatures,
 } from "./extensions.js";
 import type { ImageUploadFn } from "./ImageExtension.js";
-import { SlashCommandMenu, type SlashCommandItem } from "./SlashCommandMenu.js";
+import {
+  DEFAULT_SLASH_COMMANDS,
+  filterSlashCommandItems,
+  SlashCommandMenu,
+  type SlashCommandItem,
+} from "./SlashCommandMenu.js";
 import {
   useCollabReconcile,
   getEditorMarkdown,
@@ -200,6 +205,12 @@ export function SharedRichEditor({
 
   const collab = !!ydoc;
 
+  const effectiveSlashItems = useMemo(
+    () =>
+      filterSlashCommandItems(slashItems ?? DEFAULT_SLASH_COMMANDS, features),
+    [features, slashItems],
+  );
+
   // The collab hook needs the editor, but useEditor's `onUpdate` needs the
   // hook's guards. Break the cycle with a ref: `onUpdate` reads the guards
   // through `guardsRef`, which is populated right after the hook runs below.
@@ -313,7 +324,7 @@ export function SharedRichEditor({
         <BubbleToolbar editor={editor} buildItems={buildBubbleItems} />
       ) : null}
       {editable ? (
-        <SlashCommandMenu editor={editor} items={slashItems} />
+        <SlashCommandMenu editor={editor} items={effectiveSlashItems} />
       ) : null}
       <EditorContent editor={editor} />
     </div>

package/corpus/toolkit/src/editor/SlashCommandMenu.tsx

@@ -22,9 +22,26 @@ export interface SlashCommandItem {
   searchText?: string;
   /** Short text glyph shown in the menu (T, H1, tbl, …). */
   icon: string;
+  /** Hide this command when the shared editor feature is disabled. */
+  requires?: "tables" | "tasks" | "codeBlock";
   action: (editor: Editor) => void;
 }
 
+export interface SlashCommandFeatureFlags {
+  tables?: boolean;
+  tasks?: boolean;
+  codeBlock?: boolean;
+}
+
+export function filterSlashCommandItems(
+  items: readonly SlashCommandItem[],
+  features?: SlashCommandFeatureFlags,
+): SlashCommandItem[] {
+  return items.filter(
+    (item) => !item.requires || features?.[item.requires] !== false,
+  );
+}
+
 /**
  * The default block commands — Plan's current set. Apps pass their own `items`
  * (typically `[...DEFAULT_SLASH_COMMANDS, ...extra]`) to extend it.
@@ -73,6 +90,7 @@ export const DEFAULT_SLASH_COMMANDS: SlashCommandItem[] = [
     title: "To-do list",
     description: "Checklist items",
     icon: "[]",
+    requires: "tasks",
     action: (editor) => editor.chain().focus().toggleTaskList().run(),
   },
   {
@@ -85,6 +103,7 @@ export const DEFAULT_SLASH_COMMANDS: SlashCommandItem[] = [
     title: "Code block",
     description: "Code snippet",
     icon: "<>",
+    requires: "codeBlock",
     action: (editor) => editor.chain().focus().toggleCodeBlock().run(),
   },
   {
@@ -97,6 +116,7 @@ export const DEFAULT_SLASH_COMMANDS: SlashCommandItem[] = [
     title: "Table",
     description: "Three by three table",
     icon: "tbl",
+    requires: "tables",
     action: (editor) =>
       editor
         .chain()

package/corpus/toolkit/src/editor/index.ts

@@ -25,8 +25,10 @@ export {
   SlashCommandMenu,
   DEFAULT_SLASH_COMMANDS,
   createImageSlashCommand,
+  filterSlashCommandItems,
   type SlashCommandItem,
   type SlashCommandMenuProps,
+  type SlashCommandFeatureFlags,
 } from "./SlashCommandMenu.js";
 export {
   SharedImage,

package/corpus/toolkit/src/styles.css

@@ -20,37 +20,66 @@
  */
 @source "./**/*.{js,ts,tsx}";
 
-.agent-realtime-voice-working::after {
+.agent-realtime-voice-glow {
+  --agent-realtime-voice-edge-opacity: 0.52;
+  --agent-realtime-voice-halo-opacity: 0.28;
   position: absolute;
   z-index: 0;
+  inset: -4px;
+  border-radius: inherit;
+  pointer-events: none;
+  transform: rotate(0turn);
+  will-change: transform;
+}
+
+.agent-realtime-voice-working {
+  --agent-realtime-voice-edge-opacity: 0.92;
+  --agent-realtime-voice-halo-opacity: 0.58;
+}
+
+.agent-realtime-voice-glow::before,
+.agent-realtime-voice-glow::after {
+  position: absolute;
   inset: 0;
   border-radius: inherit;
   pointer-events: none;
   content: "";
+  background: conic-gradient(
+    from -18deg,
+    transparent 0deg 228deg,
+    oklch(0.65 0.2 294 / 0.18) 244deg,
+    oklch(0.7 0.2 265 / 0.7) 274deg,
+    oklch(0.79 0.16 235 / 0.96) 306deg,
+    oklch(0.96 0.035 210) 326deg,
+    oklch(0.88 0.11 202 / 0.72) 340deg,
+    transparent 360deg
+  );
+  opacity: var(--agent-realtime-voice-edge-opacity);
+  padding: 1.5px;
+  -webkit-mask:
+    linear-gradient(#000 0 0) content-box,
+    linear-gradient(#000 0 0);
+  mask:
+    linear-gradient(#000 0 0) content-box,
+    linear-gradient(#000 0 0);
+  -webkit-mask-composite: xor;
+  mask-composite: exclude;
+  transition: opacity 220ms ease-out;
 }
 
-@media (prefers-reduced-motion: no-preference) {
-  .agent-realtime-voice-working::after {
-    background: linear-gradient(
-      90deg,
-      transparent 0%,
-      transparent 36%,
-      hsl(var(--foreground) / 0.14) 50%,
-      transparent 64%,
-      transparent 100%
-    );
-    background-repeat: repeat;
-    background-size: 14rem 100%;
-    animation: agent-realtime-voice-shine 2.6s linear infinite;
-  }
-
-  @keyframes agent-realtime-voice-shine {
-    from {
-      background-position: 0 0;
-    }
+.agent-realtime-voice-glow::before {
+  inset: -1px;
+  opacity: var(--agent-realtime-voice-halo-opacity);
+  padding: 2px;
+  filter: blur(1px) drop-shadow(0 0 2px oklch(0.9 0.07 215 / 0.95))
+    drop-shadow(0 0 6px oklch(0.78 0.15 236 / 0.82))
+    drop-shadow(0 0 14px oklch(0.67 0.2 258 / 0.48))
+    drop-shadow(0 0 28px oklch(0.62 0.18 276 / 0.26));
+  mix-blend-mode: plus-lighter;
+}
 
-    to {
-      background-position: 14rem 0;
-    }
+@media (prefers-reduced-motion: reduce) {
+  .agent-realtime-voice-glow {
+    transform: rotate(35deg);
   }
 }

package/dist/a2a/activity.d.ts

@@ -0,0 +1,50 @@
+import type { AgentChatEvent } from "../agent/types.js";
+import type { DataPart, Part } from "./types.js";
+export declare const A2A_AGENT_ACTIVITY_KIND = "agent-native/agent-activity";
+export declare const A2A_AGENT_ACTIVITY_VERSION = 1;
+export declare const MAX_A2A_ACTIVITY_REASONING_CHARS = 32768;
+export declare const MAX_A2A_ACTIVITY_RESPONSE_CHARS = 32768;
+export declare const MAX_A2A_ACTIVITY_TOTAL_CHARS = 98304;
+export declare const MAX_A2A_ACTIVITY_REASONING_SEGMENTS = 128;
+export declare const MAX_A2A_ACTIVITY_TOOL_CALLS = 64;
+export declare const MAX_A2A_ACTIVITY_TOOL_NAME_CHARS = 96;
+export declare 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 declare function createA2AAgentActivityState(startedAt?: number): A2AAgentActivityState;
+/**
+ * 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 declare function applyA2AAgentActivityEvent(state: A2AAgentActivityState, event: AgentChatEvent, updatedAt?: number): A2AAgentActivityState;
+export declare function buildA2AAgentActivitySnapshot(state: A2AAgentActivityState): A2AAgentActivitySnapshot;
+export declare function buildA2AAgentActivityPart(state: A2AAgentActivityState): DataPart;
+export declare function parseA2AAgentActivityPart(part: Part | unknown): A2AAgentActivitySnapshot | null;
+//# sourceMappingURL=activity.d.ts.map

package/dist/a2a/activity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity.d.ts","sourceRoot":"","sources":["../../src/a2a/activity.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAEjD,eAAO,MAAM,uBAAuB,gCAAgC,CAAC;AACrE,eAAO,MAAM,0BAA0B,IAAI,CAAC;AAC5C,eAAO,MAAM,gCAAgC,QAAS,CAAC;AACvD,eAAO,MAAM,+BAA+B,QAAS,CAAC;AACtD,eAAO,MAAM,4BAA4B,QAAS,CAAC;AACnD,eAAO,MAAM,mCAAmC,MAAM,CAAC;AACvD,eAAO,MAAM,2BAA2B,KAAK,CAAC;AAC9C,eAAO,MAAM,gCAAgC,KAAK,CAAC;AACnD,eAAO,MAAM,8BAA8B,MAAM,CAAC;AAElD,MAAM,MAAM,qBAAqB,GAC7B,WAAW,GACX,MAAM,GACN,YAAY,GACZ,UAAU,GACV,OAAO,CAAC;AAEZ,MAAM,MAAM,0BAA0B,GAAG,SAAS,GAAG,WAAW,GAAG,QAAQ,CAAC;AAE5E,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,0BAA0B,CAAC;CACpC;AAED,MAAM,WAAW,wBAAyB,SAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACvE,IAAI,EAAE,OAAO,uBAAuB,CAAC;IACrC,OAAO,EAAE,OAAO,0BAA0B,CAAC;IAC3C,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,qBAAqB,CAAC;IACnC,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,SAAS,EAAE,wBAAwB,EAAE,CAAC;IACtC,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,qBAAqB,CAAC;IACnC,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,SAAS,EAAE,wBAAwB,EAAE,CAAC;IACtC,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,wBAAgB,2BAA2B,CACzC,SAAS,SAAa,GACrB,qBAAqB,CAUvB;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,qBAAqB,EAC5B,KAAK,EAAE,cAAc,EACrB,SAAS,SAAa,GACrB,qBAAqB,CAkDvB;AAED,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,qBAAqB,GAC3B,wBAAwB,CAa1B;AAED,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,qBAAqB,GAC3B,QAAQ,CAEV;AAED,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,IAAI,GAAG,OAAO,GACnB,wBAAwB,GAAG,IAAI,CAyBjC"}

package/dist/a2a/activity.js

@@ -0,0 +1,236 @@
+import { sanitizeToolErrorText } from "../agent/tool-error-redaction.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 function createA2AAgentActivityState(startedAt = Date.now()) {
+    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, event, updatedAt = Date.now()) {
+    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) {
+    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) {
+    return { type: "data", data: buildA2AAgentActivitySnapshot(state) };
+}
+export function parseA2AAgentActivityPart(part) {
+    if (!part || typeof part !== "object")
+        return null;
+    const candidate = part;
+    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;
+}
+function toolFromEvent(event) {
+    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, addition, maxChars) {
+    return sanitizeText(`${current}${addition}`, maxChars);
+}
+function appendBoundedSegment(current, addition, maxChars, precedingToolCount) {
+    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, tool) {
+    return current.length < MAX_A2A_ACTIVITY_TOOL_CALLS
+        ? [...current, tool]
+        : current;
+}
+function settleToolCall(current, tool) {
+    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, maxChars) {
+    return sanitizeToolErrorText(value)
+        .replace(/\r\n?/g, "\n")
+        .replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, "")
+        .slice(0, maxChars);
+}
+function sanitizeToolName(value) {
+    return sanitizeText(value, MAX_A2A_ACTIVITY_TOOL_NAME_CHARS) || "tool";
+}
+function sanitizeToolId(value) {
+    const sanitized = value
+        ? sanitizeText(value, MAX_A2A_ACTIVITY_TOOL_ID_CHARS)
+        : "";
+    return sanitized || undefined;
+}
+function normalizeTimestamp(value) {
+    return isSafeInteger(value) ? value : Date.now();
+}
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isSafeInteger(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function isPhase(value) {
+    return ["reasoning", "tool", "responding", "complete", "error"].includes(value);
+}
+function isSafeReasoning(value) {
+    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) {
+    return (Array.isArray(value) &&
+        value.length <= MAX_A2A_ACTIVITY_TOOL_CALLS &&
+        value.every(isSafeToolCall));
+}
+function isSafeToolCall(value) {
+    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, maxChars) {
+    return (typeof value === "string" &&
+        value.length <= maxChars &&
+        value === sanitizeText(value, maxChars));
+}
+function isSafeToolName(value) {
+    return (typeof value === "string" &&
+        value.length <= MAX_A2A_ACTIVITY_TOOL_NAME_CHARS &&
+        value === sanitizeToolName(value));
+}
+function isSafeToolId(value) {
+    return (typeof value === "string" &&
+        value.length <= MAX_A2A_ACTIVITY_TOOL_ID_CHARS &&
+        value === sanitizeToolId(value));
+}
+function activityCharacterCount(data) {
+    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;
+}
+//# sourceMappingURL=activity.js.map