@copilotkit/vue 2.0.0-rc.7 → 2.0.0-rc.8

package/src/v2/components/chat/tool-call-layout.ts

@@ -1,304 +0,0 @@
-import type { Message, ToolCall, ToolMessage } from "@ag-ui/core";
-
-/**
- * How the chat shows tool calls.
- *
- * - `"grouped"` (default): calls made in a row share one card, collapsed to a
- *   summary ("Used 3 tools") that opens to a row per call.
- * - `"line"`: the same grouping as a quiet line of text, like the reasoning
- *   message's "Thought for 4 seconds".
- * - `"stacked"`: the latest call on top of a stack of the earlier ones; click
- *   to fan the stack out into its cards.
- * - `"turn"`: the agent works in the open (narration, then a row per call),
- *   and when the reply is done everything before it folds into "Worked for 9s".
- * - `"separate"`: every call gets its own card, as before grouping existed.
- *
- * Only calls drawn by a renderer that opts into grouping (`group: true`) are
- * grouped; CopilotKit's built-in card from `useDefaultRenderTool()` does. Any
- * other call always shows on its own and splits the group around it.
- */
-export type CopilotChatToolCallDisplay =
-  | "grouped"
-  | "line"
-  | "stacked"
-  | "turn"
-  | "separate";
-
-/** One tool call and, once it has finished, the message carrying its result. */
-export interface ToolCallEntry {
-  toolCall: ToolCall;
-  toolMessage?: ToolMessage;
-}
-
-export type ToolCallSegment =
-  /** Consecutive calls drawn by renderers that opted into grouping. */
-  | {
-      kind: "group";
-      id: string;
-      calls: ToolCallEntry[];
-      /** Nothing renders after this group yet, so a running agent may add to it. */
-      trailing: boolean;
-    }
-  /**
-   * A call drawn by a renderer that didn't opt into grouping, or with no
-   * renderer at all. The latter renders nothing (and warns in development)
-   * without breaking a group.
-   */
-  | { kind: "call"; id: string; call: ToolCallEntry; rendered: boolean };
-
-/** What one assistant message's tool-call area renders. */
-export interface ToolCallLayout {
-  segments: ToolCallSegment[];
-  /** Changes whenever anything this layout renders changes; for memoization. */
-  signature: string;
-}
-
-/** Which tool-call renderers are registered. */
-export interface ToolCallRendererNames {
-  /** Tool names with a renderer of their own. */
-  named: ReadonlySet<string>;
-  /** Of those, the ones whose renderer opted into grouping. */
-  groupedNames: ReadonlySet<string>;
-  /** A wildcard (`"*"`) renderer is registered. */
-  wildcard: boolean;
-  /** The wildcard renderer opted into grouping (the built-in card does). */
-  wildcardGroups: boolean;
-}
-
-function contentLength(content: ToolMessage["content"]): number {
-  return typeof content === "string"
-    ? content.length
-    : JSON.stringify(content ?? "").length;
-}
-
-const entrySignature = ({ toolCall, toolMessage }: ToolCallEntry) =>
-  [
-    toolCall.id,
-    toolCall.function.name,
-    toolCall.function.arguments.length,
-    toolMessage
-      ? `${contentLength(toolMessage.content)}${toolMessage.error ? "!" : ""}`
-      : "-",
-  ].join(":");
-
-function signatureOf(segments: ToolCallSegment[]): string {
-  return segments
-    .map((segment) =>
-      segment.kind === "call"
-        ? `c(${entrySignature(segment.call)})`
-        : `g${segment.trailing ? "*" : ""}(${segment.calls.map(entrySignature).join(",")})`,
-    )
-    .join("|");
-}
-
-/** Index of tool results by the call they answer. */
-export function getToolResults(messages: Message[]): Map<string, ToolMessage> {
-  const results = new Map<string, ToolMessage>();
-  for (const message of messages) {
-    if (message.role === "tool") results.set(message.toolCallId, message);
-  }
-  return results;
-}
-
-/**
- * Lays out the tool calls of every assistant message in `rendered`.
- *
- * Calls drawn by a renderer that opted into grouping join the group that's
- * open; anything else that shows between them closes it: assistant text, a
- * user, reasoning or activity message, or a call drawn by any other renderer. A group belongs to
- * the message where it starts, so later messages whose calls joined it render
- * no tool calls themselves.
- *
- * @param rendered - The messages as the chat renders them, in order.
- * @param all - Every message, for finding tool results (a transform may hide them).
- * @param renderers - The registered renderers.
- */
-export function getToolCallLayouts(
-  rendered: Message[],
-  all: Message[],
-  renderers: ToolCallRendererNames,
-): Map<string, ToolCallLayout> {
-  const results = getToolResults(all);
-  const layouts = new Map<string, ToolCallSegment[]>();
-  let open: Extract<ToolCallSegment, { kind: "group" }> | undefined;
-
-  for (const message of rendered) {
-    if (message.role === "tool") continue;
-    if (message.role !== "assistant") {
-      open = undefined;
-      continue;
-    }
-    if (typeof message.content === "string" && message.content.trim()) {
-      open = undefined;
-    }
-
-    const segments: ToolCallSegment[] = [];
-    layouts.set(message.id, segments);
-    // Streaming can repeat a call: keep its first position, last content.
-    const toolCalls = new Map<string, ToolCall>();
-    for (const toolCall of message.toolCalls ?? []) {
-      toolCalls.set(toolCall.id, toolCall);
-    }
-    for (const toolCall of toolCalls.values()) {
-      const entry = { toolCall, toolMessage: results.get(toolCall.id) };
-
-      const name = toolCall.function.name;
-      const named = renderers.named.has(name);
-      const rendered = named || renderers.wildcard;
-      const groups = named
-        ? renderers.groupedNames.has(name)
-        : renderers.wildcardGroups;
-
-      if (!rendered || !groups) {
-        if (rendered) open = undefined;
-        segments.push({ kind: "call", id: toolCall.id, call: entry, rendered });
-      } else if (open) {
-        open.calls.push(entry);
-      } else {
-        open = {
-          kind: "group",
-          id: toolCall.id,
-          calls: [entry],
-          trailing: false,
-        };
-        segments.push(open);
-      }
-    }
-  }
-  if (open) open.trailing = true;
-
-  const layout = new Map<string, ToolCallLayout>();
-  for (const [id, segments] of layouts) {
-    layout.set(id, { segments, signature: signatureOf(segments) });
-  }
-  return layout;
-}
-
-const TOOL_CALL_SLOT_PREFIX = "tool-call-";
-
-/**
- * Which renderers draw tool calls, from the registered renderers and the
- * view's tool-call slots. A slot wins over a registered renderer and never
- * groups, since the chat can't tell what it draws: `#tool-call-<name>` takes
- * that tool, and `#tool-call` takes every tool.
- *
- * @param renderers - The registered renderers (`copilotkit.renderToolCalls`).
- * @param slotNames - The names of the slots the view was given.
- */
-export function getToolCallRendererNames(
-  renderers: readonly { name: string; group?: boolean }[],
-  slotNames: readonly string[] = [],
-): ToolCallRendererNames {
-  const wildcardSlot = slotNames.includes("tool-call");
-  const slotTools = slotNames
-    .filter((name) => name.startsWith(TOOL_CALL_SLOT_PREFIX))
-    .map((name) => name.slice(TOOL_CALL_SLOT_PREFIX.length));
-  const named = renderers.filter((renderer) => renderer.name !== "*");
-  const wildcards = renderers.filter((renderer) => renderer.name === "*");
-  return {
-    named: new Set([...named.map((renderer) => renderer.name), ...slotTools]),
-    groupedNames: new Set(
-      wildcardSlot
-        ? []
-        : named
-            .filter(
-              (renderer) =>
-                renderer.group && !slotTools.includes(renderer.name),
-            )
-            .map((renderer) => renderer.name),
-    ),
-    wildcard: wildcards.length > 0 || wildcardSlot,
-    wildcardGroups:
-      !wildcardSlot && wildcards.some((renderer) => renderer.group),
-  };
-}
-
-/** A reply's working phase, for the `"turn"` display. */
-export interface TurnWork {
-  /** Stable across the turn's life: the id of the user message it answers. */
-  key: string;
-  /** The first assistant-side message, where the "Worked for" line goes. */
-  firstMessageId: string;
-  /** Everything up to and including the last message with a tool call. */
-  workMessageIds: ReadonlySet<string>;
-  /**
-   * The reply's last assistant message, when it has text and is part of the
-   * work (it also calls a tool). Its text is the answer, so it stays out.
-   */
-  replyTextMessageId?: string;
-  calls: ToolCallEntry[];
-  /** No user message follows, so the agent may still be working on it. */
-  isLatest: boolean;
-}
-
-/**
- * Finds the working phase of every reply in `rendered`: its messages up to the
- * last one that calls a tool. Text in there was narration; what follows is the
- * reply itself. Replies that called no tools are omitted, except the latest,
- * which may be about to.
- */
-export function getTurnWork(
-  rendered: Message[],
-  layouts: ReadonlyMap<string, ToolCallLayout>,
-): Map<string, TurnWork> {
-  const turns = new Map<string, TurnWork>();
-  let start = 0;
-  while (start < rendered.length) {
-    let end = start;
-    while (end < rendered.length && rendered[end]!.role !== "user") end++;
-    const key = start > 0 ? rendered[start - 1]!.id : "start";
-    const visible = rendered
-      .slice(start, end)
-      .filter((message) => message.role !== "tool");
-    const isLatest = end === rendered.length;
-
-    // A message's calls may sit in a group an earlier message owns, so
-    // collect every shown call first, then find the last message making one.
-    const calls: ToolCallEntry[] = [];
-    for (const message of visible) {
-      for (const segment of layouts.get(message.id)?.segments ?? []) {
-        if (segment.kind === "group") calls.push(...segment.calls);
-        else if (segment.rendered) calls.push(segment.call);
-      }
-    }
-    const shown = new Set(calls.map((entry) => entry.toolCall.id));
-    let lastWork = -1;
-    visible.forEach((message, index) => {
-      if (
-        message.role === "assistant" &&
-        message.toolCalls?.some((call) => shown.has(call.id))
-      ) {
-        lastWork = index;
-      }
-    });
-
-    const first = visible[0];
-    if (first && (calls.length > 0 || isLatest)) {
-      let lastAssistant = -1;
-      visible.forEach((message, index) => {
-        if (message.role === "assistant") lastAssistant = index;
-      });
-      const replyText = visible[lastAssistant]?.content;
-      const endsWithWork =
-        lastAssistant >= 0 &&
-        lastAssistant <= lastWork &&
-        typeof replyText === "string" &&
-        replyText.trim().length > 0;
-
-      turns.set(key, {
-        key,
-        firstMessageId: first.id,
-        workMessageIds: new Set(
-          visible.slice(0, lastWork + 1).map((message) => message.id),
-        ),
-        replyTextMessageId: endsWithWork
-          ? visible[lastAssistant]!.id
-          : undefined,
-        calls,
-        isLatest,
-      });
-    }
-    start = end + 1;
-  }
-  return turns;
-}

package/src/v2/lib/__tests__/transcription-client.test.ts

@@ -1,67 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { TranscriptionErrorCode } from "@copilotkit/shared";
-import type { TranscriptionError } from "../transcription-client";
-import { transcribeAudio } from "../transcription-client";
-import type { CopilotKitCoreVue } from "../vue-core";
-
-describe("transcription-client", () => {
-  const originalFetch = globalThis.fetch;
-
-  afterEach(() => {
-    globalThis.fetch = originalFetch;
-  });
-
-  it("transcribes audio in REST mode", async () => {
-    globalThis.fetch = vi.fn().mockResolvedValue({
-      ok: true,
-      json: async () => ({
-        text: "Transcribed text",
-        size: 12,
-        type: "audio/webm",
-      }),
-    } satisfies Partial<Response>) as typeof fetch;
-
-    const result = await transcribeAudio(
-      {
-        runtimeUrl: "/api/copilotkit",
-        runtimeTransport: "rest",
-        headers: {},
-        resolveHeaders: async () => ({}),
-      } as CopilotKitCoreVue,
-      new Blob(["audio"], { type: "audio/webm" }),
-    );
-
-    expect(globalThis.fetch).toHaveBeenCalledTimes(1);
-    expect(result.text).toBe("Transcribed text");
-  });
-
-  it("maps structured error responses to TranscriptionError", async () => {
-    globalThis.fetch = vi.fn().mockResolvedValue({
-      ok: false,
-      status: 429,
-      statusText: "Too Many Requests",
-      json: async () => ({
-        error: TranscriptionErrorCode.RATE_LIMITED,
-        message: "Rate limited",
-        retryable: true,
-      }),
-    } satisfies Partial<Response>) as typeof fetch;
-
-    await expect(
-      transcribeAudio(
-        {
-          runtimeUrl: "/api/copilotkit",
-          runtimeTransport: "rest",
-          headers: {},
-          resolveHeaders: async () => ({}),
-        } as CopilotKitCoreVue,
-        new Blob(["audio"], { type: "audio/webm" }),
-      ),
-    ).rejects.toMatchObject({
-      info: {
-        code: TranscriptionErrorCode.RATE_LIMITED,
-        retryable: true,
-      },
-    } satisfies Partial<TranscriptionError>);
-  });
-});

package/src/v2/lib/transcription-client.ts

@@ -1,151 +0,0 @@
-import type { CopilotKitCoreVue } from "./vue-core";
-import { TranscriptionErrorCode } from "@copilotkit/shared";
-import type { TranscriptionErrorResponse } from "@copilotkit/shared";
-
-export interface TranscriptionResult {
-  text: string;
-  size: number;
-  type: string;
-}
-
-export interface TranscriptionErrorInfo {
-  code: TranscriptionErrorCode;
-  message: string;
-  retryable: boolean;
-}
-
-export { TranscriptionErrorCode };
-
-async function blobToBase64(blob: Blob): Promise<string> {
-  return await new Promise((resolve, reject) => {
-    const reader = new FileReader();
-    reader.onloadend = () => {
-      const result = reader.result as string;
-      resolve(result.split(",")[1] ?? "");
-    };
-    reader.addEventListener("error", () =>
-      reject(new Error("Failed to read audio data")),
-    );
-    reader.readAsDataURL(blob);
-  });
-}
-
-function isTranscriptionErrorResponse(
-  data: unknown,
-): data is TranscriptionErrorResponse {
-  return (
-    typeof data === "object" &&
-    data !== null &&
-    "error" in data &&
-    "message" in data &&
-    typeof (data as TranscriptionErrorResponse).error === "string" &&
-    typeof (data as TranscriptionErrorResponse).message === "string"
-  );
-}
-
-function parseTranscriptionError(
-  response: TranscriptionErrorResponse,
-): TranscriptionErrorInfo {
-  return {
-    code: response.error,
-    message: response.message,
-    retryable: response.retryable ?? false,
-  };
-}
-
-export class TranscriptionError extends Error {
-  public readonly info: TranscriptionErrorInfo;
-
-  constructor(info: TranscriptionErrorInfo) {
-    super(info.message);
-    this.name = "TranscriptionError";
-    this.info = info;
-  }
-}
-
-export async function transcribeAudio(
-  core: CopilotKitCoreVue,
-  audioBlob: Blob,
-  filename: string = "recording.webm",
-): Promise<TranscriptionResult> {
-  const runtimeUrl = core.runtimeUrl;
-  if (!runtimeUrl) {
-    throw new TranscriptionError({
-      code: TranscriptionErrorCode.INVALID_REQUEST,
-      message: "Runtime URL is not configured",
-      retryable: false,
-    });
-  }
-
-  const headers: Record<string, string> = { ...(await core.resolveHeaders()) };
-  let response: Response;
-
-  try {
-    if (core.runtimeTransport === "single") {
-      const base64Audio = await blobToBase64(audioBlob);
-
-      headers["Content-Type"] = "application/json";
-
-      response = await fetch(runtimeUrl, {
-        method: "POST",
-        headers,
-        body: JSON.stringify({
-          method: "transcribe",
-          body: {
-            audio: base64Audio,
-            mimeType: audioBlob.type || "audio/webm",
-            filename,
-          },
-        }),
-      });
-    } else {
-      delete headers["Content-Type"];
-
-      const formData = new FormData();
-      formData.append("audio", audioBlob, filename);
-
-      response = await fetch(`${runtimeUrl}/transcribe`, {
-        method: "POST",
-        headers,
-        body: formData,
-      });
-    }
-  } catch (error) {
-    throw new TranscriptionError({
-      code: TranscriptionErrorCode.NETWORK_ERROR,
-      message:
-        error instanceof Error ? error.message : "Network request failed",
-      retryable: true,
-    });
-  }
-
-  if (!response.ok) {
-    let errorData: unknown;
-    try {
-      errorData = await response.json();
-    } catch {
-      throw new TranscriptionError({
-        code: TranscriptionErrorCode.PROVIDER_ERROR,
-        message: `HTTP ${response.status}: ${response.statusText}`,
-        retryable: response.status >= 500,
-      });
-    }
-
-    if (isTranscriptionErrorResponse(errorData)) {
-      throw new TranscriptionError(parseTranscriptionError(errorData));
-    }
-
-    throw new TranscriptionError({
-      code: TranscriptionErrorCode.PROVIDER_ERROR,
-      message:
-        typeof errorData === "object" &&
-        errorData !== null &&
-        "message" in errorData
-          ? String((errorData as { message: unknown }).message)
-          : "Transcription failed",
-      retryable: response.status >= 500,
-    });
-  }
-
-  return (await response.json()) as TranscriptionResult;
-}