@assistant-ui/react-a2a 0.2.4 → 0.2.7

package/src/convertA2AMessages.ts

@@ -1,108 +0,0 @@
-"use client";
-
-import { useExternalMessageConverter } from "@assistant-ui/react";
-import { A2AMessage } from "./types";
-import { ToolCallMessagePart } from "@assistant-ui/react";
-import { ThreadUserMessage } from "@assistant-ui/react";
-
-const contentToParts = (content: A2AMessage["content"]) => {
-  if (typeof content === "string")
-    return [{ type: "text" as const, text: content }];
-  return content
-    .map((part): ThreadUserMessage["content"][number] | null => {
-      const type = part.type;
-      switch (type) {
-        case "text":
-          return { type: "text", text: part.text };
-        case "image_url":
-          if (typeof part.image_url === "string") {
-            return { type: "image", image: part.image_url };
-          } else {
-            return {
-              type: "image",
-              image: part.image_url.url,
-            };
-          }
-        case "data":
-          // Convert data parts to text representation for display
-          return {
-            type: "text",
-            text: `[Data: ${JSON.stringify(part.data)}]`,
-          };
-        default:
-          return null;
-      }
-    })
-    .filter((part): part is NonNullable<typeof part> => part !== null);
-};
-
-export const convertA2AMessage = (message: A2AMessage) => {
-  const role = message.role;
-  switch (role) {
-    case "system":
-      return {
-        id: message.id,
-        role: "system" as const,
-        content: [{ type: "text" as const, text: message.content as string }],
-      };
-
-    case "user":
-      return {
-        id: message.id,
-        role: "user" as const,
-        content: contentToParts(message.content),
-      };
-
-    case "assistant": {
-      const toolCallParts: ToolCallMessagePart[] =
-        message.tool_calls?.map((toolCall) => ({
-          type: "tool-call",
-          toolCallId: toolCall.id,
-          toolName: toolCall.name,
-          args: toolCall.args,
-          argsText: toolCall.argsText ?? JSON.stringify(toolCall.args),
-        })) ?? [];
-
-      return {
-        id: message.id,
-        role: "assistant" as const,
-        content: [...contentToParts(message.content), ...toolCallParts],
-        status: message.status,
-      };
-    }
-
-    case "tool":
-      return {
-        id: message.id,
-        role: "user" as const,
-        content: [
-          {
-            type: "tool-call" as const,
-            toolCallId: message.tool_call_id!,
-            toolName: "", // A2A doesn't store tool name in tool messages
-            result: JSON.parse(message.content as string),
-            isError:
-              message.status?.type === "incomplete" &&
-              message.status?.reason === "error",
-          },
-        ],
-      };
-
-    default:
-      const _exhaustiveCheck: never = role;
-      throw new Error(`Unknown message role: ${_exhaustiveCheck}`);
-  }
-};
-
-export const convertA2AMessages = (messages: A2AMessage[]) =>
-  messages.map(convertA2AMessage);
-
-export const useA2AMessageConverter = (
-  messages: A2AMessage[],
-  isRunning: boolean,
-) =>
-  useExternalMessageConverter({
-    callback: convertA2AMessage,
-    messages,
-    isRunning,
-  });

package/src/testUtils.ts

@@ -1,11 +0,0 @@
-import { A2AMessage } from "./types";
-import { A2AMessagesEvent } from "./useA2AMessages";
-
-export const mockStreamCallbackFactory = (
-  events: Array<A2AMessagesEvent<A2AMessage>>,
-) =>
-  async function* () {
-    for (const event of events) {
-      yield event;
-    }
-  };

package/src/useA2AMessages.ts

@@ -1,180 +0,0 @@
-import { useState, useCallback, useRef, useMemo } from "react";
-import { v4 as uuidv4 } from "uuid";
-import { A2AMessageAccumulator } from "./A2AMessageAccumulator";
-import {
-  A2AEvent,
-  A2AKnownEventTypes,
-  A2ATaskState,
-  A2AArtifact,
-  A2ASendMessageConfig,
-  A2AStreamCallback,
-  OnTaskUpdateEventCallback,
-  OnArtifactsEventCallback,
-  OnErrorEventCallback,
-  OnStateUpdateEventCallback,
-  OnCustomEventCallback,
-} from "./types";
-
-export type A2AMessagesEvent<_TMessage> = A2AEvent;
-
-const DEFAULT_APPEND_MESSAGE = <TMessage>(
-  _: TMessage | undefined,
-  curr: TMessage,
-) => curr;
-
-export const useA2AMessages = <TMessage extends { id?: string }>({
-  stream,
-  appendMessage = DEFAULT_APPEND_MESSAGE,
-  eventHandlers,
-}: {
-  stream: A2AStreamCallback<TMessage>;
-  appendMessage?: (prev: TMessage | undefined, curr: TMessage) => TMessage;
-  eventHandlers?: {
-    onTaskUpdate?: OnTaskUpdateEventCallback;
-    onArtifacts?: OnArtifactsEventCallback;
-    onError?: OnErrorEventCallback;
-    onStateUpdate?: OnStateUpdateEventCallback;
-    onCustomEvent?: OnCustomEventCallback;
-  };
-}) => {
-  const [messages, setMessages] = useState<TMessage[]>([]);
-  const [taskState, setTaskState] = useState<A2ATaskState | undefined>();
-  const [artifacts, setArtifacts] = useState<A2AArtifact[]>([]);
-  const abortControllerRef = useRef<AbortController | null>(null);
-
-  const { onTaskUpdate, onArtifacts, onError, onStateUpdate, onCustomEvent } =
-    useMemo(() => eventHandlers ?? {}, [eventHandlers]);
-
-  const sendMessage = useCallback(
-    async (newMessages: TMessage[], config: A2ASendMessageConfig) => {
-      // ensure all messages have an ID
-      const newMessagesWithId = newMessages.map((m) =>
-        m.id ? m : { ...m, id: uuidv4() },
-      );
-
-      const accumulator = new A2AMessageAccumulator({
-        initialMessages: messages,
-        appendMessage,
-      });
-      setMessages(accumulator.addMessages(newMessagesWithId));
-
-      const abortController = new AbortController();
-      abortControllerRef.current = abortController;
-      const response = await stream(newMessagesWithId, {
-        ...config,
-        abortSignal: abortController.signal,
-      });
-
-      for await (const event of response) {
-        switch (event.event) {
-          case A2AKnownEventTypes.TaskUpdate:
-            const taskData = event.data as A2ATaskState;
-            setTaskState(taskData);
-            onTaskUpdate?.(taskData);
-            break;
-
-          case A2AKnownEventTypes.TaskComplete:
-            // Extract messages and artifacts from completed task
-            const { messages: taskMessages, artifacts: taskArtifacts } =
-              event.data;
-            if (taskMessages) {
-              setMessages(accumulator.addMessages(taskMessages));
-            }
-            if (taskArtifacts) {
-              setArtifacts(taskArtifacts);
-              onArtifacts?.(taskArtifacts);
-            }
-            // Clear task state on completion
-            setTaskState(undefined);
-            break;
-
-          case A2AKnownEventTypes.TaskFailed:
-            onError?.(event.data);
-            // Update task state to failed
-            if (taskState) {
-              setTaskState({
-                ...taskState,
-                state: "failed",
-                message: event.data?.message,
-              });
-            }
-            break;
-
-          case A2AKnownEventTypes.Artifacts:
-            const artifactData = event.data as A2AArtifact[];
-            setArtifacts(artifactData);
-            onArtifacts?.(artifactData);
-            break;
-
-          case A2AKnownEventTypes.StateUpdate:
-            onStateUpdate?.(event.data);
-            break;
-
-          case A2AKnownEventTypes.Error:
-            onError?.(event.data);
-            // Update the last assistant message with error status if available
-            const messages = accumulator.getMessages();
-            const lastAssistantMessage = messages.findLast(
-              (m): m is TMessage & { role: string; id: string } =>
-                m != null &&
-                "role" in m &&
-                m.role === "assistant" &&
-                m.id != null,
-            );
-            if (lastAssistantMessage) {
-              const errorMessage = {
-                ...lastAssistantMessage,
-                status: {
-                  type: "incomplete" as const,
-                  reason: "error" as const,
-                  error: event.data,
-                },
-              };
-              setMessages(accumulator.addMessages([errorMessage]));
-            }
-            break;
-
-          default:
-            if (onCustomEvent) {
-              onCustomEvent(event.event, event.data);
-            } else {
-              console.warn(
-                "Unhandled A2A event received:",
-                event.event,
-                event.data,
-              );
-            }
-            break;
-        }
-      }
-    },
-    [
-      messages,
-      appendMessage,
-      stream,
-      onTaskUpdate,
-      onArtifacts,
-      onError,
-      onStateUpdate,
-      onCustomEvent,
-      taskState,
-    ],
-  );
-
-  const cancel = useCallback(() => {
-    if (abortControllerRef.current) {
-      abortControllerRef.current.abort();
-    }
-  }, []);
-
-  return {
-    messages,
-    artifacts,
-    taskState,
-    sendMessage,
-    cancel,
-    setMessages,
-    setArtifacts,
-    setTaskState,
-  };
-};