ai 3.4.33 → 4.0.0-canary.1

package/rsc/dist/rsc-server.mjs

@@ -1516,13 +1516,13 @@ function createStreamableUI(initialValue) {
     }
   }
   warnUnclosedStream();
-  const streamable2 = {
+  const streamable = {
     value: row,
     update(value) {
       assertStream(".update()");
       if (value === currentValue) {
         warnUnclosedStream();
-        return streamable2;
+        return streamable;
       }
       const resolvable = createResolvablePromise();
       currentValue = value;
@@ -1530,7 +1530,7 @@ function createStreamableUI(initialValue) {
       resolve = resolvable.resolve;
       reject = resolvable.reject;
       warnUnclosedStream();
-      return streamable2;
+      return streamable;
     },
     append(value) {
       assertStream(".append()");
@@ -1540,7 +1540,7 @@ function createStreamableUI(initialValue) {
       resolve = resolvable.resolve;
       reject = resolvable.reject;
       warnUnclosedStream();
-      return streamable2;
+      return streamable;
     },
     error(error) {
       assertStream(".error()");
@@ -1549,7 +1549,7 @@ function createStreamableUI(initialValue) {
       }
       closed = true;
       reject(error);
-      return streamable2;
+      return streamable;
     },
     done(...args) {
       assertStream(".done()");
@@ -1559,13 +1559,13 @@ function createStreamableUI(initialValue) {
       closed = true;
       if (args.length) {
         resolve({ value: args[0], done: true });
-        return streamable2;
+        return streamable;
       }
       resolve({ value: currentValue, done: true });
-      return streamable2;
+      return streamable;
     }
   };
-  return streamable2;
+  return streamable;
 }
 
 // rsc/stream-ui/stream-ui.tsx
@@ -1614,7 +1614,7 @@ async function streamUI({
   const textRender = text || defaultTextRenderer;
   let finished;
   let finishEvent = null;
-  async function render2({
+  async function render({
     args,
     renderer,
     streamableUI,
@@ -1688,7 +1688,7 @@ async function streamUI({
         switch (value.type) {
           case "text-delta": {
             content += value.textDelta;
-            render2({
+            render({
               renderer: textRender,
               args: [{ content, done: false, delta: value.textDelta }],
               streamableUI: ui
@@ -1723,7 +1723,7 @@ async function streamUI({
                 cause: parseResult.error
               });
             }
-            render2({
+            render({
               renderer: tool.generate,
               args: [
                 parseResult.value,
@@ -1752,7 +1752,7 @@ async function streamUI({
         }
       }
       if (!hasToolCall) {
-        render2({
+        render({
           renderer: textRender,
           args: [{ content, done: true }],
           streamableUI: ui,
@@ -1777,609 +1777,6 @@ async function streamUI({
   };
 }
 
-// rsc/stream-ui/render.ts
-import zodToJsonSchema from "zod-to-json-schema";
-
-// 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() {
-      const isOpenAICallbacks = isOfTypeOpenAIStreamCallbacks(callbacks);
-      if (callbacks.onCompletion) {
-        await callbacks.onCompletion(aggregatedResponse);
-      }
-      if (callbacks.onFinal && !isOpenAICallbacks) {
-        await callbacks.onFinal(aggregatedResponse);
-      }
-    }
-  });
-}
-function isOfTypeOpenAIStreamCallbacks(callbacks) {
-  return "experimental_onFunctionCall" in callbacks;
-}
-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 _a9;
-      await ((_a9 = it.return) == null ? void 0 : _a9.call(it, reason));
-    }
-  });
-}
-
-// streams/stream-data.ts
-import { formatStreamPart } from "@ai-sdk/ui-utils";
-function createStreamDataTransformer() {
-  const encoder = new TextEncoder();
-  const decoder = new TextDecoder();
-  return new TransformStream({
-    transform: async (chunk, controller) => {
-      const message = decoder.decode(chunk);
-      controller.enqueue(encoder.encode(formatStreamPart("text", message)));
-    }
-  });
-}
-
-// streams/openai-stream.ts
-import {
-  createChunkDecoder,
-  formatStreamPart as formatStreamPart2
-} from "@ai-sdk/ui-utils";
-function parseOpenAIStream() {
-  const extract = chunkToText();
-  return (data) => extract(JSON.parse(data));
-}
-async function* streamable(stream) {
-  const extract = chunkToText();
-  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 _a9, _b, _c, _d, _e, _f, _g;
-          return {
-            delta: {
-              content: (_a9 = choice.delta) == null ? void 0 : _a9.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;
-  }
-}
-function chunkToText() {
-  const trimStartOfStream = trimStartOfStreamHelper();
-  let isFunctionStreamingIn;
-  return (json) => {
-    var _a9, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r;
-    if (isChatCompletionChunk(json)) {
-      const delta = (_a9 = json.choices[0]) == null ? void 0 : _a9.delta;
-      if ((_b = delta.function_call) == null ? void 0 : _b.name) {
-        isFunctionStreamingIn = true;
-        return {
-          isText: false,
-          content: `{"function_call": {"name": "${delta.function_call.name}", "arguments": "`
-        };
-      } else if ((_e = (_d = (_c = delta.tool_calls) == null ? void 0 : _c[0]) == null ? void 0 : _d.function) == null ? void 0 : _e.name) {
-        isFunctionStreamingIn = true;
-        const toolCall = delta.tool_calls[0];
-        if (toolCall.index === 0) {
-          return {
-            isText: false,
-            content: `{"tool_calls":[ {"id": "${toolCall.id}", "type": "function", "function": {"name": "${(_f = toolCall.function) == null ? void 0 : _f.name}", "arguments": "`
-          };
-        } else {
-          return {
-            isText: false,
-            content: `"}}, {"id": "${toolCall.id}", "type": "function", "function": {"name": "${(_g = toolCall.function) == null ? void 0 : _g.name}", "arguments": "`
-          };
-        }
-      } else if ((_h = delta.function_call) == null ? void 0 : _h.arguments) {
-        return {
-          isText: false,
-          content: cleanupArguments((_i = delta.function_call) == null ? void 0 : _i.arguments)
-        };
-      } else if ((_l = (_k = (_j = delta.tool_calls) == null ? void 0 : _j[0]) == null ? void 0 : _k.function) == null ? void 0 : _l.arguments) {
-        return {
-          isText: false,
-          content: cleanupArguments((_o = (_n = (_m = delta.tool_calls) == null ? void 0 : _m[0]) == null ? void 0 : _n.function) == null ? void 0 : _o.arguments)
-        };
-      } else if (isFunctionStreamingIn && (((_p = json.choices[0]) == null ? void 0 : _p.finish_reason) === "function_call" || ((_q = json.choices[0]) == null ? void 0 : _q.finish_reason) === "stop")) {
-        isFunctionStreamingIn = false;
-        return {
-          isText: false,
-          content: '"}}'
-        };
-      } else if (isFunctionStreamingIn && ((_r = json.choices[0]) == null ? void 0 : _r.finish_reason) === "tool_calls") {
-        isFunctionStreamingIn = false;
-        return {
-          isText: false,
-          content: '"}}]}'
-        };
-      }
-    }
-    const text = trimStartOfStream(
-      isChatCompletionChunk(json) && json.choices[0].delta.content ? json.choices[0].delta.content : isCompletion(json) ? json.choices[0].text : ""
-    );
-    return text;
-  };
-  function cleanupArguments(argumentChunk) {
-    let escapedPartialJson = argumentChunk.replace(/\\/g, "\\\\").replace(/\//g, "\\/").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t").replace(/\f/g, "\\f");
-    return `${escapedPartialJson}`;
-  }
-}
-var __internal__OpenAIFnMessagesSymbol = Symbol(
-  "internal_openai_fn_messages"
-);
-function isChatCompletionChunk(data) {
-  return "choices" in data && data.choices && data.choices[0] && "delta" in data.choices[0];
-}
-function isCompletion(data) {
-  return "choices" in data && data.choices && data.choices[0] && "text" in data.choices[0];
-}
-function OpenAIStream(res, callbacks) {
-  const cb = callbacks;
-  let stream;
-  if (Symbol.asyncIterator in res) {
-    stream = readableFromAsyncIterable(streamable(res)).pipeThrough(
-      createCallbacksTransformer(
-        (cb == null ? void 0 : cb.experimental_onFunctionCall) || (cb == null ? void 0 : cb.experimental_onToolCall) ? {
-          ...cb,
-          onFinal: void 0
-        } : {
-          ...cb
-        }
-      )
-    );
-  } else {
-    stream = AIStream(
-      res,
-      parseOpenAIStream(),
-      (cb == null ? void 0 : cb.experimental_onFunctionCall) || (cb == null ? void 0 : cb.experimental_onToolCall) ? {
-        ...cb,
-        onFinal: void 0
-      } : {
-        ...cb
-      }
-    );
-  }
-  if (cb && (cb.experimental_onFunctionCall || cb.experimental_onToolCall)) {
-    const functionCallTransformer = createFunctionCallTransformer(cb);
-    return stream.pipeThrough(functionCallTransformer);
-  } else {
-    return stream.pipeThrough(createStreamDataTransformer());
-  }
-}
-function createFunctionCallTransformer(callbacks) {
-  const textEncoder = new TextEncoder();
-  let isFirstChunk = true;
-  let aggregatedResponse = "";
-  let aggregatedFinalCompletionResponse = "";
-  let isFunctionStreamingIn = false;
-  let functionCallMessages = callbacks[__internal__OpenAIFnMessagesSymbol] || [];
-  const decode = createChunkDecoder();
-  return new TransformStream({
-    async transform(chunk, controller) {
-      const message = decode(chunk);
-      aggregatedFinalCompletionResponse += message;
-      const shouldHandleAsFunction = isFirstChunk && (message.startsWith('{"function_call":') || message.startsWith('{"tool_calls":'));
-      if (shouldHandleAsFunction) {
-        isFunctionStreamingIn = true;
-        aggregatedResponse += message;
-        isFirstChunk = false;
-        return;
-      }
-      if (!isFunctionStreamingIn) {
-        controller.enqueue(
-          textEncoder.encode(formatStreamPart2("text", message))
-        );
-        return;
-      } else {
-        aggregatedResponse += message;
-      }
-    },
-    async flush(controller) {
-      try {
-        if (!isFirstChunk && isFunctionStreamingIn && (callbacks.experimental_onFunctionCall || callbacks.experimental_onToolCall)) {
-          isFunctionStreamingIn = false;
-          const payload = JSON.parse(aggregatedResponse);
-          let newFunctionCallMessages = [
-            ...functionCallMessages
-          ];
-          let functionResponse = void 0;
-          if (callbacks.experimental_onFunctionCall) {
-            if (payload.function_call === void 0) {
-              console.warn(
-                "experimental_onFunctionCall should not be defined when using tools"
-              );
-            }
-            const argumentsPayload = JSON.parse(
-              payload.function_call.arguments
-            );
-            functionResponse = await 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 (callbacks.experimental_onToolCall) {
-            const toolCalls = {
-              tools: []
-            };
-            for (const tool of payload.tool_calls) {
-              toolCalls.tools.push({
-                id: tool.id,
-                type: "function",
-                func: {
-                  name: tool.function.name,
-                  arguments: JSON.parse(tool.function.arguments)
-                }
-              });
-            }
-            let responseIndex = 0;
-            try {
-              functionResponse = await callbacks.experimental_onToolCall(
-                toolCalls,
-                (result) => {
-                  if (result) {
-                    const { tool_call_id, function_name, tool_call_result } = result;
-                    newFunctionCallMessages = [
-                      ...newFunctionCallMessages,
-                      // Only append the assistant message if it's the first response
-                      ...responseIndex === 0 ? [
-                        {
-                          role: "assistant",
-                          content: "",
-                          tool_calls: payload.tool_calls.map(
-                            (tc) => ({
-                              id: tc.id,
-                              type: "function",
-                              function: {
-                                name: tc.function.name,
-                                // we send the arguments an object to the user, but as the API expects a string, we need to stringify it
-                                arguments: JSON.stringify(
-                                  tc.function.arguments
-                                )
-                              }
-                            })
-                          )
-                        }
-                      ] : [],
-                      // Append the function call result message
-                      {
-                        role: "tool",
-                        tool_call_id,
-                        name: function_name,
-                        content: JSON.stringify(tool_call_result)
-                      }
-                    ];
-                    responseIndex++;
-                  }
-                  return newFunctionCallMessages;
-                }
-              );
-            } catch (e) {
-              console.error("Error calling experimental_onToolCall:", e);
-            }
-          }
-          if (!functionResponse) {
-            controller.enqueue(
-              textEncoder.encode(
-                formatStreamPart2(
-                  payload.function_call ? "function_call" : "tool_calls",
-                  // parse to prevent double-encoding:
-                  JSON.parse(aggregatedResponse)
-                )
-              )
-            );
-            return;
-          } else if (typeof functionResponse === "string") {
-            controller.enqueue(
-              textEncoder.encode(formatStreamPart2("text", functionResponse))
-            );
-            aggregatedFinalCompletionResponse = functionResponse;
-            return;
-          }
-          const filteredCallbacks = {
-            ...callbacks,
-            onStart: void 0
-          };
-          callbacks.onFinal = void 0;
-          const openAIStream = OpenAIStream(functionResponse, {
-            ...filteredCallbacks,
-            [__internal__OpenAIFnMessagesSymbol]: newFunctionCallMessages
-          });
-          const reader = openAIStream.getReader();
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done) {
-              break;
-            }
-            controller.enqueue(value);
-          }
-        }
-      } finally {
-        if (callbacks.onFinal && aggregatedFinalCompletionResponse) {
-          await callbacks.onFinal(aggregatedFinalCompletionResponse);
-        }
-      }
-    }
-  });
-}
-
-// util/consume-stream.ts
-async function consumeStream(stream) {
-  const reader = stream.getReader();
-  while (true) {
-    const { done } = await reader.read();
-    if (done)
-      break;
-  }
-}
-
-// rsc/stream-ui/render.ts
-function render(options) {
-  const ui = createStreamableUI(options.initial);
-  const text = options.text ? options.text : ({ content }) => content;
-  const functions = options.functions ? Object.entries(options.functions).map(
-    ([name9, { description, parameters }]) => {
-      return {
-        name: name9,
-        description,
-        parameters: zodToJsonSchema(parameters)
-      };
-    }
-  ) : void 0;
-  const tools = options.tools ? Object.entries(options.tools).map(
-    ([name9, { description, parameters }]) => {
-      return {
-        type: "function",
-        function: {
-          name: name9,
-          description,
-          parameters: zodToJsonSchema(parameters)
-        }
-      };
-    }
-  ) : void 0;
-  if (functions && tools) {
-    throw new Error(
-      "You can't have both functions and tools defined. Please choose one or the other."
-    );
-  }
-  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);
-    }
-  }
-  (async () => {
-    let hasFunction = false;
-    let content = "";
-    consumeStream(
-      OpenAIStream(
-        await options.provider.chat.completions.create({
-          model: options.model,
-          messages: options.messages,
-          temperature: options.temperature,
-          stream: true,
-          ...functions ? {
-            functions
-          } : {},
-          ...tools ? {
-            tools
-          } : {}
-        }),
-        {
-          ...functions ? {
-            async experimental_onFunctionCall(functionCallPayload) {
-              var _a9, _b;
-              hasFunction = true;
-              handleRender(
-                functionCallPayload.arguments,
-                (_b = (_a9 = options.functions) == null ? void 0 : _a9[functionCallPayload.name]) == null ? void 0 : _b.render,
-                ui
-              );
-            }
-          } : {},
-          ...tools ? {
-            async experimental_onToolCall(toolCallPayload) {
-              var _a9, _b;
-              hasFunction = true;
-              for (const tool of toolCallPayload.tools) {
-                handleRender(
-                  tool.func.arguments,
-                  (_b = (_a9 = options.tools) == null ? void 0 : _a9[tool.func.name]) == null ? void 0 : _b.render,
-                  ui
-                );
-              }
-            }
-          } : {},
-          onText(chunk) {
-            content += chunk;
-            handleRender({ content, done: false, delta: chunk }, text, ui);
-          },
-          async onFinal() {
-            if (hasFunction) {
-              await finished;
-              ui.done();
-              return;
-            }
-            handleRender({ content, done: true }, text, ui);
-            await finished;
-            ui.done();
-          }
-        }
-      )
-    );
-  })();
-  return ui.value;
-}
-
 // rsc/streamable-value/streamable-value.ts
 var STREAMABLE_VALUE_TYPE = Symbol.for("ui.streamable.value");
 
@@ -2479,7 +1876,7 @@ function createStreamableValueImpl(initialValue) {
     }
     currentValue = value;
   }
-  const streamable2 = {
+  const streamable = {
     set [STREAMABLE_VALUE_INTERNAL_LOCK](state) {
       locked = state;
     },
@@ -2494,7 +1891,7 @@ function createStreamableValueImpl(initialValue) {
       currentPromise = resolvable.promise;
       resolvePrevious(createWrapped());
       warnUnclosedStream();
-      return streamable2;
+      return streamable;
     },
     append(value) {
       assertStream(".append()");
@@ -2520,7 +1917,7 @@ function createStreamableValueImpl(initialValue) {
       currentPromise = resolvable.promise;
       resolvePrevious(createWrapped());
       warnUnclosedStream();
-      return streamable2;
+      return streamable;
     },
     error(error) {
       assertStream(".error()");
@@ -2531,7 +1928,7 @@ function createStreamableValueImpl(initialValue) {
       currentError = error;
       currentPromise = void 0;
       resolvable.resolve({ error });
-      return streamable2;
+      return streamable;
     },
     done(...args) {
       assertStream(".done()");
@@ -2543,13 +1940,13 @@ function createStreamableValueImpl(initialValue) {
       if (args.length) {
         updateValueStates(args[0]);
         resolvable.resolve(createWrapped());
-        return streamable2;
+        return streamable;
       }
       resolvable.resolve({});
-      return streamable2;
+      return streamable;
     }
   };
-  return streamable2;
+  return streamable;
 }
 export {
   createAI,
@@ -2557,7 +1954,6 @@ export {
   createStreamableValue,
   getAIState,
   getMutableAIState,
-  render,
   streamUI
 };
 //# sourceMappingURL=rsc-server.mjs.map