ai 3.0.33 → 3.0.34

package/rsc/dist/rsc-server.mjs

@@ -175,7 +175,319 @@ function getMutableAIState(...args) {
 }
 
 // rsc/streamable.tsx
+import zodToJsonSchema2 from "zod-to-json-schema";
+
+// core/util/detect-image-mimetype.ts
+var mimeTypeSignatures = [
+  { mimeType: "image/gif", bytes: [71, 73, 70] },
+  { mimeType: "image/png", bytes: [137, 80, 78, 71] },
+  { mimeType: "image/jpeg", bytes: [255, 216] },
+  { mimeType: "image/webp", bytes: [82, 73, 70, 70] }
+];
+function detectImageMimeType(image) {
+  for (const { bytes, mimeType } of mimeTypeSignatures) {
+    if (image.length >= bytes.length && bytes.every((byte, index) => image[index] === byte)) {
+      return mimeType;
+    }
+  }
+  return void 0;
+}
+
+// core/prompt/data-content.ts
+import { InvalidDataContentError } from "@ai-sdk/provider";
+import {
+  convertBase64ToUint8Array,
+  convertUint8ArrayToBase64
+} from "@ai-sdk/provider-utils";
+function convertDataContentToUint8Array(content) {
+  if (content instanceof Uint8Array) {
+    return content;
+  }
+  if (typeof content === "string") {
+    return convertBase64ToUint8Array(content);
+  }
+  if (content instanceof ArrayBuffer) {
+    return new Uint8Array(content);
+  }
+  throw new InvalidDataContentError({ content });
+}
+
+// core/prompt/convert-to-language-model-prompt.ts
+function convertToLanguageModelPrompt(prompt) {
+  const languageModelMessages = [];
+  if (prompt.system != null) {
+    languageModelMessages.push({ role: "system", content: prompt.system });
+  }
+  switch (prompt.type) {
+    case "prompt": {
+      languageModelMessages.push({
+        role: "user",
+        content: [{ type: "text", text: prompt.prompt }]
+      });
+      break;
+    }
+    case "messages": {
+      languageModelMessages.push(
+        ...prompt.messages.map((message) => {
+          switch (message.role) {
+            case "user": {
+              if (typeof message.content === "string") {
+                return {
+                  role: "user",
+                  content: [{ type: "text", text: message.content }]
+                };
+              }
+              return {
+                role: "user",
+                content: message.content.map(
+                  (part) => {
+                    var _a;
+                    switch (part.type) {
+                      case "text": {
+                        return part;
+                      }
+                      case "image": {
+                        if (part.image instanceof URL) {
+                          return {
+                            type: "image",
+                            image: part.image,
+                            mimeType: part.mimeType
+                          };
+                        }
+                        const imageUint8 = convertDataContentToUint8Array(
+                          part.image
+                        );
+                        return {
+                          type: "image",
+                          image: imageUint8,
+                          mimeType: (_a = part.mimeType) != null ? _a : detectImageMimeType(imageUint8)
+                        };
+                      }
+                    }
+                  }
+                )
+              };
+            }
+            case "assistant": {
+              if (typeof message.content === "string") {
+                return {
+                  role: "assistant",
+                  content: [{ type: "text", text: message.content }]
+                };
+              }
+              return { role: "assistant", content: message.content };
+            }
+            case "tool": {
+              return message;
+            }
+          }
+        })
+      );
+      break;
+    }
+    default: {
+      const _exhaustiveCheck = prompt;
+      throw new Error(`Unsupported prompt type: ${_exhaustiveCheck}`);
+    }
+  }
+  return languageModelMessages;
+}
+
+// core/prompt/get-validated-prompt.ts
+import { InvalidPromptError } from "@ai-sdk/provider";
+function getValidatedPrompt(prompt) {
+  if (prompt.prompt == null && prompt.messages == null) {
+    throw new InvalidPromptError({
+      prompt,
+      message: "prompt or messages must be defined"
+    });
+  }
+  if (prompt.prompt != null && prompt.messages != null) {
+    throw new InvalidPromptError({
+      prompt,
+      message: "prompt and messages cannot be defined at the same time"
+    });
+  }
+  return prompt.prompt != null ? {
+    type: "prompt",
+    prompt: prompt.prompt,
+    messages: void 0,
+    system: prompt.system
+  } : {
+    type: "messages",
+    prompt: void 0,
+    messages: prompt.messages,
+    // only possible case bc of checks above
+    system: prompt.system
+  };
+}
+
+// core/prompt/prepare-call-settings.ts
+import { InvalidArgumentError } from "@ai-sdk/provider";
+function prepareCallSettings({
+  maxTokens,
+  temperature,
+  topP,
+  presencePenalty,
+  frequencyPenalty,
+  seed,
+  maxRetries
+}) {
+  if (maxTokens != null) {
+    if (!Number.isInteger(maxTokens)) {
+      throw new InvalidArgumentError({
+        parameter: "maxTokens",
+        value: maxTokens,
+        message: "maxTokens must be an integer"
+      });
+    }
+    if (maxTokens < 1) {
+      throw new InvalidArgumentError({
+        parameter: "maxTokens",
+        value: maxTokens,
+        message: "maxTokens must be >= 1"
+      });
+    }
+  }
+  if (temperature != null) {
+    if (typeof temperature !== "number") {
+      throw new InvalidArgumentError({
+        parameter: "temperature",
+        value: temperature,
+        message: "temperature must be a number"
+      });
+    }
+  }
+  if (topP != null) {
+    if (typeof topP !== "number") {
+      throw new InvalidArgumentError({
+        parameter: "topP",
+        value: topP,
+        message: "topP must be a number"
+      });
+    }
+  }
+  if (presencePenalty != null) {
+    if (typeof presencePenalty !== "number") {
+      throw new InvalidArgumentError({
+        parameter: "presencePenalty",
+        value: presencePenalty,
+        message: "presencePenalty must be a number"
+      });
+    }
+  }
+  if (frequencyPenalty != null) {
+    if (typeof frequencyPenalty !== "number") {
+      throw new InvalidArgumentError({
+        parameter: "frequencyPenalty",
+        value: frequencyPenalty,
+        message: "frequencyPenalty must be a number"
+      });
+    }
+  }
+  if (seed != null) {
+    if (!Number.isInteger(seed)) {
+      throw new InvalidArgumentError({
+        parameter: "seed",
+        value: seed,
+        message: "seed must be an integer"
+      });
+    }
+  }
+  if (maxRetries != null) {
+    if (!Number.isInteger(maxRetries)) {
+      throw new InvalidArgumentError({
+        parameter: "maxRetries",
+        value: maxRetries,
+        message: "maxRetries must be an integer"
+      });
+    }
+    if (maxRetries < 0) {
+      throw new InvalidArgumentError({
+        parameter: "maxRetries",
+        value: maxRetries,
+        message: "maxRetries must be >= 0"
+      });
+    }
+  }
+  return {
+    maxTokens,
+    temperature: temperature != null ? temperature : 0,
+    topP,
+    presencePenalty,
+    frequencyPenalty,
+    seed,
+    maxRetries: maxRetries != null ? maxRetries : 2
+  };
+}
+
+// core/util/convert-zod-to-json-schema.ts
 import zodToJsonSchema from "zod-to-json-schema";
+function convertZodToJSONSchema(zodSchema) {
+  return zodToJsonSchema(zodSchema);
+}
+
+// core/util/retry-with-exponential-backoff.ts
+import { APICallError, RetryError } from "@ai-sdk/provider";
+import { getErrorMessage, isAbortError } from "@ai-sdk/provider-utils";
+
+// core/util/delay.ts
+async function delay(delayInMs) {
+  return new Promise((resolve) => setTimeout(resolve, delayInMs));
+}
+
+// core/util/retry-with-exponential-backoff.ts
+var retryWithExponentialBackoff = ({
+  maxRetries = 2,
+  initialDelayInMs = 2e3,
+  backoffFactor = 2
+} = {}) => async (f) => _retryWithExponentialBackoff(f, {
+  maxRetries,
+  delayInMs: initialDelayInMs,
+  backoffFactor
+});
+async function _retryWithExponentialBackoff(f, {
+  maxRetries,
+  delayInMs,
+  backoffFactor
+}, errors = []) {
+  try {
+    return await f();
+  } catch (error) {
+    if (isAbortError(error)) {
+      throw error;
+    }
+    if (maxRetries === 0) {
+      throw error;
+    }
+    const errorMessage = getErrorMessage(error);
+    const newErrors = [...errors, error];
+    const tryNumber = newErrors.length;
+    if (tryNumber > maxRetries) {
+      throw new RetryError({
+        message: `Failed after ${tryNumber} attempts. Last error: ${errorMessage}`,
+        reason: "maxRetriesExceeded",
+        errors: newErrors
+      });
+    }
+    if (error instanceof Error && APICallError.isAPICallError(error) && error.isRetryable === true && tryNumber <= maxRetries) {
+      await delay(delayInMs);
+      return _retryWithExponentialBackoff(
+        f,
+        { maxRetries, delayInMs: backoffFactor * delayInMs, backoffFactor },
+        newErrors
+      );
+    }
+    if (tryNumber === 1) {
+      throw error;
+    }
+    throw new RetryError({
+      message: `Failed after ${tryNumber} attempts with non-retryable error: '${errorMessage}'`,
+      reason: "errorNotRetryable",
+      errors: newErrors
+    });
+  }
+}
 
 // shared/stream-parts.ts
 var textStreamPart = {
@@ -1044,7 +1356,7 @@ function render(options) {
       return {
         name,
         description,
-        parameters: zodToJsonSchema(parameters)
+        parameters: zodToJsonSchema2(parameters)
       };
     }
   ) : void 0;
@@ -1055,7 +1367,7 @@ function render(options) {
         function: {
           name,
           description,
-          parameters: zodToJsonSchema(parameters)
+          parameters: zodToJsonSchema2(parameters)
         }
       };
     }
@@ -1166,6 +1478,194 @@ function render(options) {
   return ui.value;
 }
 
+// rsc/stream-ui/stream-ui.tsx
+import {
+  InvalidToolArgumentsError,
+  NoSuchToolError
+} from "@ai-sdk/provider";
+import { safeParseJSON } from "@ai-sdk/provider-utils";
+var defaultTextRenderer = ({ content }) => content;
+async function experimental_streamUI({
+  model,
+  tools,
+  system,
+  prompt,
+  messages,
+  maxRetries,
+  abortSignal,
+  initial,
+  text,
+  ...settings
+}) {
+  if (typeof model === "string") {
+    throw new Error(
+      "`model` cannot be a string in `experimental_streamUI`. Use the actual model instance instead."
+    );
+  }
+  if ("functions" in settings) {
+    throw new Error(
+      "`functions` is not supported in `experimental_streamUI`, use `tools` instead."
+    );
+  }
+  if ("provider" in settings) {
+    throw new Error(
+      "`provider` is no longer needed in `experimental_streamUI`. Use `model` instead."
+    );
+  }
+  if (tools) {
+    for (const [name, tool] of Object.entries(tools)) {
+      if ("render" in tool) {
+        throw new Error(
+          "Tool definition in `experimental_streamUI` should not have `render` property. Use `generate` instead. Found in tool: " + name
+        );
+      }
+    }
+  }
+  const ui = createStreamableUI(initial);
+  const textRender = text || defaultTextRenderer;
+  let finished;
+  async function handleRender(args, renderer, res) {
+    if (!renderer)
+      return;
+    const resolvable = createResolvablePromise();
+    if (finished) {
+      finished = finished.then(() => resolvable.promise);
+    } else {
+      finished = resolvable.promise;
+    }
+    const value = renderer(...args);
+    if (value instanceof Promise || value && typeof value === "object" && "then" in value && typeof value.then === "function") {
+      const node = await value;
+      res.update(node);
+      resolvable.resolve(void 0);
+    } else if (value && typeof value === "object" && Symbol.asyncIterator in value) {
+      const it = value;
+      while (true) {
+        const { done, value: value2 } = await it.next();
+        res.update(value2);
+        if (done)
+          break;
+      }
+      resolvable.resolve(void 0);
+    } else if (value && typeof value === "object" && Symbol.iterator in value) {
+      const it = value;
+      while (true) {
+        const { done, value: value2 } = it.next();
+        res.update(value2);
+        if (done)
+          break;
+      }
+      resolvable.resolve(void 0);
+    } else {
+      res.update(value);
+      resolvable.resolve(void 0);
+    }
+  }
+  const retry = retryWithExponentialBackoff({ maxRetries });
+  const validatedPrompt = getValidatedPrompt({ system, prompt, messages });
+  const result = await retry(
+    () => model.doStream({
+      mode: {
+        type: "regular",
+        tools: tools == null ? void 0 : Object.entries(tools).map(([name, tool]) => ({
+          type: "function",
+          name,
+          description: tool.description,
+          parameters: convertZodToJSONSchema(tool.parameters)
+        }))
+      },
+      ...prepareCallSettings(settings),
+      inputFormat: validatedPrompt.type,
+      prompt: convertToLanguageModelPrompt(validatedPrompt),
+      abortSignal
+    })
+  );
+  const [stream, forkedStream] = result.stream.tee();
+  (async () => {
+    try {
+      let content = "";
+      let hasToolCall = false;
+      const reader = forkedStream.getReader();
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        switch (value.type) {
+          case "text-delta": {
+            content += value.textDelta;
+            handleRender(
+              [{ content, done: false, delta: value.textDelta }],
+              textRender,
+              ui
+            );
+            break;
+          }
+          case "tool-call-delta": {
+            hasToolCall = true;
+            break;
+          }
+          case "tool-call": {
+            const toolName = value.toolName;
+            if (!tools) {
+              throw new NoSuchToolError({ toolName });
+            }
+            const tool = tools[toolName];
+            if (!tool) {
+              throw new NoSuchToolError({
+                toolName,
+                availableTools: Object.keys(tools)
+              });
+            }
+            const parseResult = safeParseJSON({
+              text: value.args,
+              schema: tool.parameters
+            });
+            if (parseResult.success === false) {
+              throw new InvalidToolArgumentsError({
+                toolName,
+                toolArgs: value.args,
+                cause: parseResult.error
+              });
+            }
+            handleRender(
+              [
+                parseResult.value,
+                {
+                  toolName,
+                  toolCallId: value.toolCallId
+                }
+              ],
+              tool.generate,
+              ui
+            );
+            break;
+          }
+          case "error": {
+            throw value.error;
+          }
+          case "finish": {
+          }
+        }
+      }
+      if (hasToolCall) {
+        await finished;
+        ui.done();
+      } else {
+        handleRender([{ content, done: true }], textRender, ui);
+        await finished;
+        ui.done();
+      }
+    } catch (error) {
+      ui.error(error);
+    }
+  })();
+  return {
+    ...result,
+    stream,
+    value: ui.value
+  };
+}
+
 // rsc/provider.tsx
 import * as React2 from "react";
 import { InternalAIProvider } from "./rsc-shared.mjs";
@@ -1239,6 +1739,7 @@ export {
   createAI,
   createStreamableUI,
   createStreamableValue,
+  experimental_streamUI,
   getAIState,
   getMutableAIState,
   render