@assistant-ui/react 0.5.30 → 0.5.32

package/dist/edge.d.ts

@@ -1,6 +1,6 @@
 import { LanguageModelV1LogProbs, LanguageModelV1, LanguageModelV1ToolChoice } from '@ai-sdk/provider';
-import { z } from 'zod';
 import { JSONSchema7 } from 'json-schema';
+import { z } from 'zod';
 
 type TextContentPart = {
     type: "text";
@@ -42,6 +42,255 @@ type CoreAssistantMessage = {
 };
 type CoreMessage = CoreSystemMessage | CoreUserMessage | CoreAssistantMessage;
 
+declare const EdgeRuntimeRequestOptionsSchema: z.ZodObject<z.objectUtil.extendShape<z.objectUtil.extendShape<{
+    system: z.ZodOptional<z.ZodString>;
+    messages: z.ZodArray<z.ZodDiscriminatedUnion<"role", [z.ZodObject<{
+        role: z.ZodLiteral<"system">;
+        content: z.ZodTuple<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            text: string;
+            type: "text";
+        }, {
+            text: string;
+            type: "text";
+        }>], null>;
+    }, "strip", z.ZodTypeAny, {
+        role: "system";
+        content: [{
+            text: string;
+            type: "text";
+        }];
+    }, {
+        role: "system";
+        content: [{
+            text: string;
+            type: "text";
+        }];
+    }>, z.ZodObject<{
+        role: z.ZodLiteral<"user">;
+        content: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            text: string;
+            type: "text";
+        }, {
+            text: string;
+            type: "text";
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"image">;
+            image: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            image: string;
+            type: "image";
+        }, {
+            image: string;
+            type: "image";
+        }>]>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        role: "user";
+        content: ({
+            text: string;
+            type: "text";
+        } | {
+            image: string;
+            type: "image";
+        })[];
+    }, {
+        role: "user";
+        content: ({
+            text: string;
+            type: "text";
+        } | {
+            image: string;
+            type: "image";
+        })[];
+    }>, z.ZodObject<{
+        role: z.ZodLiteral<"assistant">;
+        content: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            text: string;
+            type: "text";
+        }, {
+            text: string;
+            type: "text";
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"tool-call">;
+            toolCallId: z.ZodString;
+            toolName: z.ZodString;
+            args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            result: z.ZodOptional<z.ZodUnknown>;
+            isError: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            type: "tool-call";
+            toolCallId: string;
+            toolName: string;
+            args: Record<string, unknown>;
+            isError?: boolean | undefined;
+            result?: unknown;
+        }, {
+            type: "tool-call";
+            toolCallId: string;
+            toolName: string;
+            args: Record<string, unknown>;
+            isError?: boolean | undefined;
+            result?: unknown;
+        }>]>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        role: "assistant";
+        content: ({
+            text: string;
+            type: "text";
+        } | {
+            type: "tool-call";
+            toolCallId: string;
+            toolName: string;
+            args: Record<string, unknown>;
+            isError?: boolean | undefined;
+            result?: unknown;
+        })[];
+    }, {
+        role: "assistant";
+        content: ({
+            text: string;
+            type: "text";
+        } | {
+            type: "tool-call";
+            toolCallId: string;
+            toolName: string;
+            args: Record<string, unknown>;
+            isError?: boolean | undefined;
+            result?: unknown;
+        })[];
+    }>]>, "many">;
+    tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"function">;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        parameters: z.ZodType<JSONSchema7, z.ZodTypeDef, JSONSchema7>;
+    }, "strip", z.ZodTypeAny, {
+        type: "function";
+        name: string;
+        parameters: JSONSchema7;
+        description?: string | undefined;
+    }, {
+        type: "function";
+        name: string;
+        parameters: JSONSchema7;
+        description?: string | undefined;
+    }>, "many">>;
+}, {
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    topP: z.ZodOptional<z.ZodNumber>;
+    presencePenalty: z.ZodOptional<z.ZodNumber>;
+    frequencyPenalty: z.ZodOptional<z.ZodNumber>;
+    seed: z.ZodOptional<z.ZodNumber>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodOptional<z.ZodString>>>;
+}>, {
+    apiKey: z.ZodOptional<z.ZodString>;
+    baseUrl: z.ZodOptional<z.ZodString>;
+    modelName: z.ZodOptional<z.ZodString>;
+}>, "strip", z.ZodTypeAny, {
+    messages: ({
+        role: "user";
+        content: ({
+            text: string;
+            type: "text";
+        } | {
+            image: string;
+            type: "image";
+        })[];
+    } | {
+        role: "assistant";
+        content: ({
+            text: string;
+            type: "text";
+        } | {
+            type: "tool-call";
+            toolCallId: string;
+            toolName: string;
+            args: Record<string, unknown>;
+            isError?: boolean | undefined;
+            result?: unknown;
+        })[];
+    } | {
+        role: "system";
+        content: [{
+            text: string;
+            type: "text";
+        }];
+    })[];
+    system?: string | undefined;
+    maxTokens?: number | undefined;
+    temperature?: number | undefined;
+    topP?: number | undefined;
+    presencePenalty?: number | undefined;
+    frequencyPenalty?: number | undefined;
+    seed?: number | undefined;
+    headers?: Record<string, string | undefined> | undefined;
+    apiKey?: string | undefined;
+    baseUrl?: string | undefined;
+    modelName?: string | undefined;
+    tools?: {
+        type: "function";
+        name: string;
+        parameters: JSONSchema7;
+        description?: string | undefined;
+    }[] | undefined;
+}, {
+    messages: ({
+        role: "user";
+        content: ({
+            text: string;
+            type: "text";
+        } | {
+            image: string;
+            type: "image";
+        })[];
+    } | {
+        role: "assistant";
+        content: ({
+            text: string;
+            type: "text";
+        } | {
+            type: "tool-call";
+            toolCallId: string;
+            toolName: string;
+            args: Record<string, unknown>;
+            isError?: boolean | undefined;
+            result?: unknown;
+        })[];
+    } | {
+        role: "system";
+        content: [{
+            text: string;
+            type: "text";
+        }];
+    })[];
+    system?: string | undefined;
+    maxTokens?: number | undefined;
+    temperature?: number | undefined;
+    topP?: number | undefined;
+    presencePenalty?: number | undefined;
+    frequencyPenalty?: number | undefined;
+    seed?: number | undefined;
+    headers?: Record<string, string | undefined> | undefined;
+    apiKey?: string | undefined;
+    baseUrl?: string | undefined;
+    modelName?: string | undefined;
+    tools?: {
+        type: "function";
+        name: string;
+        parameters: JSONSchema7;
+        description?: string | undefined;
+    }[] | undefined;
+}>;
+
 declare const LanguageModelV1CallSettingsSchema: z.ZodObject<{
     maxTokens: z.ZodOptional<z.ZodNumber>;
     temperature: z.ZodOptional<z.ZodNumber>;
@@ -103,8 +352,17 @@ type CreateEdgeRuntimeAPIOptions = LanguageModelV1CallSettings & {
     toolChoice?: LanguageModelV1ToolChoice;
     onFinish?: (result: FinishResult) => void;
 };
-declare const createEdgeRuntimeAPI: ({ model: modelOrCreator, system: serverSystem, tools: serverTools, toolChoice, onFinish, ...unsafeSettings }: CreateEdgeRuntimeAPIOptions) => {
+type GetEdgeRuntimeStreamOptions = {
+    abortSignal: AbortSignal;
+    requestData: z.infer<typeof EdgeRuntimeRequestOptionsSchema>;
+    options: CreateEdgeRuntimeAPIOptions;
+};
+declare namespace getEdgeRuntimeResponse {
+    export type { GetEdgeRuntimeStreamOptions as Options };
+}
+declare const getEdgeRuntimeResponse: (options: getEdgeRuntimeResponse.Options) => Promise<Response>;
+declare const createEdgeRuntimeAPI: (options: CreateEdgeRuntimeAPIOptions) => {
     POST: (request: Request) => Promise<Response>;
 };
 
-export { createEdgeRuntimeAPI };
+export { createEdgeRuntimeAPI, getEdgeRuntimeResponse };

package/dist/edge.js

@@ -30,7 +30,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/edge.ts
 var edge_exports = {};
 __export(edge_exports, {
-  createEdgeRuntimeAPI: () => createEdgeRuntimeAPI
+  createEdgeRuntimeAPI: () => createEdgeRuntimeAPI,
+  getEdgeRuntimeResponse: () => getEdgeRuntimeResponse
 });
 module.exports = __toCommonJS(edge_exports);
 
@@ -963,117 +964,112 @@ var voidStream = () => {
     }
   });
 };
-var createEdgeRuntimeAPI = ({
-  model: modelOrCreator,
-  system: serverSystem,
-  tools: serverTools = {},
-  toolChoice,
-  onFinish,
-  ...unsafeSettings
+var getEdgeRuntimeStream = async ({
+  abortSignal,
+  requestData: unsafeRequest,
+  options: {
+    model: modelOrCreator,
+    system: serverSystem,
+    tools: serverTools = {},
+    toolChoice,
+    onFinish,
+    ...unsafeSettings
+  }
 }) => {
   const settings = LanguageModelV1CallSettingsSchema.parse(unsafeSettings);
   const lmServerTools = toLanguageModelTools(serverTools);
   const hasServerTools = Object.values(serverTools).some((v) => !!v.execute);
-  const POST = async (request) => {
-    const {
-      system: clientSystem,
-      tools: clientTools = [],
-      messages,
-      apiKey,
-      baseUrl,
-      modelName,
-      ...callSettings
-    } = EdgeRuntimeRequestOptionsSchema.parse(await request.json());
-    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 {
+    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.`
+      );
     }
-    let model;
-    try {
-      model = typeof modelOrCreator === "function" ? await modelOrCreator({ apiKey, baseUrl, modelName }) : modelOrCreator;
-    } catch (e) {
-      return new Response(
-        JSON.stringify({
-          type: "error",
-          error: e.message
-        }),
-        {
-          status: 500,
-          headers: {
-            "Content-Type": "application/json"
+  }
+  let model;
+  model = typeof modelOrCreator === "function" ? await modelOrCreator({ apiKey, baseUrl, modelName }) : modelOrCreator;
+  let stream;
+  const streamResult = await streamMessage({
+    ...settings,
+    ...callSettings,
+    model,
+    abortSignal,
+    ...!!system ? { system } : void 0,
+    messages,
+    tools: lmServerTools.concat(clientTools),
+    ...toolChoice ? { toolChoice } : void 0
+  });
+  stream = streamResult.stream;
+  const canExecuteTools = hasServerTools && toolChoice?.type !== "none";
+  if (canExecuteTools) {
+    stream = stream.pipeThrough(toolResultStream(serverTools, abortSignal));
+  }
+  if (canExecuteTools || onFinish) {
+    const tees = stream.tee();
+    stream = tees[0];
+    let serverStream = tees[1];
+    if (onFinish) {
+      let lastChunk;
+      serverStream = serverStream.pipeThrough(runResultStream()).pipeThrough(
+        new TransformStream({
+          transform(chunk) {
+            lastChunk = chunk;
+          },
+          flush() {
+            if (!lastChunk?.status || lastChunk.status.type === "running")
+              return;
+            const resultingMessages = [
+              ...messages,
+              toCoreMessage({
+                role: "assistant",
+                content: lastChunk.content
+              })
+            ];
+            onFinish({
+              messages: resultingMessages,
+              roundtrips: lastChunk.roundtrips
+            });
           }
-        }
+        })
       );
     }
-    let stream;
-    const streamResult = await streamMessage({
-      ...settings,
-      ...callSettings,
-      model,
-      abortSignal: request.signal,
-      ...!!system ? { system } : void 0,
-      messages,
-      tools: lmServerTools.concat(clientTools),
-      ...toolChoice ? { toolChoice } : void 0
+    serverStream.pipeTo(voidStream()).catch((e) => {
+      console.error("Server stream processing error:", e);
     });
-    stream = streamResult.stream;
-    const canExecuteTools = hasServerTools && toolChoice?.type !== "none";
-    if (canExecuteTools) {
-      stream = stream.pipeThrough(
-        toolResultStream(serverTools, request.signal)
-      );
-    }
-    if (canExecuteTools || onFinish) {
-      const tees = stream.tee();
-      stream = tees[0];
-      let serverStream = tees[1];
-      if (onFinish) {
-        let lastChunk;
-        serverStream = serverStream.pipeThrough(runResultStream()).pipeThrough(
-          new TransformStream({
-            transform(chunk) {
-              lastChunk = chunk;
-            },
-            flush() {
-              if (!lastChunk?.status || lastChunk.status.type === "running")
-                return;
-              const resultingMessages = [
-                ...messages,
-                toCoreMessage({
-                  role: "assistant",
-                  content: lastChunk.content
-                })
-              ];
-              onFinish({
-                messages: resultingMessages,
-                roundtrips: lastChunk.roundtrips
-              });
-            }
-          })
-        );
+  }
+  return stream;
+};
+var getEdgeRuntimeResponse = async (options) => {
+  const stream = await getEdgeRuntimeStream(options);
+  return new Response(
+    stream.pipeThrough(assistantEncoderStream()).pipeThrough(streamPartEncoderStream()),
+    {
+      headers: {
+        "Content-Type": "text/plain; charset=utf-8"
       }
-      serverStream.pipeTo(voidStream()).catch((e) => {
-        console.error("Server stream processing error:", e);
-      });
     }
-    return new Response(
-      stream.pipeThrough(assistantEncoderStream()).pipeThrough(streamPartEncoderStream()),
-      {
-        headers: {
-          contentType: "text/plain; charset=utf-8"
-        }
-      }
-    );
-  };
-  return { POST };
+  );
 };
+var createEdgeRuntimeAPI = (options) => ({
+  POST: async (request) => getEdgeRuntimeResponse({
+    abortSignal: request.signal,
+    requestData: await request.json(),
+    options
+  })
+});
 async function streamMessage({
   model,
   system,
@@ -1103,6 +1099,7 @@ function convertToLanguageModelPrompt(system, messages) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createEdgeRuntimeAPI
+  createEdgeRuntimeAPI,
+  getEdgeRuntimeResponse
 });
 //# sourceMappingURL=edge.js.map