@assistant-ui/react 0.8.6 → 0.8.8

package/src/runtimes/edge/streams/assistantEncoderStream.ts

@@ -1,126 +0,0 @@
-import {
-  AssistantStreamChunk,
-  AssistantStreamChunkType,
-} from "./AssistantStreamChunkType";
-import { StreamPart } from "./utils/StreamPart";
-import { ToolResultStreamPart } from "./toolResultStream";
-
-export function assistantEncoderStream() {
-  const toolCalls = new Set<string>();
-  return new TransformStream<
-    ToolResultStreamPart,
-    StreamPart<AssistantStreamChunk>
-  >({
-    transform(chunk, controller) {
-      const chunkType = chunk.type;
-      switch (chunkType) {
-        case "reasoning": {
-          controller.enqueue({
-            type: AssistantStreamChunkType.ReasoningDelta,
-            value: chunk.textDelta,
-          });
-          break;
-        }
-
-        case "source":
-          controller.enqueue({
-            type: AssistantStreamChunkType.Source,
-            value: chunk.source,
-          });
-          break;
-
-        case "text-delta": {
-          if (!chunk.textDelta) break; // ignore empty text deltas
-          controller.enqueue({
-            type: AssistantStreamChunkType.TextDelta,
-            value: chunk.textDelta,
-          });
-          break;
-        }
-        case "tool-call-delta": {
-          if (!toolCalls.has(chunk.toolCallId)) {
-            toolCalls.add(chunk.toolCallId);
-            controller.enqueue({
-              type: AssistantStreamChunkType.ToolCallBegin,
-              value: {
-                toolCallId: chunk.toolCallId,
-                toolName: chunk.toolName,
-              },
-            });
-          }
-
-          controller.enqueue({
-            type: AssistantStreamChunkType.ToolCallDelta,
-            value: {
-              toolCallId: chunk.toolCallId,
-              argsTextDelta: chunk.argsTextDelta,
-            },
-          });
-          break;
-        }
-
-        case "annotations": {
-          controller.enqueue({
-            type: AssistantStreamChunkType.Annotation,
-            value: chunk.annotations,
-          });
-          break;
-        }
-
-        case "data": {
-          controller.enqueue({
-            type: AssistantStreamChunkType.Data,
-            value: chunk.data,
-          });
-          break;
-        }
-
-        // ignore
-        case "tool-call":
-        case "response-metadata":
-          break;
-
-        case "tool-result": {
-          controller.enqueue({
-            type: AssistantStreamChunkType.ToolCallResult,
-            value: {
-              toolCallId: chunk.toolCallId,
-              result: chunk.result,
-            },
-          });
-          break;
-        }
-
-        case "step-finish": {
-          const { type, ...rest } = chunk;
-          controller.enqueue({
-            type: AssistantStreamChunkType.FinishStep,
-            value: rest,
-          });
-          break;
-        }
-
-        case "finish": {
-          const { type, ...rest } = chunk;
-          controller.enqueue({
-            type: AssistantStreamChunkType.FinishMessage,
-            value: rest,
-          });
-          break;
-        }
-
-        case "error": {
-          controller.enqueue({
-            type: AssistantStreamChunkType.Error,
-            value: chunk.error,
-          });
-          break;
-        }
-        default: {
-          const unhandledType: never = chunkType;
-          throw new Error(`Unhandled chunk type: ${unhandledType}`);
-        }
-      }
-    },
-  });
-}

package/src/runtimes/edge/streams/runResultStream.ts

@@ -1,360 +0,0 @@
-import { CoreChatModelRunResult } from "../../local/ChatModelAdapter";
-import { parsePartialJson } from "../../../utils/json/parse-partial-json";
-import { LanguageModelV1StreamPart } from "@ai-sdk/provider";
-import { ToolResultStreamPart } from "./toolResultStream";
-import { MessageStatus, ToolCallContentPart } from "../../../types";
-
-export function runResultStream() {
-  let message: CoreChatModelRunResult = {
-    content: [],
-    status: { type: "running" },
-  };
-
-  return new TransformStream<ToolResultStreamPart, CoreChatModelRunResult>({
-    transform(chunk, controller) {
-      const chunkType = chunk.type;
-      switch (chunkType) {
-        case "reasoning": {
-          message = appendOrUpdateReasoning(message, chunk.textDelta);
-          controller.enqueue(message);
-          break;
-        }
-
-        case "text-delta": {
-          message = appendOrUpdateText(message, chunk.textDelta);
-          controller.enqueue(message);
-          break;
-        }
-
-        case "tool-call-delta": {
-          const { toolCallId, toolName, argsTextDelta } = chunk;
-
-          message = appendOrUpdateToolCall(
-            message,
-            toolCallId,
-            toolName,
-            argsTextDelta,
-          );
-          controller.enqueue(message);
-          break;
-        }
-
-        case "tool-call":
-        // ignoring tool call events because they are converted to tool-call-delta as well
-        case "response-metadata":
-          break;
-
-        case "annotations": {
-          message = appendAnnotations(message, chunk);
-          controller.enqueue(message);
-          break;
-        }
-
-        case "data": {
-          message = appendData(message, chunk);
-          controller.enqueue(message);
-          break;
-        }
-
-        case "source": {
-          message = appendSource(message, chunk);
-          controller.enqueue(message);
-          break;
-        }
-
-        case "tool-result": {
-          message = appendOrUpdateToolResult(
-            message,
-            chunk.toolCallId,
-            chunk.toolName,
-            chunk.result,
-          );
-          controller.enqueue(message);
-          break;
-        }
-        case "step-finish": {
-          message = appendStepFinish(message, chunk);
-          controller.enqueue(message);
-          break;
-        }
-        case "finish": {
-          message = appendOrUpdateFinish(message, chunk);
-          controller.enqueue(message);
-          break;
-        }
-        case "error": {
-          if (
-            chunk.error instanceof Error &&
-            chunk.error.name === "AbortError"
-          ) {
-            message = appendOrUpdateCancel(message);
-            controller.enqueue(message);
-            break;
-          } else {
-            throw chunk.error;
-          }
-        }
-        default: {
-          const unhandledType: never = chunkType;
-          throw new Error(`Unhandled chunk type: ${unhandledType}`);
-        }
-      }
-    },
-    flush(controller) {
-      if (message.status?.type === "running") {
-        const requiresAction = message.content?.at(-1)?.type === "tool-call";
-        message = appendOrUpdateFinish(message, {
-          type: "finish",
-          finishReason: requiresAction ? "tool-calls" : "unknown",
-          usage: {
-            promptTokens: 0,
-            completionTokens: 0,
-          },
-        });
-        controller.enqueue(message);
-      }
-    },
-  });
-}
-
-const appendOrUpdateReasoning = (
-  message: CoreChatModelRunResult,
-  textDelta: string,
-) => {
-  let contentParts = message.content ?? [];
-  let contentPart = message.content?.at(-1);
-  if (contentPart?.type !== "reasoning") {
-    contentPart = { type: "reasoning", text: textDelta };
-  } else {
-    contentParts = contentParts.slice(0, -1);
-    contentPart = { type: "reasoning", text: contentPart.text + textDelta };
-  }
-  return {
-    ...message,
-    content: contentParts.concat([contentPart]),
-  };
-};
-
-const appendOrUpdateText = (
-  message: CoreChatModelRunResult,
-  textDelta: string,
-) => {
-  let contentParts = message.content ?? [];
-  let contentPart = message.content?.at(-1);
-  if (contentPart?.type !== "text") {
-    contentPart = { type: "text", text: textDelta };
-  } else {
-    contentParts = contentParts.slice(0, -1);
-    contentPart = { type: "text", text: contentPart.text + textDelta };
-  }
-  return {
-    ...message,
-    content: contentParts.concat([contentPart]),
-  };
-};
-
-const appendOrUpdateToolCall = (
-  message: CoreChatModelRunResult,
-  toolCallId: string,
-  toolName: string,
-  argsTextDelta: string,
-): CoreChatModelRunResult => {
-  let contentParts = message.content ?? [];
-  const contentPartIdx = contentParts.findIndex(
-    (c) => c.type === "tool-call" && c.toolCallId === toolCallId,
-  );
-  let contentPart =
-    contentPartIdx === -1
-      ? null
-      : (contentParts[contentPartIdx] as ToolCallContentPart);
-
-  if (contentPart == null) {
-    contentPart = {
-      type: "tool-call",
-      toolCallId,
-      toolName,
-      argsText: argsTextDelta,
-      args: argsTextDelta ? parsePartialJson(argsTextDelta) : {},
-    };
-    contentParts = [...contentParts, contentPart];
-  } else {
-    const argsText = contentPart.argsText + argsTextDelta;
-    contentPart = {
-      ...contentPart,
-      argsText,
-      args: argsTextDelta ? parsePartialJson(argsText) : {},
-    };
-    contentParts = [
-      ...contentParts.slice(0, contentPartIdx),
-      contentPart,
-      ...contentParts.slice(contentPartIdx + 1),
-    ];
-  }
-
-  return {
-    ...message,
-    content: contentParts,
-  };
-};
-
-const appendOrUpdateToolResult = (
-  message: CoreChatModelRunResult,
-  toolCallId: string,
-  toolName: string,
-  result: any,
-) => {
-  let found = false;
-  const newContentParts = message.content?.map((part) => {
-    if (part.type !== "tool-call" || part.toolCallId !== toolCallId)
-      return part;
-    found = true;
-
-    if (part.toolName !== toolName)
-      throw new Error(
-        `Tool call ${toolCallId} found with tool name ${part.toolName}, but expected ${toolName}`,
-      );
-
-    return {
-      ...part,
-      result,
-    };
-  });
-  if (!found)
-    throw new Error(
-      `Received tool result for unknown tool call "${toolName}" / "${toolCallId}". This is likely an internal bug in assistant-ui.`,
-    );
-
-  return {
-    ...message,
-    content: newContentParts!,
-  };
-};
-
-const appendAnnotations = (
-  message: CoreChatModelRunResult,
-  chunk: ToolResultStreamPart & { type: "annotations" },
-): CoreChatModelRunResult => {
-  return {
-    ...message,
-    metadata: {
-      ...message.metadata,
-      unstable_annotations: [
-        ...(message.metadata?.unstable_annotations ?? []),
-        ...chunk.annotations,
-      ],
-    },
-  };
-};
-
-const appendData = (
-  message: CoreChatModelRunResult,
-  chunk: ToolResultStreamPart & { type: "data" },
-): CoreChatModelRunResult => {
-  return {
-    ...message,
-    metadata: {
-      ...message.metadata,
-      unstable_data: [
-        ...(message.metadata?.unstable_data ?? []),
-        ...chunk.data,
-      ],
-    },
-  };
-};
-
-const appendStepFinish = (
-  message: CoreChatModelRunResult,
-  chunk: ToolResultStreamPart & { type: "step-finish" },
-): CoreChatModelRunResult => {
-  const { type, ...rest } = chunk;
-  const steps = [
-    ...(message.metadata?.steps ?? []),
-    {
-      usage: rest.usage,
-    },
-  ];
-  return {
-    ...message,
-    metadata: {
-      ...message.metadata,
-      steps,
-    },
-  };
-};
-
-const appendOrUpdateFinish = (
-  message: CoreChatModelRunResult,
-  chunk: LanguageModelV1StreamPart & { type: "finish" },
-): CoreChatModelRunResult => {
-  const { type, ...rest } = chunk;
-
-  const steps = [
-    ...(message.metadata?.steps ?? []),
-    {
-      logprobs: rest.logprobs,
-      usage: rest.usage,
-    },
-  ];
-  return {
-    ...message,
-    status: getStatus(chunk),
-    metadata: {
-      ...message.metadata,
-      steps,
-    },
-  };
-};
-
-const appendSource = (
-  message: CoreChatModelRunResult,
-  chunk: ToolResultStreamPart & { type: "source" },
-): CoreChatModelRunResult => {
-  return {
-    ...message,
-    content: [
-      ...message.content,
-      {
-        type: "source",
-        ...chunk.source,
-      },
-    ],
-  };
-};
-
-const getStatus = (
-  chunk:
-    | (LanguageModelV1StreamPart & { type: "finish" })
-    | (ToolResultStreamPart & { type: "step-finish" }),
-): MessageStatus => {
-  if (chunk.finishReason === "tool-calls") {
-    return {
-      type: "requires-action",
-      reason: "tool-calls",
-    };
-  } else if (
-    chunk.finishReason === "stop" ||
-    chunk.finishReason === "unknown"
-  ) {
-    return {
-      type: "complete",
-      reason: chunk.finishReason,
-    };
-  } else {
-    return {
-      type: "incomplete",
-      reason: chunk.finishReason,
-    };
-  }
-};
-
-const appendOrUpdateCancel = (
-  message: CoreChatModelRunResult,
-): CoreChatModelRunResult => {
-  return {
-    ...message,
-    status: {
-      type: "incomplete",
-      reason: "cancelled",
-    },
-  };
-};

package/src/runtimes/edge/streams/utils/PipeableTransformStream.ts

@@ -1,10 +0,0 @@
-export class PipeableTransformStream<I, O> extends TransformStream<I, O> {
-  constructor(transform: (readable: ReadableStream<I>) => ReadableStream<O>) {
-    super();
-    const readable = transform(super.readable as any);
-    Object.defineProperty(this, "readable", {
-      value: readable,
-      writable: false,
-    });
-  }
-}

package/src/runtimes/edge/streams/utils/StreamPart.ts

@@ -1,3 +0,0 @@
-export type StreamPart<T extends Record<string, unknown>> = {
-  [K in keyof T]: { type: K; value: T[K] };
-}[keyof T];

package/src/runtimes/edge/streams/utils/chunkByLineStream.ts

@@ -1,24 +0,0 @@
-export function chunkByLineStream() {
-  let buffer = "";
-
-  return new TransformStream({
-    transform(chunk, controller) {
-      buffer += chunk;
-      const lines = buffer.split("\n");
-
-      // Process all complete lines
-      for (let i = 0; i < lines.length - 1; i++) {
-        controller.enqueue(lines[i]);
-      }
-
-      // Keep the last incomplete line in the buffer
-      buffer = lines[lines.length - 1]!;
-    },
-    flush(controller) {
-      // flush any remaining content in the buffer
-      if (buffer) {
-        controller.enqueue(buffer);
-      }
-    },
-  });
-}

package/src/runtimes/edge/streams/utils/index.ts

@@ -1,15 +0,0 @@
-import { streamPartDecoderStream } from "./streamPartDecoderStream";
-import { streamPartEncoderStream } from "./streamPartEncoderStream";
-import { StreamPart } from "./StreamPart";
-
-export declare namespace StreamUtils {
-  export { StreamPart };
-}
-
-/**
- * @deprecated `streamUtils` will be replaced with `assistant-stream` once it is ready.
- */
-export const streamUtils = {
-  streamPartEncoderStream,
-  streamPartDecoderStream,
-};

package/src/runtimes/edge/streams/utils/streamPartDecoderStream.ts

@@ -1,29 +0,0 @@
-import { chunkByLineStream } from "./chunkByLineStream";
-import { PipeableTransformStream } from "./PipeableTransformStream";
-import { StreamPart } from "./StreamPart";
-
-const decodeStreamPart = <T extends Record<string, unknown>>(
-  part: string,
-): StreamPart<T> => {
-  const index = part.indexOf(":");
-  if (index === -1) throw new Error("Invalid stream part");
-  return {
-    type: part.slice(0, index),
-    value: JSON.parse(part.slice(index + 1)),
-  };
-};
-
-export function streamPartDecoderStream<T extends Record<string, unknown>>() {
-  const decodeStream = new TransformStream<string, StreamPart<T>>({
-    transform(chunk, controller) {
-      controller.enqueue(decodeStreamPart<T>(chunk));
-    },
-  });
-
-  return new PipeableTransformStream((readable) => {
-    return readable
-      .pipeThrough(new TextDecoderStream())
-      .pipeThrough(chunkByLineStream())
-      .pipeThrough(decodeStream);
-  });
-}

package/src/runtimes/edge/streams/utils/streamPartEncoderStream.ts

@@ -1,23 +0,0 @@
-import { PipeableTransformStream } from "./PipeableTransformStream";
-import { StreamPart } from "./StreamPart";
-
-function encodeStreamPart<T extends Record<string, unknown>>({
-  type,
-  value,
-}: StreamPart<T>): string {
-  return `${type as string}:${JSON.stringify(value)}\n`;
-}
-
-export function streamPartEncoderStream<T extends Record<string, unknown>>() {
-  const encodeStream = new TransformStream<StreamPart<T>, string>({
-    transform(chunk, controller) {
-      controller.enqueue(encodeStreamPart<T>(chunk));
-    },
-  });
-
-  return new PipeableTransformStream((readable) => {
-    return readable
-      .pipeThrough(encodeStream)
-      .pipeThrough(new TextEncoderStream());
-  });
-}