ai 3.1.6 → 3.1.8

package/dist/index.mjs

@@ -4,6 +4,96 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// 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
+    });
+  }
+}
+
+// core/embed/embed.ts
+async function embed({
+  model,
+  value,
+  maxRetries,
+  abortSignal
+}) {
+  const retry = retryWithExponentialBackoff({ maxRetries });
+  const modelResponse = await retry(
+    () => model.doEmbed({
+      values: [value],
+      abortSignal
+    })
+  );
+  return new EmbedResult({
+    value,
+    embedding: modelResponse.embeddings[0],
+    rawResponse: modelResponse.rawResponse
+  });
+}
+var EmbedResult = class {
+  constructor(options) {
+    this.value = options.value;
+    this.embedding = options.embedding;
+    this.rawResponse = options.rawResponse;
+  }
+};
+
 // core/generate-object/generate-object.ts
 import { NoObjectGeneratedError } from "@ai-sdk/provider";
 import { safeParseJSON } from "@ai-sdk/provider-utils";
@@ -287,68 +377,6 @@ 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
-    });
-  }
-}
-
 // core/generate-object/inject-json-schema-into-system.ts
 var DEFAULT_SCHEMA_PREFIX = "JSON schema:";
 var DEFAULT_SCHEMA_SUFFIX = "You MUST answer with a JSON object that matches the JSON schema above.";
@@ -1491,8 +1519,65 @@ var StreamTextResult = class {
   
   @returns an `AIStream` object.
      */
-  toAIStream(callbacks) {
-    return this.textStream.pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(createStreamDataTransformer());
+  toAIStream(callbacks = {}) {
+    let aggregatedResponse = "";
+    const callbackTransformer = new TransformStream({
+      async start() {
+        if (callbacks.onStart)
+          await callbacks.onStart();
+      },
+      async transform(chunk, controller) {
+        controller.enqueue(chunk);
+        if (chunk.type === "text-delta") {
+          const textDelta = chunk.textDelta;
+          aggregatedResponse += textDelta;
+          if (callbacks.onToken)
+            await callbacks.onToken(textDelta);
+          if (callbacks.onText)
+            await callbacks.onText(textDelta);
+        }
+      },
+      async flush() {
+        if (callbacks.onCompletion)
+          await callbacks.onCompletion(aggregatedResponse);
+        if (callbacks.onFinal)
+          await callbacks.onFinal(aggregatedResponse);
+      }
+    });
+    const streamDataTransformer = new TransformStream({
+      transform: async (chunk, controller) => {
+        switch (chunk.type) {
+          case "text-delta":
+            controller.enqueue(formatStreamPart("text", chunk.textDelta));
+            break;
+          case "tool-call":
+            controller.enqueue(
+              formatStreamPart("tool_call", {
+                toolCallId: chunk.toolCallId,
+                toolName: chunk.toolName,
+                args: chunk.args
+              })
+            );
+            break;
+          case "tool-result":
+            controller.enqueue(
+              formatStreamPart("tool_result", {
+                toolCallId: chunk.toolCallId,
+                toolName: chunk.toolName,
+                args: chunk.args,
+                result: chunk.result
+              })
+            );
+            break;
+          case "error":
+            controller.enqueue(
+              formatStreamPart("error", JSON.stringify(chunk.error))
+            );
+            break;
+        }
+      }
+    });
+    return this.fullStream.pipeThrough(callbackTransformer).pipeThrough(streamDataTransformer).pipeThrough(new TextEncoderStream());
   }
   /**
   Writes stream data output to a Node.js response-like object.
@@ -1598,6 +1683,55 @@ var StreamTextResult = class {
 };
 var experimental_streamText = streamText;
 
+// core/prompt/convert-to-core-messages.ts
+function convertToCoreMessages(messages) {
+  const coreMessages = [];
+  for (const { role, content, toolInvocations } of messages) {
+    switch (role) {
+      case "user": {
+        coreMessages.push({ role: "user", content });
+        break;
+      }
+      case "assistant": {
+        if (toolInvocations == null) {
+          coreMessages.push({ role: "assistant", content });
+          break;
+        }
+        coreMessages.push({
+          role: "assistant",
+          content: [
+            { type: "text", text: content },
+            ...toolInvocations.map(({ toolCallId, toolName, args }) => ({
+              type: "tool-call",
+              toolCallId,
+              toolName,
+              args
+            }))
+          ]
+        });
+        coreMessages.push({
+          role: "tool",
+          content: toolInvocations.map(
+            ({ toolCallId, toolName, args, result }) => ({
+              type: "tool-result",
+              toolCallId,
+              toolName,
+              args,
+              result
+            })
+          )
+        });
+        break;
+      }
+      default: {
+        const _exhaustiveCheck = role;
+        throw new Error(`Unhandled role: ${_exhaustiveCheck}`);
+      }
+    }
+  }
+  return coreMessages;
+}
+
 // core/tool/tool.ts
 function tool(tool2) {
   return tool2;
@@ -1719,7 +1853,7 @@ var dataMessageStreamPart = {
     };
   }
 };
-var toolCallStreamPart = {
+var toolCallsStreamPart = {
   code: "7",
   name: "tool_calls",
   parse: (value) => {
@@ -1746,6 +1880,36 @@ var messageAnnotationsStreamPart = {
     return { type: "message_annotations", value };
   }
 };
+var toolCallStreamPart = {
+  code: "9",
+  name: "tool_call",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("toolCallId" in value) || typeof value.toolCallId !== "string" || !("toolName" in value) || typeof value.toolName !== "string" || !("args" in value) || typeof value.args !== "object") {
+      throw new Error(
+        '"tool_call" parts expect an object with a "toolCallId", "toolName", and "args" property.'
+      );
+    }
+    return {
+      type: "tool_call",
+      value
+    };
+  }
+};
+var toolResultStreamPart = {
+  code: "a",
+  name: "tool_result",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("toolCallId" in value) || typeof value.toolCallId !== "string" || !("toolName" in value) || typeof value.toolName !== "string" || !("args" in value) || typeof value.args !== "object" || !("result" in value)) {
+      throw new Error(
+        '"tool_result" parts expect an object with a "toolCallId", "toolName", "args", and "result" property.'
+      );
+    }
+    return {
+      type: "tool_result",
+      value
+    };
+  }
+};
 var streamParts = [
   textStreamPart,
   functionCallStreamPart,
@@ -1754,8 +1918,10 @@ var streamParts = [
   assistantMessageStreamPart,
   assistantControlDataStreamPart,
   dataMessageStreamPart,
+  toolCallsStreamPart,
+  messageAnnotationsStreamPart,
   toolCallStreamPart,
-  messageAnnotationsStreamPart
+  toolResultStreamPart
 ];
 var streamPartsByCode = {
   [textStreamPart.code]: textStreamPart,
@@ -1765,8 +1931,10 @@ var streamPartsByCode = {
   [assistantMessageStreamPart.code]: assistantMessageStreamPart,
   [assistantControlDataStreamPart.code]: assistantControlDataStreamPart,
   [dataMessageStreamPart.code]: dataMessageStreamPart,
+  [toolCallsStreamPart.code]: toolCallsStreamPart,
+  [messageAnnotationsStreamPart.code]: messageAnnotationsStreamPart,
   [toolCallStreamPart.code]: toolCallStreamPart,
-  [messageAnnotationsStreamPart.code]: messageAnnotationsStreamPart
+  [toolResultStreamPart.code]: toolResultStreamPart
 };
 var StreamStringPrefixes = {
   [textStreamPart.name]: textStreamPart.code,
@@ -1776,8 +1944,10 @@ var StreamStringPrefixes = {
   [assistantMessageStreamPart.name]: assistantMessageStreamPart.code,
   [assistantControlDataStreamPart.name]: assistantControlDataStreamPart.code,
   [dataMessageStreamPart.name]: dataMessageStreamPart.code,
+  [toolCallsStreamPart.name]: toolCallsStreamPart.code,
+  [messageAnnotationsStreamPart.name]: messageAnnotationsStreamPart.code,
   [toolCallStreamPart.name]: toolCallStreamPart.code,
-  [messageAnnotationsStreamPart.name]: messageAnnotationsStreamPart.code
+  [toolResultStreamPart.name]: toolResultStreamPart.code
 };
 var validCodes = streamParts.map((part) => part.code);
 var parseStreamPart = (line) => {
@@ -2882,6 +3052,40 @@ async function parseComplexResponse({
         };
       }
     }
+    if (type === "tool_call") {
+      if (prefixMap.text == null) {
+        prefixMap.text = {
+          id: generateId2(),
+          role: "assistant",
+          content: "",
+          createdAt
+        };
+      }
+      if (prefixMap.text.toolInvocations == null) {
+        prefixMap.text.toolInvocations = [];
+      }
+      prefixMap.text.toolInvocations.push(value);
+    } else if (type === "tool_result") {
+      if (prefixMap.text == null) {
+        prefixMap.text = {
+          id: generateId2(),
+          role: "assistant",
+          content: "",
+          createdAt
+        };
+      }
+      if (prefixMap.text.toolInvocations == null) {
+        prefixMap.text.toolInvocations = [];
+      }
+      const toolInvocationIndex = prefixMap.text.toolInvocations.findIndex(
+        (invocation) => invocation.toolCallId === value.toolCallId
+      );
+      if (toolInvocationIndex !== -1) {
+        prefixMap.text.toolInvocations[toolInvocationIndex] = value;
+      } else {
+        prefixMap.text.toolInvocations.push(value);
+      }
+    }
     let functionCallMessage = null;
     if (type === "function_call") {
       prefixMap["function_call"] = {
@@ -3044,6 +3248,7 @@ export {
   AnthropicStream,
   AssistantResponse,
   CohereStream,
+  EmbedResult,
   EmptyResponseBodyError,
   GenerateObjectResult,
   GenerateTextResult,
@@ -3075,10 +3280,12 @@ export {
   UnsupportedJSONSchemaError,
   convertDataContentToBase64String,
   convertDataContentToUint8Array,
+  convertToCoreMessages,
   createCallbacksTransformer,
   createChunkDecoder,
   createEventStreamTransformer,
   createStreamDataTransformer,
+  embed,
   experimental_AssistantResponse,
   experimental_StreamData,
   experimental_StreamingReactResponse,