@assistant-ui/react 0.8.20 → 0.9.1

package/src/runtimes/edge/converters/toLanguageModelMessages.ts

@@ -1,184 +0,0 @@
-import {
-  LanguageModelV1FilePart,
-  LanguageModelV1ImagePart,
-  LanguageModelV1Message,
-  LanguageModelV1TextPart,
-  LanguageModelV1ToolCallPart,
-  LanguageModelV1ToolResultPart,
-} from "@ai-sdk/provider";
-import {
-  CoreMessage,
-  ThreadMessage,
-  TextContentPart,
-  CoreToolCallContentPart,
-  ToolCallContentPart,
-} from "../../../types/AssistantTypes";
-
-const assistantMessageSplitter = () => {
-  const stash: LanguageModelV1Message[] = [];
-  let assistantMessage = {
-    role: "assistant" as const,
-    content: [] as (LanguageModelV1TextPart | LanguageModelV1ToolCallPart)[],
-  };
-  let toolMessage = {
-    role: "tool" as const,
-    content: [] as LanguageModelV1ToolResultPart[],
-  };
-
-  return {
-    addTextContentPart: (part: TextContentPart) => {
-      if (toolMessage.content.length > 0) {
-        stash.push(assistantMessage);
-        stash.push(toolMessage);
-
-        assistantMessage = {
-          role: "assistant" as const,
-          content: [] as (
-            | LanguageModelV1TextPart
-            | LanguageModelV1ToolCallPart
-          )[],
-        };
-
-        toolMessage = {
-          role: "tool" as const,
-          content: [] as LanguageModelV1ToolResultPart[],
-        };
-      }
-
-      assistantMessage.content.push(part);
-    },
-    addToolCallPart: (part: CoreToolCallContentPart | ToolCallContentPart) => {
-      assistantMessage.content.push({
-        type: "tool-call",
-        toolCallId: part.toolCallId,
-        toolName: part.toolName,
-        args: part.args,
-      });
-
-      toolMessage.content.push({
-        type: "tool-result",
-        toolCallId: part.toolCallId,
-        toolName: part.toolName,
-        ...("artifact" in part ? { artifact: part.artifact } : {}),
-        result:
-          part.result === undefined
-            ? "Error: tool is has no configured code to run"
-            : part.result,
-        isError: part.isError ?? part.result === undefined,
-      });
-    },
-    getMessages: () => {
-      if (toolMessage.content.length > 0) {
-        return [...stash, assistantMessage, toolMessage];
-      }
-
-      return [...stash, assistantMessage];
-    },
-  };
-};
-
-export function toLanguageModelMessages(
-  message: readonly CoreMessage[] | readonly ThreadMessage[],
-  options: { unstable_includeId?: boolean | undefined } = {},
-): LanguageModelV1Message[] {
-  const includeId = options.unstable_includeId ?? false;
-  return message.flatMap((message) => {
-    const role = message.role;
-    switch (role) {
-      case "system": {
-        return [
-          {
-            ...(includeId
-              ? { unstable_id: (message as ThreadMessage).id }
-              : {}),
-            role: "system",
-            content: message.content[0].text,
-          },
-        ];
-      }
-
-      case "user": {
-        const attachments = "attachments" in message ? message.attachments : [];
-        const content = [
-          ...message.content,
-          ...attachments.map((a) => a.content).flat(),
-        ];
-        const msg: LanguageModelV1Message = {
-          ...(includeId ? { unstable_id: (message as ThreadMessage).id } : {}),
-          role: "user",
-          content: content.map(
-            (
-              part,
-            ):
-              | LanguageModelV1TextPart
-              | LanguageModelV1ImagePart
-              | LanguageModelV1FilePart => {
-              const type = part.type;
-              switch (type) {
-                case "text": {
-                  return part;
-                }
-
-                case "image": {
-                  return {
-                    type: "image",
-                    image: new URL(part.image),
-                  };
-                }
-
-                case "file": {
-                  return {
-                    type: "file",
-                    data: new URL(part.data),
-                    mimeType: part.mimeType,
-                  };
-                }
-
-                default: {
-                  const unhandledType: "audio" = type;
-                  throw new Error(
-                    `Unspported content part type: ${unhandledType}`,
-                  );
-                }
-              }
-            },
-          ),
-        };
-        return [msg];
-      }
-
-      case "assistant": {
-        const splitter = assistantMessageSplitter();
-        for (const part of message.content) {
-          const type = part.type;
-          switch (type) {
-            case "reasoning":
-            case "source":
-            case "file": {
-              break; // reasoning, source, and file parts are omitted
-            }
-
-            case "text": {
-              splitter.addTextContentPart(part);
-              break;
-            }
-            case "tool-call": {
-              splitter.addToolCallPart(part);
-              break;
-            }
-            default: {
-              const unhandledType: never = type;
-              throw new Error(`Unhandled content part type: ${unhandledType}`);
-            }
-          }
-        }
-        return splitter.getMessages();
-      }
-
-      default: {
-        const unhandledRole: never = role;
-        throw new Error(`Unknown message role: ${unhandledRole}`);
-      }
-    }
-  });
-}

package/src/runtimes/edge/converters/toLanguageModelTools.ts

@@ -1,18 +0,0 @@
-import { LanguageModelV1FunctionTool } from "@ai-sdk/provider";
-import { JSONSchema7 } from "json-schema";
-import { z } from "zod";
-import zodToJsonSchema from "zod-to-json-schema";
-import { Tool } from "../../../model-context/ModelContextTypes";
-
-export const toLanguageModelTools = (
-  tools: Record<string, Tool<any, any>>,
-): LanguageModelV1FunctionTool[] => {
-  return Object.entries(tools).map(([name, tool]) => ({
-    type: "function",
-    name,
-    ...(tool.description ? { description: tool.description } : undefined),
-    parameters: (tool.parameters instanceof z.ZodType
-      ? zodToJsonSchema(tool.parameters)
-      : tool.parameters) as JSONSchema7,
-  }));
-};

package/src/runtimes/edge/createEdgeRuntimeAPI.ts

@@ -1,234 +0,0 @@
-import {
-  LanguageModelV1,
-  LanguageModelV1ToolChoice,
-  LanguageModelV1FunctionTool,
-  LanguageModelV1Prompt,
-  LanguageModelV1CallOptions,
-} from "@ai-sdk/provider";
-import {
-  CoreMessage,
-  ThreadMessage,
-  ThreadStep,
-} from "../../types/AssistantTypes";
-import { EdgeRuntimeRequestOptionsSchema } from "./EdgeRuntimeRequestOptions";
-import { toLanguageModelMessages } from "./converters/toLanguageModelMessages";
-import { toLanguageModelTools } from "./converters/toLanguageModelTools";
-import { toolResultStream } from "./streams/toolResultStream";
-import {
-  LanguageModelConfig,
-  LanguageModelV1CallSettings,
-  LanguageModelV1CallSettingsSchema,
-  Tool,
-} from "../../model-context/ModelContextTypes";
-import { z } from "zod";
-import {
-  AssistantMessage,
-  AssistantMessageAccumulator,
-  AssistantStreamChunk,
-  DataStreamEncoder,
-} from "assistant-stream";
-import { LanguageModelV1StreamDecoder } from "assistant-stream/ai-sdk";
-
-type FinishResult = {
-  messages: readonly (CoreMessage | ThreadMessage)[];
-  metadata: {
-    steps: readonly ThreadStep[];
-  };
-};
-
-type LanguageModelCreator = (
-  config: LanguageModelConfig,
-) => Promise<LanguageModelV1> | LanguageModelV1;
-
-export type CreateEdgeRuntimeAPIOptions = LanguageModelV1CallSettings & {
-  model: LanguageModelV1 | LanguageModelCreator;
-  system?: string;
-  tools?: Record<string, Tool<any, any>>;
-  toolChoice?: LanguageModelV1ToolChoice;
-  onFinish?: (result: FinishResult) => void;
-};
-
-type GetEdgeRuntimeStreamOptions = {
-  abortSignal: AbortSignal;
-  requestData: z.infer<typeof EdgeRuntimeRequestOptionsSchema>;
-  options: CreateEdgeRuntimeAPIOptions;
-};
-
-export const getEdgeRuntimeStream = async ({
-  abortSignal,
-  requestData: unsafeRequest,
-  options: {
-    model: modelOrCreator,
-    system: serverSystem,
-    tools: serverTools = {},
-    toolChoice,
-    onFinish,
-    ...unsafeSettings
-  },
-}: GetEdgeRuntimeStreamOptions) => {
-  const settings = LanguageModelV1CallSettingsSchema.parse(unsafeSettings);
-  const lmServerTools = toLanguageModelTools(serverTools);
-  const hasServerTools = Object.values(serverTools).some((v) => !!v.execute);
-
-  const {
-    system: clientSystem,
-    tools: clientTools = [],
-    messages,
-    apiKey,
-    baseUrl,
-    modelName,
-    ...callSettings
-  } = EdgeRuntimeRequestOptionsSchema.parse(unsafeRequest);
-
-  const systemMessages = [];
-  if (serverSystem) systemMessages.push(serverSystem);
-  if (clientSystem) systemMessages.push(clientSystem);
-  const system = systemMessages.join("\n\n");
-
-  for (const clientTool of clientTools) {
-    if (serverTools?.[clientTool.name]) {
-      throw new Error(
-        `Tool ${clientTool.name} was defined in both the client and server tools. This is not allowed.`,
-      );
-    }
-  }
-
-  const model =
-    typeof modelOrCreator === "function"
-      ? await modelOrCreator({ apiKey, baseUrl, modelName })
-      : modelOrCreator;
-
-  let stream: ReadableStream<AssistantStreamChunk>;
-  const streamResult = await streamMessage({
-    ...(settings as Partial<StreamMessageOptions>),
-    ...callSettings,
-
-    model,
-    abortSignal,
-
-    ...(!!system ? { system } : undefined),
-    messages,
-    tools: lmServerTools.concat(clientTools as LanguageModelV1FunctionTool[]),
-    ...(toolChoice ? { toolChoice } : undefined),
-  });
-  stream = streamResult.stream.pipeThrough(new LanguageModelV1StreamDecoder());
-
-  // add tool results if we have server tools
-  const canExecuteTools = hasServerTools && toolChoice?.type !== "none";
-  if (canExecuteTools) {
-    stream = stream.pipeThrough(toolResultStream(serverTools, abortSignal));
-  }
-
-  if (canExecuteTools || onFinish) {
-    // tee the stream to process server tools and onFinish asap
-    const tees = stream.tee();
-    stream = tees[0];
-    let serverStream = tees[1];
-
-    if (onFinish) {
-      let lastChunk: AssistantMessage | undefined;
-      serverStream.pipeThrough(new AssistantMessageAccumulator()).pipeTo(
-        new WritableStream({
-          write(chunk) {
-            lastChunk = chunk;
-          },
-          close() {
-            if (!lastChunk?.status || lastChunk.status.type === "running")
-              return;
-
-            const resultingMessages = [
-              ...messages,
-              {
-                id: "DEFAULT",
-                createdAt: new Date(),
-                role: "assistant",
-                content: lastChunk.content,
-                status: lastChunk.status,
-                metadata: lastChunk.metadata,
-              } satisfies ThreadMessage,
-            ];
-            onFinish({
-              messages: resultingMessages,
-              metadata: {
-                steps: lastChunk.metadata.steps,
-              },
-            });
-          },
-          abort(e) {
-            console.error("Server stream processing error:", e);
-          },
-        }),
-      );
-    }
-  }
-
-  return stream;
-};
-
-export declare namespace getEdgeRuntimeResponse {
-  export type { GetEdgeRuntimeStreamOptions as Options };
-}
-
-export const getEdgeRuntimeResponse = async (
-  options: getEdgeRuntimeResponse.Options,
-) => {
-  const stream = await getEdgeRuntimeStream(options);
-  return new Response(stream.pipeThrough(new DataStreamEncoder()), {
-    headers: {
-      "Content-Type": "text/plain; charset=utf-8",
-      "x-vercel-ai-data-stream": "v1",
-    },
-  });
-};
-
-export const createEdgeRuntimeAPI = (options: CreateEdgeRuntimeAPIOptions) => ({
-  POST: async (request: Request) =>
-    getEdgeRuntimeResponse({
-      abortSignal: request.signal,
-      requestData: await request.json(),
-      options,
-    }),
-});
-
-type StreamMessageOptions = LanguageModelV1CallSettings & {
-  model: LanguageModelV1;
-  system?: string;
-  messages: readonly CoreMessage[];
-  tools?: LanguageModelV1FunctionTool[];
-  toolChoice?: LanguageModelV1ToolChoice;
-  abortSignal: AbortSignal;
-};
-
-async function streamMessage({
-  model,
-  system,
-  messages,
-  tools,
-  toolChoice,
-  ...options
-}: StreamMessageOptions) {
-  return model.doStream({
-    inputFormat: "messages",
-    mode: {
-      type: "regular",
-      ...(tools ? { tools } : undefined),
-      ...(toolChoice ? { toolChoice } : undefined),
-    },
-    prompt: convertToLanguageModelPrompt(system, messages),
-    ...(options as Partial<LanguageModelV1CallOptions>),
-  });
-}
-
-export function convertToLanguageModelPrompt(
-  system: string | undefined,
-  messages: readonly CoreMessage[],
-): LanguageModelV1Prompt {
-  const languageModelMessages: LanguageModelV1Prompt = [];
-
-  if (system != null) {
-    languageModelMessages.push({ role: "system", content: system });
-  }
-  languageModelMessages.push(...toLanguageModelMessages(messages));
-
-  return languageModelMessages;
-}

package/src/runtimes/edge/index.ts

@@ -1,7 +0,0 @@
-export * from "./converters";
-
-export { useEdgeRuntime, type EdgeRuntimeOptions } from "./useEdgeRuntime";
-export { EdgeModelAdapter as EdgeChatAdapter } from "./EdgeModelAdapter";
-export type { EdgeRuntimeRequestOptions } from "./EdgeRuntimeRequestOptions";
-
-export { unstable_runPendingTools } from "./streams/toolResultStream";

package/src/runtimes/edge/useEdgeRuntime.ts

@@ -1,17 +0,0 @@
-"use client";
-
-import { LocalRuntimeOptions, useLocalRuntime } from "..";
-import { EdgeModelAdapterOptions, EdgeModelAdapter } from "./EdgeModelAdapter";
-import { splitLocalRuntimeOptions } from "../local/LocalRuntimeOptions";
-
-export type EdgeRuntimeOptions = EdgeModelAdapterOptions & LocalRuntimeOptions;
-
-export const useEdgeRuntime = (options: EdgeRuntimeOptions) => {
-  const { localRuntimeOptions, otherOptions } =
-    splitLocalRuntimeOptions(options);
-
-  return useLocalRuntime(
-    new EdgeModelAdapter(otherOptions),
-    localRuntimeOptions,
-  );
-};

package/src/utils/json/parse-partial-json.ts

@@ -1,74 +0,0 @@
-import sjson from "secure-json-parse";
-import { fixJson } from "./fix-json";
-import {
-  ContentPartStatus,
-  ToolCallContentPartStatus,
-} from "../../types/AssistantTypes";
-import { useContentPart } from "../../context";
-
-const PARTIAL_JSON_COUNT_SYMBOL = Symbol("partial-json-count");
-export const parsePartialJson = (json: string) => {
-  try {
-    return sjson.parse(json);
-  } catch {
-    try {
-      const [fixedJson, partialCount] = fixJson(json);
-      const res = sjson.parse(fixedJson);
-      res[PARTIAL_JSON_COUNT_SYMBOL] = partialCount;
-      return res;
-    } catch {
-      return undefined;
-    }
-  }
-};
-
-const COMPLETE_STATUS = Object.freeze({ type: "complete" });
-
-const getFieldStatus = (
-  lastState: ContentPartStatus,
-  args: unknown,
-  fieldPath: string[],
-  partialCount: number,
-): ContentPartStatus => {
-  if (fieldPath.length === 0) return lastState;
-  if (typeof args !== "object" || args === null) return COMPLETE_STATUS;
-
-  const path = fieldPath.at(-1)!;
-
-  // If the expected property does not exist, mark as incomplete
-  if (!Object.prototype.hasOwnProperty.call(args, path)) {
-    return lastState;
-  }
-
-  const argsKeys = Object.keys(args);
-  const isLast = argsKeys[argsKeys.length - 1] === path;
-  if (!isLast) return COMPLETE_STATUS;
-
-  return getFieldStatus(
-    lastState,
-    (args as Record<string, unknown>)[path],
-    fieldPath.slice(0, -1),
-    partialCount - 1,
-  );
-};
-
-const getToolArgsFieldStatus = (
-  status: ToolCallContentPartStatus,
-  args: Record<string, unknown>,
-  fieldPath: string[],
-): ContentPartStatus => {
-  const partialCount = (args as any)[PARTIAL_JSON_COUNT_SYMBOL] ?? 0;
-  if (partialCount === 0) return COMPLETE_STATUS;
-
-  const lastState: ContentPartStatus =
-    status.type !== "requires-action" ? status : COMPLETE_STATUS;
-
-  return getFieldStatus(lastState, args, fieldPath, partialCount);
-};
-
-export const useToolArgsFieldStatus = (fieldPath: string[]) => {
-  return useContentPart((p) => {
-    if (p.type !== "tool-call") throw new Error("not a tool call");
-    return getToolArgsFieldStatus(p.status, p.args, fieldPath);
-  });
-};