ai 4.0.0-canary.2 → 4.0.0-canary.4

package/dist/index.mjs

@@ -6,12 +6,12 @@ var __export = (target, all) => {
 
 // streams/index.ts
 import {
-  formatStreamPart,
+  formatStreamPart as formatStreamPart4,
   parseStreamPart,
   readDataStream,
   processDataProtocolResponse
 } from "@ai-sdk/ui-utils";
-import { generateId as generateIdImpl } from "@ai-sdk/provider-utils";
+import { generateId as generateId2 } from "@ai-sdk/provider-utils";
 
 // core/index.ts
 import { jsonSchema } from "@ai-sdk/ui-utils";
@@ -1402,9 +1402,7 @@ function convertToCoreMessages(messages, options) {
         });
         break;
       }
-      case "function":
-      case "data":
-      case "tool": {
+      case "data": {
         break;
       }
       default: {
@@ -2299,7 +2297,6 @@ var DefaultGenerateObjectResult = class {
     });
   }
 };
-var experimental_generateObject = generateObject;
 
 // core/generate-object/stream-object.ts
 import { createIdGenerator as createIdGenerator2 } from "@ai-sdk/provider-utils";
@@ -2922,7 +2919,6 @@ var DefaultStreamObjectResult = class {
     });
   }
 };
-var experimental_streamObject = streamObject;
 
 // core/generate-text/generate-text.ts
 import { createIdGenerator as createIdGenerator3 } from "@ai-sdk/provider-utils";
@@ -2965,12 +2961,6 @@ var InvalidToolArgumentsError = class extends AISDKError8 {
   static isInstance(error) {
     return AISDKError8.hasMarker(error, marker8);
   }
-  /**
-   * @deprecated use `isInstance` instead
-   */
-  static isInvalidToolArgumentsError(error) {
-    return error instanceof Error && error.name === name8 && typeof error.toolName === "string" && typeof error.toolArgs === "string";
-  }
 };
 _a8 = symbol8;
 
@@ -3146,9 +3136,7 @@ async function generateText({
   maxRetries,
   abortSignal,
   headers,
-  maxAutomaticRoundtrips = 0,
-  maxToolRoundtrips = maxAutomaticRoundtrips,
-  maxSteps = maxToolRoundtrips != null ? maxToolRoundtrips + 1 : 1,
+  maxSteps = 1,
   experimental_continuationSteps,
   experimental_continueSteps: continueSteps = experimental_continuationSteps != null ? experimental_continuationSteps : false,
   experimental_telemetry: telemetry,
@@ -3516,7 +3504,6 @@ var DefaultGenerateTextResult = class {
     this.request = options.request;
     this.response = options.response;
     this.responseMessages = options.responseMessages;
-    this.roundtrips = options.steps;
     this.steps = options.steps;
     this.experimental_providerMetadata = options.providerMetadata;
     this.rawResponse = {
@@ -3525,10 +3512,10 @@ var DefaultGenerateTextResult = class {
     this.logprobs = options.logprobs;
   }
 };
-var experimental_generateText = generateText;
 
 // core/generate-text/stream-text.ts
 import { createIdGenerator as createIdGenerator4 } from "@ai-sdk/provider-utils";
+import { formatStreamPart } from "@ai-sdk/ui-utils";
 
 // core/util/create-stitchable-stream.ts
 function createStitchableStream() {
@@ -3885,8 +3872,7 @@ async function streamText({
   maxRetries,
   abortSignal,
   headers,
-  maxToolRoundtrips = 0,
-  maxSteps = maxToolRoundtrips != null ? maxToolRoundtrips + 1 : 1,
+  maxSteps = 1,
   experimental_continueSteps: continueSteps = false,
   experimental_telemetry: telemetry,
   experimental_providerMetadata: providerMetadata,
@@ -4532,37 +4518,18 @@ var DefaultStreamTextResult = class {
       }
     });
   }
-  toAIStream(callbacks = {}) {
-    return this.toDataStreamInternal({ callbacks });
-  }
   toDataStreamInternal({
-    callbacks = {},
     getErrorMessage: getErrorMessage3 = () => "",
     // mask error messages for safety by default
     sendUsage = true
   } = {}) {
     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);
+          aggregatedResponse += chunk.textDelta;
         }
-      },
-      async flush() {
-        if (callbacks.onCompletion)
-          await callbacks.onCompletion(aggregatedResponse);
-        if (callbacks.onFinal)
-          await callbacks.onFinal(aggregatedResponse);
       }
     });
     const streamPartsTransformer = new TransformStream({
@@ -4650,9 +4617,6 @@ var DefaultStreamTextResult = class {
     });
     return this.fullStream.pipeThrough(callbackTransformer).pipeThrough(streamPartsTransformer).pipeThrough(new TextEncoderStream());
   }
-  pipeAIStreamToResponse(response, init) {
-    return this.pipeDataStreamToResponse(response, init);
-  }
   pipeDataStreamToResponse(response, options) {
     const init = options == null ? void 0 : "init" in options ? options.init : {
       headers: "headers" in options ? options.headers : void 0,
@@ -4684,9 +4648,6 @@ var DefaultStreamTextResult = class {
       stream: this.textStream.pipeThrough(new TextEncoderStream())
     });
   }
-  toAIStreamResponse(options) {
-    return this.toDataStreamResponse(options);
-  }
   toDataStream(options) {
     const stream = this.toDataStreamInternal({
       getErrorMessage: options == null ? void 0 : options.getErrorMessage,
@@ -4726,7 +4687,6 @@ var DefaultStreamTextResult = class {
     });
   }
 };
-var experimental_streamText = streamText;
 
 // core/middleware/wrap-language-model.ts
 var experimental_wrapLanguageModel = ({
@@ -4913,123 +4873,6 @@ function magnitude(vector) {
   return Math.sqrt(dotProduct(vector, vector));
 }
 
-// streams/ai-stream.ts
-import {
-  createParser
-} from "eventsource-parser";
-function createEventStreamTransformer(customParser) {
-  const textDecoder = new TextDecoder();
-  let eventSourceParser;
-  return new TransformStream({
-    async start(controller) {
-      eventSourceParser = createParser(
-        (event) => {
-          if ("data" in event && event.type === "event" && event.data === "[DONE]" || // Replicate doesn't send [DONE] but does send a 'done' event
-          // @see https://replicate.com/docs/streaming
-          event.event === "done") {
-            controller.terminate();
-            return;
-          }
-          if ("data" in event) {
-            const parsedMessage = customParser ? customParser(event.data, {
-              event: event.event
-            }) : event.data;
-            if (parsedMessage)
-              controller.enqueue(parsedMessage);
-          }
-        }
-      );
-    },
-    transform(chunk) {
-      eventSourceParser.feed(textDecoder.decode(chunk));
-    }
-  });
-}
-function createCallbacksTransformer(cb) {
-  const textEncoder = new TextEncoder();
-  let aggregatedResponse = "";
-  const callbacks = cb || {};
-  return new TransformStream({
-    async start() {
-      if (callbacks.onStart)
-        await callbacks.onStart();
-    },
-    async transform(message, controller) {
-      const content = typeof message === "string" ? message : message.content;
-      controller.enqueue(textEncoder.encode(content));
-      aggregatedResponse += content;
-      if (callbacks.onToken)
-        await callbacks.onToken(content);
-      if (callbacks.onText && typeof message === "string") {
-        await callbacks.onText(message);
-      }
-    },
-    async flush() {
-      if (callbacks.onCompletion) {
-        await callbacks.onCompletion(aggregatedResponse);
-      }
-    }
-  });
-}
-function trimStartOfStreamHelper() {
-  let isStreamStart = true;
-  return (text) => {
-    if (isStreamStart) {
-      text = text.trimStart();
-      if (text)
-        isStreamStart = false;
-    }
-    return text;
-  };
-}
-function AIStream(response, customParser, callbacks) {
-  if (!response.ok) {
-    if (response.body) {
-      const reader = response.body.getReader();
-      return new ReadableStream({
-        async start(controller) {
-          const { done, value } = await reader.read();
-          if (!done) {
-            const errorText = new TextDecoder().decode(value);
-            controller.error(new Error(`Response error: ${errorText}`));
-          }
-        }
-      });
-    } else {
-      return new ReadableStream({
-        start(controller) {
-          controller.error(new Error("Response error: No response body"));
-        }
-      });
-    }
-  }
-  const responseBodyStream = response.body || createEmptyReadableStream();
-  return responseBodyStream.pipeThrough(createEventStreamTransformer(customParser)).pipeThrough(createCallbacksTransformer(callbacks));
-}
-function createEmptyReadableStream() {
-  return new ReadableStream({
-    start(controller) {
-      controller.close();
-    }
-  });
-}
-function readableFromAsyncIterable(iterable) {
-  let it = iterable[Symbol.asyncIterator]();
-  return new ReadableStream({
-    async pull(controller) {
-      const { done, value } = await it.next();
-      if (done)
-        controller.close();
-      else
-        controller.enqueue(value);
-    },
-    async cancel(reason) {
-      var _a11;
-      await ((_a11 = it.return) == null ? void 0 : _a11.call(it, reason));
-    }
-  });
-}
-
 // streams/assistant-response.ts
 import {
   formatStreamPart as formatStreamPart2
@@ -5135,6 +4978,32 @@ __export(langchain_adapter_exports, {
   toDataStreamResponse: () => toDataStreamResponse
 });
 
+// streams/stream-callbacks.ts
+function createCallbacksTransformer(callbacks = {}) {
+  const textEncoder = new TextEncoder();
+  let aggregatedResponse = "";
+  return new TransformStream({
+    async start() {
+      if (callbacks.onStart)
+        await callbacks.onStart();
+    },
+    async transform(message, controller) {
+      controller.enqueue(textEncoder.encode(message));
+      aggregatedResponse += message;
+      if (callbacks.onToken)
+        await callbacks.onToken(message);
+      if (callbacks.onText && typeof message === "string") {
+        await callbacks.onText(message);
+      }
+    },
+    async flush() {
+      if (callbacks.onCompletion) {
+        await callbacks.onCompletion(aggregatedResponse);
+      }
+    }
+  });
+}
+
 // streams/stream-data.ts
 import { formatStreamPart as formatStreamPart3 } from "@ai-sdk/ui-utils";
 
@@ -5142,7 +5011,7 @@ import { formatStreamPart as formatStreamPart3 } from "@ai-sdk/ui-utils";
 var HANGING_STREAM_WARNING_TIME_MS = 15 * 1e3;
 
 // streams/stream-data.ts
-var StreamData2 = class {
+var StreamData = class {
   constructor() {
     this.encoder = new TextEncoder();
     this.controller = null;
@@ -5213,7 +5082,7 @@ function createStreamDataTransformer() {
     }
   });
 }
-var experimental_StreamData = class extends StreamData2 {
+var experimental_StreamData = class extends StreamData {
 };
 
 // streams/langchain-adapter.ts
@@ -5277,8 +5146,16 @@ __export(llamaindex_adapter_exports, {
   toDataStream: () => toDataStream2,
   toDataStreamResponse: () => toDataStreamResponse2
 });
+import { convertAsyncIteratorToReadableStream } from "@ai-sdk/provider-utils";
 function toDataStream2(stream, callbacks) {
-  return toReadableStream(stream).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(createStreamDataTransformer());
+  const trimStart = trimStartOfStream();
+  return convertAsyncIteratorToReadableStream(stream[Symbol.asyncIterator]()).pipeThrough(
+    new TransformStream({
+      async transform(message, controller) {
+        controller.enqueue(trimStart(message.delta));
+      }
+    })
+  ).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(createStreamDataTransformer());
 }
 function toDataStreamResponse2(stream, options = {}) {
   var _a11;
@@ -5294,23 +5171,16 @@ function toDataStreamResponse2(stream, options = {}) {
     })
   });
 }
-function toReadableStream(res) {
-  const it = res[Symbol.asyncIterator]();
-  const trimStartOfStream = trimStartOfStreamHelper();
-  return new ReadableStream({
-    async pull(controller) {
-      var _a11;
-      const { value, done } = await it.next();
-      if (done) {
-        controller.close();
-        return;
-      }
-      const text = trimStartOfStream((_a11 = value.delta) != null ? _a11 : "");
-      if (text) {
-        controller.enqueue(text);
-      }
+function trimStartOfStream() {
+  let isStreamStart = true;
+  return (text) => {
+    if (isStreamStart) {
+      text = text.trimStart();
+      if (text)
+        isStreamStart = false;
     }
-  });
+    return text;
+  };
 }
 
 // streams/stream-to-response.ts
@@ -5354,12 +5224,8 @@ var StreamingTextResponse = class extends Response {
     });
   }
 };
-
-// streams/index.ts
-var generateId2 = generateIdImpl;
 export {
   AISDKError10 as AISDKError,
-  AIStream,
   APICallError2 as APICallError,
   AssistantResponse,
   DownloadError,
@@ -5381,14 +5247,12 @@ export {
   NoSuchProviderError,
   NoSuchToolError,
   RetryError,
-  StreamData2 as StreamData,
+  StreamData,
   StreamingTextResponse,
   TypeValidationError2 as TypeValidationError,
   UnsupportedFunctionalityError2 as UnsupportedFunctionalityError,
   convertToCoreMessages,
   cosineSimilarity,
-  createCallbacksTransformer,
-  createEventStreamTransformer,
   createStreamDataTransformer,
   embed,
   embedMany,
@@ -5397,12 +5261,8 @@ export {
   experimental_createModelRegistry,
   experimental_createProviderRegistry,
   experimental_customProvider,
-  experimental_generateObject,
-  experimental_generateText,
-  experimental_streamObject,
-  experimental_streamText,
   experimental_wrapLanguageModel,
-  formatStreamPart,
+  formatStreamPart4 as formatStreamPart,
   generateId2 as generateId,
   generateObject,
   generateText,
@@ -5410,11 +5270,9 @@ export {
   parseStreamPart,
   processDataProtocolResponse,
   readDataStream,
-  readableFromAsyncIterable,
   streamObject,
   streamText,
   streamToResponse,
-  tool,
-  trimStartOfStreamHelper
+  tool
 };
 //# sourceMappingURL=index.mjs.map