ai 2.1.18 → 2.1.20

package/dist/index.d.ts

@@ -1,7 +1,11 @@
-import { ServerResponse } from 'node:http';
 import { ChatCompletionRequestMessageFunctionCall, CreateChatCompletionRequestFunctionCall } from 'openai-edge';
 import { ChatCompletionFunctions } from 'openai-edge/types/api';
+import { ServerResponse } from 'node:http';
 
+interface FunctionCallPayload {
+    name: string;
+    arguments: Record<string, unknown>;
+}
 /**
  * Helper callback methods for AIStream stream lifecycle events
  * @interface
@@ -81,44 +85,6 @@ declare function trimStartOfStreamHelper(): (text: string) => string;
  */
 declare function AIStream(response: Response, customParser: AIStreamParser, callbacks?: AIStreamCallbacks): ReadableStream;
 
-declare function OpenAIStream(res: Response, cb?: AIStreamCallbacks): ReadableStream;
-
-/**
- * A utility class for streaming text responses.
- */
-declare class StreamingTextResponse extends Response {
-    constructor(res: ReadableStream, init?: ResponseInit);
-}
-/**
- * A utility function to stream a ReadableStream to a Node.js response-like object.
- */
-declare function streamToResponse(res: ReadableStream, response: ServerResponse, init?: {
-    headers?: Record<string, string>;
-    status?: number;
-}): void;
-
-declare function HuggingFaceStream(res: AsyncGenerator<any>, callbacks?: AIStreamCallbacks): ReadableStream;
-
-declare function CohereStream(reader: Response, callbacks?: AIStreamCallbacks): ReadableStream;
-
-declare function AnthropicStream(res: Response, cb?: AIStreamCallbacks): ReadableStream;
-
-declare function LangChainStream(callbacks?: AIStreamCallbacks): {
-    stream: ReadableStream<Uint8Array>;
-    handlers: {
-        handleLLMNewToken: (token: string) => Promise<void>;
-        handleLLMStart: (_llm: any, _prompts: string[], runId: string) => Promise<void>;
-        handleLLMEnd: (_output: any, runId: string) => Promise<void>;
-        handleLLMError: (e: Error, runId: string) => Promise<void>;
-        handleChainStart: (_chain: any, _inputs: any, runId: string) => Promise<void>;
-        handleChainEnd: (_outputs: any, runId: string) => Promise<void>;
-        handleChainError: (e: Error, runId: string) => Promise<void>;
-        handleToolStart: (_tool: any, _input: string, runId: string) => Promise<void>;
-        handleToolEnd: (_output: string, runId: string) => Promise<void>;
-        handleToolError: (e: Error, runId: string) => Promise<void>;
-    };
-};
-
 /**
  * Shared types between the API and UI packages.
  */
@@ -283,7 +249,78 @@ type UseCompletionOptions = {
     body?: object;
 };
 
+type JSONValue = null | string | number | boolean | {
+    [x: string]: JSONValue;
+} | Array<JSONValue>;
+type OpenAIStreamCallbacks = AIStreamCallbacks & {
+    /**
+     * @example
+     * ```js
+     * const response = await openai.createChatCompletion({
+     *   model: 'gpt-3.5-turbo-0613',
+     *   stream: true,
+     *   messages,
+     *   functions,
+     * })
+     *
+     * const stream = OpenAIStream(response, {
+     *   experimental_onFunctionCall: async (functionCallPayload, createFunctionCallMessages) => {
+     *     // ... run your custom logic here
+     *     const result = await myFunction(functionCallPayload)
+     *
+     *     // Ask for another completion, or return a string to send to the client as an assistant message.
+     *     return await openai.createChatCompletion({
+     *       model: 'gpt-3.5-turbo-0613',
+     *       stream: true,
+     *       // Append the relevant "assistant" and "function" call messages
+     *       messages: [...messages, ...createFunctionCallMessages(result)],
+     *       functions,
+     *     })
+     *   }
+     * })
+     * ```
+     */
+    experimental_onFunctionCall?: (functionCallPayload: FunctionCallPayload, createFunctionCallMessages: (functionCallResult: JSONValue) => CreateMessage[]) => Promise<Response | undefined | void | string>;
+};
+declare function OpenAIStream(res: Response, callbacks?: OpenAIStreamCallbacks): ReadableStream;
+
+/**
+ * A utility class for streaming text responses.
+ */
+declare class StreamingTextResponse extends Response {
+    constructor(res: ReadableStream, init?: ResponseInit);
+}
+/**
+ * A utility function to stream a ReadableStream to a Node.js response-like object.
+ */
+declare function streamToResponse(res: ReadableStream, response: ServerResponse, init?: {
+    headers?: Record<string, string>;
+    status?: number;
+}): void;
+
+declare function HuggingFaceStream(res: AsyncGenerator<any>, callbacks?: AIStreamCallbacks): ReadableStream;
+
+declare function CohereStream(reader: Response, callbacks?: AIStreamCallbacks): ReadableStream;
+
+declare function AnthropicStream(res: Response, cb?: AIStreamCallbacks): ReadableStream;
+
+declare function LangChainStream(callbacks?: AIStreamCallbacks): {
+    stream: ReadableStream<Uint8Array>;
+    handlers: {
+        handleLLMNewToken: (token: string) => Promise<void>;
+        handleLLMStart: (_llm: any, _prompts: string[], runId: string) => Promise<void>;
+        handleLLMEnd: (_output: any, runId: string) => Promise<void>;
+        handleLLMError: (e: Error, runId: string) => Promise<void>;
+        handleChainStart: (_chain: any, _inputs: any, runId: string) => Promise<void>;
+        handleChainEnd: (_outputs: any, runId: string) => Promise<void>;
+        handleChainError: (e: Error, runId: string) => Promise<void>;
+        handleToolStart: (_tool: any, _input: string, runId: string) => Promise<void>;
+        handleToolEnd: (_output: string, runId: string) => Promise<void>;
+        handleToolError: (e: Error, runId: string) => Promise<void>;
+    };
+};
+
 declare const nanoid: (size?: number | undefined) => string;
 declare function createChunkDecoder(): (chunk: Uint8Array | undefined) => string;
 
-export { AIStream, AIStreamCallbacks, AIStreamParser, AnthropicStream, ChatRequest, ChatRequestOptions, CohereStream, CreateMessage, FunctionCallHandler, HuggingFaceStream, LangChainStream, Message, OpenAIStream, RequestOptions, StreamingTextResponse, UseChatOptions, UseCompletionOptions, createCallbacksTransformer, createChunkDecoder, createEventStreamTransformer, nanoid, streamToResponse, trimStartOfStreamHelper };
+export { AIStream, AIStreamCallbacks, AIStreamParser, AnthropicStream, ChatRequest, ChatRequestOptions, CohereStream, CreateMessage, FunctionCallHandler, FunctionCallPayload, HuggingFaceStream, LangChainStream, Message, OpenAIStream, OpenAIStreamCallbacks, RequestOptions, StreamingTextResponse, UseChatOptions, UseCompletionOptions, createCallbacksTransformer, createChunkDecoder, createEventStreamTransformer, nanoid, streamToResponse, trimStartOfStreamHelper };

package/dist/index.js

@@ -196,8 +196,94 @@ function parseOpenAIStream() {
     return text;
   };
 }
-function OpenAIStream(res, cb) {
-  return AIStream(res, parseOpenAIStream(), cb);
+var __internal__OpenAIFnMessagesSymbol = Symbol("internal_openai_fn_messages");
+function OpenAIStream(res, callbacks) {
+  const cb = callbacks;
+  const stream = AIStream(res, parseOpenAIStream(), cb);
+  if (cb && cb.experimental_onFunctionCall) {
+    const functionCallTransformer = createFunctionCallTransformer(cb);
+    return stream.pipeThrough(functionCallTransformer);
+  } else {
+    return stream;
+  }
+}
+function createFunctionCallTransformer(callbacks) {
+  const textEncoder = new TextEncoder();
+  let isFirstChunk = true;
+  let aggregatedResponse = "";
+  let isFunctionStreamingIn = false;
+  let functionCallMessages = callbacks[__internal__OpenAIFnMessagesSymbol] || [];
+  return new TransformStream({
+    transform(chunk, controller) {
+      return __async(this, null, function* () {
+        const message = new TextDecoder().decode(chunk);
+        const shouldHandleAsFunction = isFirstChunk && message.startsWith('{"function_call":');
+        if (shouldHandleAsFunction) {
+          isFunctionStreamingIn = true;
+          aggregatedResponse += message;
+          isFirstChunk = false;
+          return;
+        }
+        if (!isFunctionStreamingIn) {
+          controller.enqueue(chunk);
+          return;
+        } else {
+          aggregatedResponse += message;
+        }
+      });
+    },
+    flush(controller) {
+      return __async(this, null, function* () {
+        const isEndOfFunction = !isFirstChunk && callbacks.experimental_onFunctionCall && isFunctionStreamingIn;
+        if (isEndOfFunction && callbacks.experimental_onFunctionCall) {
+          isFunctionStreamingIn = false;
+          const payload = JSON.parse(aggregatedResponse);
+          const argumentsPayload = JSON.parse(payload.function_call.arguments);
+          let newFunctionCallMessages = [...functionCallMessages];
+          const functionResponse = yield callbacks.experimental_onFunctionCall(
+            {
+              name: payload.function_call.name,
+              arguments: argumentsPayload
+            },
+            (result) => {
+              newFunctionCallMessages = [
+                ...functionCallMessages,
+                {
+                  role: "assistant",
+                  content: "",
+                  function_call: payload.function_call
+                },
+                {
+                  role: "function",
+                  name: payload.function_call.name,
+                  content: JSON.stringify(result)
+                }
+              ];
+              return newFunctionCallMessages;
+            }
+          );
+          if (!functionResponse) {
+            controller.enqueue(textEncoder.encode(aggregatedResponse));
+            return;
+          } else if (typeof functionResponse === "string") {
+            controller.enqueue(textEncoder.encode(functionResponse));
+            return;
+          }
+          const openAIStream = OpenAIStream(functionResponse, __spreadProps(__spreadValues({}, callbacks), {
+            [__internal__OpenAIFnMessagesSymbol]: newFunctionCallMessages
+          }));
+          const reader = openAIStream.getReader();
+          while (true) {
+            const { done, value } = yield reader.read();
+            if (done) {
+              break;
+            }
+            controller.enqueue(value);
+          }
+        }
+      });
+    }
+  });
 }
 
 // streams/streaming-text-response.ts

package/dist/index.mjs

@@ -163,8 +163,94 @@ function parseOpenAIStream() {
     return text;
   };
 }
-function OpenAIStream(res, cb) {
-  return AIStream(res, parseOpenAIStream(), cb);
+var __internal__OpenAIFnMessagesSymbol = Symbol("internal_openai_fn_messages");
+function OpenAIStream(res, callbacks) {
+  const cb = callbacks;
+  const stream = AIStream(res, parseOpenAIStream(), cb);
+  if (cb && cb.experimental_onFunctionCall) {
+    const functionCallTransformer = createFunctionCallTransformer(cb);
+    return stream.pipeThrough(functionCallTransformer);
+  } else {
+    return stream;
+  }
+}
+function createFunctionCallTransformer(callbacks) {
+  const textEncoder = new TextEncoder();
+  let isFirstChunk = true;
+  let aggregatedResponse = "";
+  let isFunctionStreamingIn = false;
+  let functionCallMessages = callbacks[__internal__OpenAIFnMessagesSymbol] || [];
+  return new TransformStream({
+    transform(chunk, controller) {
+      return __async(this, null, function* () {
+        const message = new TextDecoder().decode(chunk);
+        const shouldHandleAsFunction = isFirstChunk && message.startsWith('{"function_call":');
+        if (shouldHandleAsFunction) {
+          isFunctionStreamingIn = true;
+          aggregatedResponse += message;
+          isFirstChunk = false;
+          return;
+        }
+        if (!isFunctionStreamingIn) {
+          controller.enqueue(chunk);
+          return;
+        } else {
+          aggregatedResponse += message;
+        }
+      });
+    },
+    flush(controller) {
+      return __async(this, null, function* () {
+        const isEndOfFunction = !isFirstChunk && callbacks.experimental_onFunctionCall && isFunctionStreamingIn;
+        if (isEndOfFunction && callbacks.experimental_onFunctionCall) {
+          isFunctionStreamingIn = false;
+          const payload = JSON.parse(aggregatedResponse);
+          const argumentsPayload = JSON.parse(payload.function_call.arguments);
+          let newFunctionCallMessages = [...functionCallMessages];
+          const functionResponse = yield callbacks.experimental_onFunctionCall(
+            {
+              name: payload.function_call.name,
+              arguments: argumentsPayload
+            },
+            (result) => {
+              newFunctionCallMessages = [
+                ...functionCallMessages,
+                {
+                  role: "assistant",
+                  content: "",
+                  function_call: payload.function_call
+                },
+                {
+                  role: "function",
+                  name: payload.function_call.name,
+                  content: JSON.stringify(result)
+                }
+              ];
+              return newFunctionCallMessages;
+            }
+          );
+          if (!functionResponse) {
+            controller.enqueue(textEncoder.encode(aggregatedResponse));
+            return;
+          } else if (typeof functionResponse === "string") {
+            controller.enqueue(textEncoder.encode(functionResponse));
+            return;
+          }
+          const openAIStream = OpenAIStream(functionResponse, __spreadProps(__spreadValues({}, callbacks), {
+            [__internal__OpenAIFnMessagesSymbol]: newFunctionCallMessages
+          }));
+          const reader = openAIStream.getReader();
+          while (true) {
+            const { done, value } = yield reader.read();
+            if (done) {
+              break;
+            }
+            controller.enqueue(value);
+          }
+        }
+      });
+    }
+  });
 }
 
 // streams/streaming-text-response.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "2.1.18",
+  "version": "2.1.20",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",