ai 2.2.32 → 2.2.34

package/dist/index.d.ts

@@ -352,6 +352,41 @@ type StreamString = `${(typeof StreamStringPrefixes)[keyof typeof StreamStringPr
  */
 declare const COMPLEX_HEADER = "X-Experimental-Stream-Data";
 
+declare interface AzureChatCompletions {
+    id: string;
+    created: Date;
+    choices: AzureChatChoice[];
+    systemFingerprint?: string;
+    usage?: AzureCompletionsUsage;
+    promptFilterResults: any[];
+}
+declare interface AzureChatChoice {
+    message?: AzureChatResponseMessage;
+    index: number;
+    finishReason: string | null;
+    delta?: AzureChatResponseMessage;
+}
+declare interface AzureChatResponseMessage {
+    role: string;
+    content: string | null;
+    toolCalls: AzureChatCompletionsFunctionToolCall[];
+    functionCall?: AzureFunctionCall;
+}
+declare interface AzureCompletionsUsage {
+    completionTokens: number;
+    promptTokens: number;
+    totalTokens: number;
+}
+declare interface AzureFunctionCall {
+    name: string;
+    arguments: string;
+}
+declare interface AzureChatCompletionsFunctionToolCall {
+    type: 'function';
+    function: AzureFunctionCall;
+    id: string;
+}
+
 type OpenAIStreamCallbacks = AIStreamCallbacksAndOptions & {
     /**
      * @example
@@ -536,7 +571,7 @@ interface CompletionUsage {
      */
     total_tokens: number;
 }
-type AsyncIterableOpenAIStreamReturnTypes = AsyncIterable<ChatCompletionChunk> | AsyncIterable<Completion>;
+type AsyncIterableOpenAIStreamReturnTypes = AsyncIterable<ChatCompletionChunk> | AsyncIterable<Completion> | AsyncIterable<AzureChatCompletions>;
 declare function OpenAIStream(res: Response | AsyncIterableOpenAIStreamReturnTypes, callbacks?: OpenAIStreamCallbacks): ReadableStream;
 
 interface FunctionCallPayload {
@@ -760,7 +795,11 @@ declare function AWSBedrockCohereStream(response: AWSBedrockResponse, callbacks?
 declare function AWSBedrockLlama2Stream(response: AWSBedrockResponse, callbacks?: AIStreamCallbacksAndOptions): ReadableStream;
 declare function AWSBedrockStream(response: AWSBedrockResponse, callbacks: AIStreamCallbacksAndOptions | undefined, extractTextDeltaFromChunk: (chunk: any) => string): ReadableStream<any>;
 
-declare function CohereStream(reader: Response, callbacks?: AIStreamCallbacksAndOptions): ReadableStream;
+interface StreamChunk {
+    text?: string;
+    eventType: 'stream-start' | 'search-queries-generation' | 'search-results' | 'text-generation' | 'citation-generation' | 'stream-end';
+}
+declare function CohereStream(reader: Response | AsyncIterable<StreamChunk>, callbacks?: AIStreamCallbacksAndOptions): ReadableStream;
 
 interface GenerateContentResponse {
     candidates?: GenerateContentCandidate[];

package/dist/index.js

@@ -402,10 +402,11 @@ var experimental_StreamData = class {
           controller.enqueue(encodedData);
         }
         if (self.messageAnnotations.length) {
-          const encodedmessageAnnotations = self.encoder.encode(
+          const encodedMessageAnnotations = self.encoder.encode(
             formatStreamPart("message_annotations", self.messageAnnotations)
           );
-          controller.enqueue(encodedmessageAnnotations);
+          self.messageAnnotations = [];
+          controller.enqueue(encodedMessageAnnotations);
         }
         controller.enqueue(chunk);
       },
@@ -660,14 +661,29 @@ function createParser2(res) {
     }
   });
 }
+async function* streamable2(stream) {
+  for await (const chunk of stream) {
+    if (chunk.eventType === "text-generation") {
+      const text = chunk.text;
+      if (text)
+        yield text;
+    }
+  }
+}
 function CohereStream(reader, callbacks) {
-  return createParser2(reader).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(
-    createStreamDataTransformer(callbacks == null ? void 0 : callbacks.experimental_streamData)
-  );
+  if (Symbol.asyncIterator in reader) {
+    return readableFromAsyncIterable(streamable2(reader)).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(
+      createStreamDataTransformer(callbacks == null ? void 0 : callbacks.experimental_streamData)
+    );
+  } else {
+    return createParser2(reader).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(
+      createStreamDataTransformer(callbacks == null ? void 0 : callbacks.experimental_streamData)
+    );
+  }
 }
 
 // streams/google-generative-ai-stream.ts
-async function* streamable2(response) {
+async function* streamable3(response) {
   var _a, _b, _c;
   for await (const chunk of response.stream) {
     const parts = (_c = (_b = (_a = chunk.candidates) == null ? void 0 : _a[0]) == null ? void 0 : _b.content) == null ? void 0 : _c.parts;
@@ -681,7 +697,7 @@ async function* streamable2(response) {
   }
 }
 function GoogleGenerativeAIStream(response, cb) {
-  return readableFromAsyncIterable(streamable2(response)).pipeThrough(createCallbacksTransformer(cb)).pipeThrough(createStreamDataTransformer(cb == null ? void 0 : cb.experimental_streamData));
+  return readableFromAsyncIterable(streamable3(response)).pipeThrough(createCallbacksTransformer(cb)).pipeThrough(createStreamDataTransformer(cb == null ? void 0 : cb.experimental_streamData));
 }
 
 // streams/huggingface-stream.ts
@@ -780,9 +796,37 @@ function parseOpenAIStream() {
   const extract = chunkToText();
   return (data) => extract(JSON.parse(data));
 }
-async function* streamable3(stream) {
+async function* streamable4(stream) {
   const extract = chunkToText();
-  for await (const chunk of stream) {
+  for await (let chunk of stream) {
+    if ("promptFilterResults" in chunk) {
+      chunk = {
+        id: chunk.id,
+        created: chunk.created.getDate(),
+        object: chunk.object,
+        // not exposed by Azure API
+        model: chunk.model,
+        // not exposed by Azure API
+        choices: chunk.choices.map((choice) => {
+          var _a, _b, _c, _d, _e, _f, _g;
+          return {
+            delta: {
+              content: (_a = choice.delta) == null ? void 0 : _a.content,
+              function_call: (_b = choice.delta) == null ? void 0 : _b.functionCall,
+              role: (_c = choice.delta) == null ? void 0 : _c.role,
+              tool_calls: ((_e = (_d = choice.delta) == null ? void 0 : _d.toolCalls) == null ? void 0 : _e.length) ? (_g = (_f = choice.delta) == null ? void 0 : _f.toolCalls) == null ? void 0 : _g.map((toolCall, index) => ({
+                index,
+                id: toolCall.id,
+                function: toolCall.function,
+                type: toolCall.type
+              })) : void 0
+            },
+            finish_reason: choice.finishReason,
+            index: choice.index
+          };
+        })
+      };
+    }
     const text = extract(chunk);
     if (text)
       yield text;
@@ -841,7 +885,7 @@ function OpenAIStream(res, callbacks) {
   const cb = callbacks;
   let stream;
   if (Symbol.asyncIterator in res) {
-    stream = readableFromAsyncIterable(streamable3(res)).pipeThrough(
+    stream = readableFromAsyncIterable(streamable4(res)).pipeThrough(
       createCallbacksTransformer(
         (cb == null ? void 0 : cb.experimental_onFunctionCall) || (cb == null ? void 0 : cb.experimental_onToolCall) ? {
           ...cb,
@@ -1112,6 +1156,11 @@ async function* readDataStream(reader, {
 }
 
 // shared/parse-complex-response.ts
+function assignAnnotationsToMessage(message, annotations) {
+  if (!message || !annotations || !annotations.length)
+    return message;
+  return { ...message, annotations: [...annotations] };
+}
 async function parseComplexResponse({
   reader,
   abortControllerRef,
@@ -1124,6 +1173,7 @@ async function parseComplexResponse({
   const prefixMap = {
     data: []
   };
+  let message_annotations = void 0;
   for await (const { type, value } of readDataStream(reader, {
     isAborted: () => (abortControllerRef == null ? void 0 : abortControllerRef.current) === null
   })) {
@@ -1142,22 +1192,6 @@ async function parseComplexResponse({
         };
       }
     }
-    if (type == "message_annotations") {
-      if (prefixMap["text"]) {
-        prefixMap["text"] = {
-          ...prefixMap["text"],
-          annotations: [...prefixMap["text"].annotations || [], ...value]
-        };
-      } else {
-        prefixMap["text"] = {
-          id: generateId(),
-          role: "assistant",
-          content: "",
-          annotations: [...value],
-          createdAt
-        };
-      }
-    }
     let functionCallMessage = null;
     if (type === "function_call") {
       prefixMap["function_call"] = {
@@ -1184,12 +1218,41 @@ async function parseComplexResponse({
     if (type === "data") {
       prefixMap["data"].push(...value);
     }
-    const responseMessage = prefixMap["text"];
-    const merged = [
-      functionCallMessage,
-      toolCallMessage,
-      responseMessage
-    ].filter(Boolean);
+    let responseMessage = prefixMap["text"];
+    if (type === "message_annotations") {
+      if (!message_annotations) {
+        message_annotations = [...value];
+      } else {
+        message_annotations.push(...value);
+      }
+      functionCallMessage = assignAnnotationsToMessage(
+        prefixMap["function_call"],
+        message_annotations
+      );
+      toolCallMessage = assignAnnotationsToMessage(
+        prefixMap["tool_calls"],
+        message_annotations
+      );
+      responseMessage = assignAnnotationsToMessage(
+        prefixMap["text"],
+        message_annotations
+      );
+    }
+    if (message_annotations == null ? void 0 : message_annotations.length) {
+      const messagePrefixKeys = [
+        "text",
+        "function_call",
+        "tool_calls"
+      ];
+      messagePrefixKeys.forEach((key) => {
+        if (prefixMap[key]) {
+          prefixMap[key].annotations = [...message_annotations];
+        }
+      });
+    }
+    const merged = [functionCallMessage, toolCallMessage, responseMessage].filter(Boolean).map((message) => ({
+      ...assignAnnotationsToMessage(message, message_annotations)
+    }));
     update(merged, [...prefixMap["data"]]);
   }
   onFinish == null ? void 0 : onFinish(prefixMap);