a2a-ui 0.8.3

package/lib/features/chats/taskIndex.ts

@@ -0,0 +1,113 @@
+import type { Part, TaskState } from "@a2a-js/sdk";
+import {
+  getTaskTimelineStages,
+  type TaskTimelineStage,
+} from "@/lib/a2a/execution-events";
+import type { Chat } from "./chatsSlice";
+
+export interface TaskSummary {
+  chatId: string;
+  chatTitle: string;
+  contextId: string;
+  taskId: string;
+  agentName: string;
+  agentUrl: string;
+  state: TaskState;
+  artifactCount: number;
+  artifactNames: string[];
+  validationWarningCount: number;
+  latestStatusText: string;
+  lastUpdated: number;
+  timelineStages: TaskTimelineStage[];
+}
+
+function textFromParts(parts: Part[]): string {
+  return parts
+    .filter((part): part is Extract<Part, { kind: "text" }> => part.kind === "text")
+    .map((part) => part.text)
+    .join(" ")
+    .trim();
+}
+
+function taskKey(chatId: string, taskId: string) {
+  return `${chatId}::${taskId}`;
+}
+
+export function buildTaskSummaries(chats: Chat[]): TaskSummary[] {
+  const tasks = new Map<string, TaskSummary>();
+
+  for (const chat of chats) {
+    for (const item of chat.items) {
+      if (item.kind === "task-status") {
+        const key = taskKey(chat.id, item.taskId);
+        const existing = tasks.get(key);
+        const latestStatusText = item.statusMessage
+          ? textFromParts(item.statusMessage.parts)
+          : "";
+
+        tasks.set(key, {
+          chatId: chat.id,
+          chatTitle: chat.title,
+          contextId: chat.id,
+          taskId: item.taskId,
+          agentName: chat.agentName,
+          agentUrl: chat.agentUrl,
+          state: item.state,
+          artifactCount: existing?.artifactCount ?? 0,
+          artifactNames: existing?.artifactNames ?? [],
+          validationWarningCount: existing?.validationWarningCount ?? 0,
+          latestStatusText,
+          lastUpdated: Math.max(existing?.lastUpdated ?? 0, item.timestamp),
+          timelineStages: getTaskTimelineStages(chat.executionEvents, item.taskId),
+        });
+        continue;
+      }
+
+      if (item.kind === "artifact") {
+        const key = taskKey(chat.id, item.taskId);
+        const existing = tasks.get(key);
+        tasks.set(key, {
+          chatId: chat.id,
+          chatTitle: chat.title,
+          contextId: chat.id,
+          taskId: item.taskId,
+          agentName: chat.agentName,
+          agentUrl: chat.agentUrl,
+          state: existing?.state ?? "unknown",
+          artifactCount: (existing?.artifactCount ?? 0) + 1,
+          artifactNames:
+            item.name && !(existing?.artifactNames ?? []).includes(item.name)
+              ? [...(existing?.artifactNames ?? []), item.name]
+              : (existing?.artifactNames ?? []),
+          validationWarningCount: existing?.validationWarningCount ?? 0,
+          latestStatusText: existing?.latestStatusText ?? "",
+          lastUpdated: Math.max(existing?.lastUpdated ?? 0, item.timestamp),
+          timelineStages: getTaskTimelineStages(chat.executionEvents, item.taskId),
+        });
+      }
+    }
+
+    for (const event of chat.executionEvents) {
+      if (event.kind !== "validation" || !event.taskId) continue;
+      const key = taskKey(chat.id, event.taskId);
+      const existing = tasks.get(key);
+      tasks.set(key, {
+        chatId: chat.id,
+        chatTitle: chat.title,
+        contextId: chat.id,
+        taskId: event.taskId,
+        agentName: chat.agentName,
+        agentUrl: chat.agentUrl,
+        state: existing?.state ?? "unknown",
+        artifactCount: existing?.artifactCount ?? 0,
+        artifactNames: existing?.artifactNames ?? [],
+        validationWarningCount: (existing?.validationWarningCount ?? 0) + 1,
+        latestStatusText: existing?.latestStatusText ?? "",
+        lastUpdated: Math.max(existing?.lastUpdated ?? 0, event.timestamp),
+        timelineStages: getTaskTimelineStages(chat.executionEvents, event.taskId),
+      });
+    }
+  }
+
+  return [...tasks.values()].sort((a, b) => b.lastUpdated - a.lastUpdated);
+}

package/lib/features/qa/assertions.ts

@@ -0,0 +1,165 @@
+import type { Part, TaskState } from "@a2a-js/sdk";
+import type {
+  QaAssertion,
+  QaAssertionResult,
+  QaOutputMode,
+} from "@/lib/features/qa/types";
+
+export interface QaCapturedOutput {
+  text: string;
+  jsonValues: unknown[];
+  artifactCount: number;
+  finalTaskState?: TaskState;
+}
+
+export function textFromParts(parts: Part[]): string {
+  return parts
+    .filter((part): part is Extract<Part, { kind: "text" }> => part.kind === "text")
+    .map((part) => part.text)
+    .join("\n")
+    .trim();
+}
+
+export function jsonValuesFromParts(parts: Part[]): unknown[] {
+  const values: unknown[] = [];
+  for (const part of parts) {
+    if (part.kind === "data") {
+      values.push(part.data);
+      continue;
+    }
+    if (part.kind !== "text") continue;
+    try {
+      values.push(JSON.parse(part.text));
+    } catch {
+      // Plain text is still valid output; it just cannot satisfy JSON assertions.
+    }
+  }
+  return values;
+}
+
+function readPath(value: unknown, path: string): unknown {
+  const segments = path
+    .replace(/^\$\./, "")
+    .replace(/^\$/, "")
+    .split(".")
+    .map((segment) => segment.trim())
+    .filter(Boolean);
+
+  let current = value;
+  for (const segment of segments) {
+    if (current == null) return undefined;
+    if (Array.isArray(current)) {
+      const index = Number(segment);
+      if (!Number.isInteger(index)) return undefined;
+      current = current[index];
+      continue;
+    }
+    if (typeof current !== "object") return undefined;
+    current = (current as Record<string, unknown>)[segment];
+  }
+  return current;
+}
+
+function stringifyComparable(value: unknown): string {
+  if (typeof value === "string") return value;
+  return JSON.stringify(value);
+}
+
+export function evaluateOutputMode(
+  expected: QaOutputMode,
+  output: QaCapturedOutput,
+): QaAssertionResult | null {
+  if (expected === "any") return null;
+
+  const passed =
+    expected === "text"
+      ? output.text.length > 0
+      : expected === "json"
+        ? output.jsonValues.length > 0
+        : output.artifactCount > 0;
+
+  return {
+    assertionId: "expected-output-mode",
+    label: `Expected ${expected} output`,
+    passed,
+    message: passed
+      ? `Observed ${expected} output.`
+      : `Did not observe ${expected} output.`,
+  };
+}
+
+export function evaluateExpectedTaskState(
+  expected: TaskState | undefined,
+  output: QaCapturedOutput,
+): QaAssertionResult | null {
+  if (!expected) return null;
+  const passed = output.finalTaskState === expected;
+  return {
+    assertionId: "expected-task-state",
+    label: `Expected task state ${expected}`,
+    passed,
+    message: passed
+      ? `Final task state was ${expected}.`
+      : `Final task state was ${output.finalTaskState ?? "unknown"}.`,
+  };
+}
+
+export function evaluateAssertion(
+  assertion: QaAssertion,
+  output: QaCapturedOutput,
+): QaAssertionResult {
+  if (assertion.kind === "content-regex") {
+    try {
+      const regex = new RegExp(assertion.pattern, assertion.flags);
+      const passed = regex.test(output.text);
+      return {
+        assertionId: assertion.id,
+        label: assertion.label,
+        passed,
+        message: passed
+          ? `Matched /${assertion.pattern}/${assertion.flags ?? ""}.`
+          : `No match for /${assertion.pattern}/${assertion.flags ?? ""}.`,
+      };
+    } catch (err) {
+      return {
+        assertionId: assertion.id,
+        label: assertion.label,
+        passed: false,
+        message: err instanceof Error ? err.message : String(err),
+      };
+    }
+  }
+
+  for (const value of output.jsonValues) {
+    const actual = readPath(value, assertion.path);
+    if (actual === undefined) continue;
+    if (assertion.equals == null || stringifyComparable(actual) === assertion.equals) {
+      return {
+        assertionId: assertion.id,
+        label: assertion.label,
+        passed: true,
+        message:
+          assertion.equals == null
+            ? `Found ${assertion.path}.`
+            : `${assertion.path} matched ${assertion.equals}.`,
+      };
+    }
+  }
+
+  return {
+    assertionId: assertion.id,
+    label: assertion.label,
+    passed: false,
+    message:
+      assertion.equals == null
+        ? `Could not find ${assertion.path}.`
+        : `Could not find ${assertion.path} equal to ${assertion.equals}.`,
+  };
+}
+
+export function evaluateQaAssertions(
+  assertions: QaAssertion[],
+  output: QaCapturedOutput,
+): QaAssertionResult[] {
+  return assertions.map((assertion) => evaluateAssertion(assertion, output));
+}

package/lib/features/qa/demoSuite.ts

@@ -0,0 +1,36 @@
+import type { Agent } from "@/lib/features/agents/agentsSlice";
+import type { QaSuite } from "@/lib/features/qa/types";
+
+export function createDemoSmokeSuite(agent: Agent): QaSuite {
+  const now = Date.now();
+  const agentName = agent.displayName ?? agent.card.name;
+  return {
+    id: crypto.randomUUID(),
+    agentUrl: agent.url,
+    agentName,
+    name: `${agentName} smoke suite`,
+    description: "Basic QA checks for the bundled demo agent flow.",
+    createdAt: now,
+    updatedAt: now,
+    cases: [
+      {
+        id: crypto.randomUUID(),
+        name: "Returns a helpful text response",
+        prompt: "Reply with one concise sentence confirming you are ready for A2A QA.",
+        attachments: [],
+        metadata: { source: "a2a-ui-qa-smoke" },
+        expectedTaskState: "completed",
+        expectedOutputMode: "text",
+        assertions: [
+          {
+            id: crypto.randomUUID(),
+            kind: "content-regex",
+            label: "Mentions QA or ready",
+            pattern: "qa|ready",
+            flags: "i",
+          },
+        ],
+      },
+    ],
+  };
+}

package/lib/features/qa/qaSlice.ts

@@ -0,0 +1,59 @@
+import { createSlice, PayloadAction } from "@reduxjs/toolkit";
+import type { QaState, QaSuite, QaSuiteRun } from "@/lib/features/qa/types";
+
+const MAX_RUN_HISTORY = 100;
+
+const initialState: QaState = {
+  suites: [],
+  runs: [],
+};
+
+export const qaSlice = createSlice({
+  name: "qa",
+  initialState,
+  reducers: {
+    hydrateQa: (_state, action: PayloadAction<QaState | undefined>) => ({
+      suites: action.payload?.suites ?? [],
+      runs: action.payload?.runs ?? [],
+    }),
+    saveQaSuite: (state, action: PayloadAction<QaSuite>) => {
+      const suite = {
+        ...action.payload,
+        updatedAt: Date.now(),
+      };
+      const existing = state.suites.findIndex((entry) => entry.id === suite.id);
+      if (existing >= 0) {
+        state.suites[existing] = suite;
+      } else {
+        state.suites.unshift(suite);
+      }
+    },
+    removeQaSuite: (state, action: PayloadAction<string>) => {
+      state.suites = state.suites.filter((suite) => suite.id !== action.payload);
+      state.runs = state.runs.filter((run) => run.suiteId !== action.payload);
+    },
+    recordQaRun: (state, action: PayloadAction<QaSuiteRun>) => {
+      state.runs.unshift(action.payload);
+      if (state.runs.length > MAX_RUN_HISTORY) {
+        state.runs = state.runs.slice(0, MAX_RUN_HISTORY);
+      }
+    },
+    clearQaRunHistory: (state, action: PayloadAction<string | undefined>) => {
+      if (!action.payload) {
+        state.runs = [];
+        return;
+      }
+      state.runs = state.runs.filter((run) => run.suiteId !== action.payload);
+    },
+  },
+});
+
+export const {
+  hydrateQa,
+  saveQaSuite,
+  removeQaSuite,
+  recordQaRun,
+  clearQaRunHistory,
+} = qaSlice.actions;
+
+export default qaSlice.reducer;

package/lib/features/qa/runner.ts

@@ -0,0 +1,153 @@
+import type {
+  Message,
+  Part,
+  TaskArtifactUpdateEvent,
+  TaskState,
+  TaskStatusUpdateEvent,
+} from "@a2a-js/sdk";
+import type { Client } from "@a2a-js/sdk/client";
+import type { Agent } from "@/lib/features/agents/agentsSlice";
+import { buildOutgoingMessage } from "@/lib/a2a/message-utils";
+import { createClientFactory } from "@/lib/utils/auth";
+import {
+  evaluateExpectedTaskState,
+  evaluateOutputMode,
+  evaluateQaAssertions,
+  jsonValuesFromParts,
+  textFromParts,
+  type QaCapturedOutput,
+} from "@/lib/features/qa/assertions";
+import type { QaCaseResult, QaSuite, QaSuiteRun } from "@/lib/features/qa/types";
+
+interface QaRunnerOptions {
+  suite: QaSuite;
+  agent: Agent;
+  client?: Client;
+}
+
+function outputModeFromCapture(output: QaCapturedOutput) {
+  if (output.artifactCount > 0) return "artifact";
+  if (output.jsonValues.length > 0) return "json";
+  if (output.text.length > 0) return "text";
+  return "any";
+}
+
+async function executeQaCase(input: {
+  suite: QaSuite;
+  agent: Agent;
+  client: Client;
+  testCase: QaSuite["cases"][number];
+}): Promise<QaCaseResult> {
+  const startedAt = Date.now();
+  const contextId = crypto.randomUUID();
+  const messageId = crypto.randomUUID();
+  const parts: Part[] = [
+    { kind: "text", text: input.testCase.prompt },
+    ...input.testCase.attachments,
+  ];
+  const outputParts: Part[] = [];
+  let artifactCount = 0;
+  let finalTaskState: TaskState | undefined;
+
+  try {
+    const message = await buildOutgoingMessage({
+      parts,
+      messageId,
+      contextId,
+      agentUrl: input.agent.url,
+      metadata: input.testCase.metadata,
+    });
+    const stream = input.client.sendMessageStream({ message });
+
+    for await (const event of stream) {
+      if (event.kind === "status-update") {
+        const statusEvent = event as TaskStatusUpdateEvent;
+        finalTaskState = statusEvent.status.state;
+        if (statusEvent.status.message) {
+          outputParts.push(...statusEvent.status.message.parts);
+        }
+        continue;
+      }
+
+      if (event.kind === "artifact-update") {
+        const artifactEvent = event as TaskArtifactUpdateEvent;
+        artifactCount += artifactEvent.lastChunk === false ? 0 : 1;
+        outputParts.push(...artifactEvent.artifact.parts);
+        continue;
+      }
+
+      if (event.kind === "message") {
+        const agentMessage = event as Message;
+        if (agentMessage.role === "agent") {
+          outputParts.push(...agentMessage.parts);
+        }
+      }
+    }
+
+    const output: QaCapturedOutput = {
+      text: textFromParts(outputParts),
+      jsonValues: jsonValuesFromParts(outputParts),
+      artifactCount,
+      finalTaskState,
+    };
+    const assertionResults = [
+      evaluateExpectedTaskState(input.testCase.expectedTaskState, output),
+      evaluateOutputMode(input.testCase.expectedOutputMode, output),
+      ...evaluateQaAssertions(input.testCase.assertions, output),
+    ].filter((result) => result != null);
+    const passed = assertionResults.every((result) => result.passed);
+
+    return {
+      caseId: input.testCase.id,
+      caseName: input.testCase.name,
+      passed,
+      durationMs: Date.now() - startedAt,
+      finalTaskState,
+      outputMode: outputModeFromCapture(output),
+      outputPreview: output.text.slice(0, 500),
+      assertionResults,
+    };
+  } catch (err) {
+    return {
+      caseId: input.testCase.id,
+      caseName: input.testCase.name,
+      passed: false,
+      durationMs: Date.now() - startedAt,
+      finalTaskState,
+      outputMode: "any",
+      outputPreview: "",
+      assertionResults: [],
+      error: err instanceof Error ? err.message : String(err),
+    };
+  }
+}
+
+export async function executeQaSuite({
+  suite,
+  agent,
+  client,
+}: QaRunnerOptions): Promise<QaSuiteRun> {
+  const startedAt = Date.now();
+  const runnerClient =
+    client ??
+    (await createClientFactory(agent.auth, agent.customHeaders, undefined, undefined, {
+      a2uiEnabled: agent.a2uiEnabled,
+    }).createFromUrl(agent.url));
+  const caseResults: QaCaseResult[] = [];
+
+  for (const testCase of suite.cases) {
+    caseResults.push(await executeQaCase({ suite, agent, client: runnerClient, testCase }));
+  }
+
+  return {
+    id: crypto.randomUUID(),
+    suiteId: suite.id,
+    suiteName: suite.name,
+    agentUrl: agent.url,
+    agentName: suite.agentName,
+    startedAt,
+    completedAt: Date.now(),
+    passed: caseResults.every((result) => result.passed),
+    caseResults,
+  };
+}

package/lib/features/qa/types.ts

@@ -0,0 +1,77 @@
+import type { Part, TaskState } from "@a2a-js/sdk";
+
+export type QaOutputMode = "any" | "text" | "json" | "artifact";
+
+export type QaAssertion =
+  | {
+      id: string;
+      kind: "content-regex";
+      label: string;
+      pattern: string;
+      flags?: string;
+    }
+  | {
+      id: string;
+      kind: "json-path";
+      label: string;
+      path: string;
+      equals?: string;
+    };
+
+export interface QaTestCase {
+  id: string;
+  name: string;
+  prompt: string;
+  attachments: Part[];
+  metadata: Record<string, string>;
+  expectedTaskState?: TaskState;
+  expectedOutputMode: QaOutputMode;
+  assertions: QaAssertion[];
+}
+
+export interface QaSuite {
+  id: string;
+  agentUrl: string;
+  agentName: string;
+  name: string;
+  description?: string;
+  cases: QaTestCase[];
+  createdAt: number;
+  updatedAt: number;
+}
+
+export interface QaAssertionResult {
+  assertionId: string;
+  label: string;
+  passed: boolean;
+  message: string;
+}
+
+export interface QaCaseResult {
+  caseId: string;
+  caseName: string;
+  passed: boolean;
+  durationMs: number;
+  finalTaskState?: TaskState;
+  outputMode: QaOutputMode;
+  outputPreview: string;
+  assertionResults: QaAssertionResult[];
+  error?: string;
+}
+
+export interface QaSuiteRun {
+  id: string;
+  suiteId: string;
+  suiteName: string;
+  agentUrl: string;
+  agentName: string;
+  startedAt: number;
+  completedAt: number;
+  passed: boolean;
+  caseResults: QaCaseResult[];
+}
+
+export interface QaState {
+  suites: QaSuite[];
+  runs: QaSuiteRun[];
+}