ai 2.2.37 → 3.0.0

package/rsc/dist/rsc-server.mjs

@@ -0,0 +1,1112 @@
+// rsc/ai-state.tsx
+import { AsyncLocalStorage } from "async_hooks";
+import * as jsondiffpatch from "jsondiffpatch";
+
+// rsc/utils.tsx
+import { Suspense } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function createResolvablePromise() {
+  let resolve, reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return {
+    promise,
+    resolve,
+    reject
+  };
+}
+function createSuspensedChunk(initialValue) {
+  const Row = async ({
+    current,
+    next
+  }) => {
+    const chunk = await next;
+    if (chunk.done) {
+      return chunk.value;
+    }
+    if (chunk.append) {
+      return /* @__PURE__ */ jsxs(Fragment, { children: [
+        current,
+        /* @__PURE__ */ jsx(Suspense, { fallback: chunk.value, children: /* @__PURE__ */ jsx(Row, { current: chunk.value, next: chunk.next }) })
+      ] });
+    }
+    return /* @__PURE__ */ jsx(Suspense, { fallback: chunk.value, children: /* @__PURE__ */ jsx(Row, { current: chunk.value, next: chunk.next }) });
+  };
+  const { promise, resolve, reject } = createResolvablePromise();
+  return {
+    row: /* @__PURE__ */ jsx(Suspense, { fallback: initialValue, children: /* @__PURE__ */ jsx(Row, { current: initialValue, next: promise }) }),
+    resolve,
+    reject
+  };
+}
+var isFunction = (x) => typeof x === "function";
+var consumeStream = async (stream) => {
+  const reader = stream.getReader();
+  while (true) {
+    const { done } = await reader.read();
+    if (done)
+      break;
+  }
+};
+
+// rsc/ai-state.tsx
+var asyncAIStateStorage = new AsyncLocalStorage();
+function getAIStateStoreOrThrow(message) {
+  const store = asyncAIStateStorage.getStore();
+  if (!store) {
+    throw new Error(message);
+  }
+  return store;
+}
+function withAIState({ state, options }, fn) {
+  return asyncAIStateStorage.run(
+    {
+      currentState: state,
+      originalState: state,
+      sealed: false,
+      options
+    },
+    fn
+  );
+}
+function getAIStateDeltaPromise() {
+  const store = getAIStateStoreOrThrow("Internal error occurred.");
+  return store.mutationDeltaPromise;
+}
+function sealMutableAIState() {
+  const store = getAIStateStoreOrThrow("Internal error occurred.");
+  store.sealed = true;
+}
+function getAIState(...args) {
+  const store = getAIStateStoreOrThrow(
+    "`getAIState` must be called within an AI Action."
+  );
+  if (args.length > 0) {
+    const key = args[0];
+    if (typeof store.currentState !== "object") {
+      throw new Error(
+        `You can't get the "${String(
+          key
+        )}" field from the AI state because it's not an object.`
+      );
+    }
+    return store.currentState[key];
+  }
+  return store.currentState;
+}
+function getMutableAIState(...args) {
+  const store = getAIStateStoreOrThrow(
+    "`getMutableAIState` must be called within an AI Action."
+  );
+  if (store.sealed) {
+    throw new Error(
+      "`getMutableAIState` must be called before returning from an AI Action. Please move it to the top level of the Action's function body."
+    );
+  }
+  if (!store.mutationDeltaPromise) {
+    const { promise, resolve } = createResolvablePromise();
+    store.mutationDeltaPromise = promise;
+    store.mutationDeltaResolve = resolve;
+  }
+  function doUpdate(newState, done) {
+    var _a, _b;
+    if (args.length > 0) {
+      if (typeof store.currentState !== "object") {
+        const key = args[0];
+        throw new Error(
+          `You can't modify the "${String(
+            key
+          )}" field of the AI state because it's not an object.`
+        );
+      }
+    }
+    if (isFunction(newState)) {
+      if (args.length > 0) {
+        store.currentState[args[0]] = newState(store.currentState[args[0]]);
+      } else {
+        store.currentState = newState(store.currentState);
+      }
+    } else {
+      if (args.length > 0) {
+        store.currentState[args[0]] = newState;
+      } else {
+        store.currentState = newState;
+      }
+    }
+    (_b = (_a = store.options).onSetAIState) == null ? void 0 : _b.call(_a, {
+      key: args.length > 0 ? args[0] : void 0,
+      state: store.currentState,
+      done
+    });
+  }
+  const mutableState = {
+    get: () => {
+      if (args.length > 0) {
+        const key = args[0];
+        if (typeof store.currentState !== "object") {
+          throw new Error(
+            `You can't get the "${String(
+              key
+            )}" field from the AI state because it's not an object.`
+          );
+        }
+        return store.currentState[key];
+      }
+      return store.currentState;
+    },
+    update: function update(newAIState) {
+      doUpdate(newAIState, false);
+    },
+    done: function done(...doneArgs) {
+      if (doneArgs.length > 0) {
+        doUpdate(doneArgs[0], true);
+      }
+      const delta = jsondiffpatch.diff(store.originalState, store.currentState);
+      store.mutationDeltaResolve(delta);
+    }
+  };
+  return mutableState;
+}
+
+// rsc/streamable.tsx
+import zodToJsonSchema from "zod-to-json-schema";
+
+// shared/utils.ts
+import { customAlphabet } from "nanoid/non-secure";
+
+// shared/stream-parts.ts
+var textStreamPart = {
+  code: "0",
+  name: "text",
+  parse: (value) => {
+    if (typeof value !== "string") {
+      throw new Error('"text" parts expect a string value.');
+    }
+    return { type: "text", value };
+  }
+};
+var functionCallStreamPart = {
+  code: "1",
+  name: "function_call",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("function_call" in value) || typeof value.function_call !== "object" || value.function_call == null || !("name" in value.function_call) || !("arguments" in value.function_call) || typeof value.function_call.name !== "string" || typeof value.function_call.arguments !== "string") {
+      throw new Error(
+        '"function_call" parts expect an object with a "function_call" property.'
+      );
+    }
+    return {
+      type: "function_call",
+      value
+    };
+  }
+};
+var dataStreamPart = {
+  code: "2",
+  name: "data",
+  parse: (value) => {
+    if (!Array.isArray(value)) {
+      throw new Error('"data" parts expect an array value.');
+    }
+    return { type: "data", value };
+  }
+};
+var errorStreamPart = {
+  code: "3",
+  name: "error",
+  parse: (value) => {
+    if (typeof value !== "string") {
+      throw new Error('"error" parts expect a string value.');
+    }
+    return { type: "error", value };
+  }
+};
+var assistantMessageStreamPart = {
+  code: "4",
+  name: "assistant_message",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("id" in value) || !("role" in value) || !("content" in value) || typeof value.id !== "string" || typeof value.role !== "string" || value.role !== "assistant" || !Array.isArray(value.content) || !value.content.every(
+      (item) => item != null && typeof item === "object" && "type" in item && item.type === "text" && "text" in item && item.text != null && typeof item.text === "object" && "value" in item.text && typeof item.text.value === "string"
+    )) {
+      throw new Error(
+        '"assistant_message" parts expect an object with an "id", "role", and "content" property.'
+      );
+    }
+    return {
+      type: "assistant_message",
+      value
+    };
+  }
+};
+var assistantControlDataStreamPart = {
+  code: "5",
+  name: "assistant_control_data",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("threadId" in value) || !("messageId" in value) || typeof value.threadId !== "string" || typeof value.messageId !== "string") {
+      throw new Error(
+        '"assistant_control_data" parts expect an object with a "threadId" and "messageId" property.'
+      );
+    }
+    return {
+      type: "assistant_control_data",
+      value: {
+        threadId: value.threadId,
+        messageId: value.messageId
+      }
+    };
+  }
+};
+var dataMessageStreamPart = {
+  code: "6",
+  name: "data_message",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("role" in value) || !("data" in value) || typeof value.role !== "string" || value.role !== "data") {
+      throw new Error(
+        '"data_message" parts expect an object with a "role" and "data" property.'
+      );
+    }
+    return {
+      type: "data_message",
+      value
+    };
+  }
+};
+var toolCallStreamPart = {
+  code: "7",
+  name: "tool_calls",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("tool_calls" in value) || typeof value.tool_calls !== "object" || value.tool_calls == null || !Array.isArray(value.tool_calls) || value.tool_calls.some((tc) => {
+      tc == null || typeof tc !== "object" || !("id" in tc) || typeof tc.id !== "string" || !("type" in tc) || typeof tc.type !== "string" || !("function" in tc) || tc.function == null || typeof tc.function !== "object" || !("arguments" in tc.function) || typeof tc.function.name !== "string" || typeof tc.function.arguments !== "string";
+    })) {
+      throw new Error(
+        '"tool_calls" parts expect an object with a ToolCallPayload.'
+      );
+    }
+    return {
+      type: "tool_calls",
+      value
+    };
+  }
+};
+var messageAnnotationsStreamPart = {
+  code: "8",
+  name: "message_annotations",
+  parse: (value) => {
+    if (!Array.isArray(value)) {
+      throw new Error('"message_annotations" parts expect an array value.');
+    }
+    return { type: "message_annotations", value };
+  }
+};
+var streamParts = [
+  textStreamPart,
+  functionCallStreamPart,
+  dataStreamPart,
+  errorStreamPart,
+  assistantMessageStreamPart,
+  assistantControlDataStreamPart,
+  dataMessageStreamPart,
+  toolCallStreamPart,
+  messageAnnotationsStreamPart
+];
+var streamPartsByCode = {
+  [textStreamPart.code]: textStreamPart,
+  [functionCallStreamPart.code]: functionCallStreamPart,
+  [dataStreamPart.code]: dataStreamPart,
+  [errorStreamPart.code]: errorStreamPart,
+  [assistantMessageStreamPart.code]: assistantMessageStreamPart,
+  [assistantControlDataStreamPart.code]: assistantControlDataStreamPart,
+  [dataMessageStreamPart.code]: dataMessageStreamPart,
+  [toolCallStreamPart.code]: toolCallStreamPart,
+  [messageAnnotationsStreamPart.code]: messageAnnotationsStreamPart
+};
+var StreamStringPrefixes = {
+  [textStreamPart.name]: textStreamPart.code,
+  [functionCallStreamPart.name]: functionCallStreamPart.code,
+  [dataStreamPart.name]: dataStreamPart.code,
+  [errorStreamPart.name]: errorStreamPart.code,
+  [assistantMessageStreamPart.name]: assistantMessageStreamPart.code,
+  [assistantControlDataStreamPart.name]: assistantControlDataStreamPart.code,
+  [dataMessageStreamPart.name]: dataMessageStreamPart.code,
+  [toolCallStreamPart.name]: toolCallStreamPart.code,
+  [messageAnnotationsStreamPart.name]: messageAnnotationsStreamPart.code
+};
+var validCodes = streamParts.map((part) => part.code);
+var parseStreamPart = (line) => {
+  const firstSeparatorIndex = line.indexOf(":");
+  if (firstSeparatorIndex === -1) {
+    throw new Error("Failed to parse stream string. No separator found.");
+  }
+  const prefix = line.slice(0, firstSeparatorIndex);
+  if (!validCodes.includes(prefix)) {
+    throw new Error(`Failed to parse stream string. Invalid code ${prefix}.`);
+  }
+  const code = prefix;
+  const textValue = line.slice(firstSeparatorIndex + 1);
+  const jsonValue = JSON.parse(textValue);
+  return streamPartsByCode[code].parse(jsonValue);
+};
+function formatStreamPart(type, value) {
+  const streamPart = streamParts.find((part) => part.name === type);
+  if (!streamPart) {
+    throw new Error(`Invalid stream part type: ${type}`);
+  }
+  return `${streamPart.code}:${JSON.stringify(value)}
+`;
+}
+
+// shared/utils.ts
+var nanoid = customAlphabet(
+  "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+  7
+);
+function createChunkDecoder(complex) {
+  const decoder = new TextDecoder();
+  if (!complex) {
+    return function(chunk) {
+      if (!chunk)
+        return "";
+      return decoder.decode(chunk, { stream: true });
+    };
+  }
+  return function(chunk) {
+    const decoded = decoder.decode(chunk, { stream: true }).split("\n").filter((line) => line !== "");
+    return decoded.map(parseStreamPart).filter(Boolean);
+  };
+}
+
+// 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) {
+      controller.enqueue(textEncoder.encode(message));
+      aggregatedResponse += message;
+      if (callbacks.onToken)
+        await callbacks.onToken(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 _a;
+      await ((_a = it.return) == null ? void 0 : _a.call(it, reason));
+    }
+  });
+}
+
+// streams/stream-data.ts
+function createStreamDataTransformer(experimental_streamData) {
+  if (!experimental_streamData) {
+    return new TransformStream({
+      transform: async (chunk, controller) => {
+        controller.enqueue(chunk);
+      }
+    });
+  }
+  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
+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 _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;
+  }
+}
+function chunkToText() {
+  const trimStartOfStream = trimStartOfStreamHelper();
+  let isFunctionStreamingIn;
+  return (json) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r;
+    if (isChatCompletionChunk(json)) {
+      const delta = (_a = json.choices[0]) == null ? void 0 : _a.delta;
+      if ((_b = delta.function_call) == null ? void 0 : _b.name) {
+        isFunctionStreamingIn = true;
+        return `{"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 `{"tool_calls":[ {"id": "${toolCall.id}", "type": "function", "function": {"name": "${(_f = toolCall.function) == null ? void 0 : _f.name}", "arguments": "`;
+        } else {
+          return `"}}, {"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 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 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 '"}}';
+      } else if (isFunctionStreamingIn && ((_r = json.choices[0]) == null ? void 0 : _r.finish_reason) === "tool_calls") {
+        isFunctionStreamingIn = false;
+        return '"}}]}';
+      }
+    }
+    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(cb == null ? void 0 : cb.experimental_streamData)
+    );
+  }
+}
+function createFunctionCallTransformer(callbacks) {
+  const textEncoder = new TextEncoder();
+  let isFirstChunk = true;
+  let aggregatedResponse = "";
+  let aggregatedFinalCompletionResponse = "";
+  let isFunctionStreamingIn = false;
+  let functionCallMessages = callbacks[__internal__OpenAIFnMessagesSymbol] || [];
+  const isComplexMode = callbacks == null ? void 0 : callbacks.experimental_streamData;
+  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(
+          isComplexMode ? textEncoder.encode(formatStreamPart("text", message)) : chunk
+        );
+        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: 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(
+                isComplexMode ? formatStreamPart(
+                  payload.function_call ? "function_call" : "tool_calls",
+                  // parse to prevent double-encoding:
+                  JSON.parse(aggregatedResponse)
+                ) : aggregatedResponse
+              )
+            );
+            return;
+          } else if (typeof functionResponse === "string") {
+            controller.enqueue(
+              isComplexMode ? textEncoder.encode(formatStreamPart("text", functionResponse)) : textEncoder.encode(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);
+        }
+      }
+    }
+  });
+}
+
+// rsc/constants.ts
+var STREAMABLE_VALUE_TYPE = Symbol.for("ui.streamable.value");
+
+// rsc/streamable.tsx
+import { Fragment as Fragment2, jsxs as jsxs2 } from "react/jsx-runtime";
+function createStreamableUI(initialValue) {
+  let currentValue = initialValue;
+  let closed = false;
+  let { row, resolve, reject } = createSuspensedChunk(initialValue);
+  function assertStream() {
+    if (closed) {
+      throw new Error("UI stream is already closed.");
+    }
+  }
+  return {
+    value: row,
+    update(value) {
+      assertStream();
+      const resolvable = createResolvablePromise();
+      resolve({ value, done: false, next: resolvable.promise });
+      resolve = resolvable.resolve;
+      reject = resolvable.reject;
+      currentValue = value;
+    },
+    append(value) {
+      assertStream();
+      const resolvable = createResolvablePromise();
+      resolve({ value, done: false, next: resolvable.promise });
+      resolve = resolvable.resolve;
+      reject = resolvable.reject;
+      if (typeof currentValue === "string" && typeof value === "string") {
+        currentValue += value;
+      } else {
+        currentValue = /* @__PURE__ */ jsxs2(Fragment2, { children: [
+          currentValue,
+          value
+        ] });
+      }
+    },
+    error(error) {
+      assertStream();
+      closed = true;
+      reject(error);
+    },
+    done(...args) {
+      assertStream();
+      closed = true;
+      if (args.length) {
+        resolve({ value: args[0], done: true });
+        return;
+      }
+      resolve({ value: currentValue, done: true });
+    }
+  };
+}
+function createStreamableValue(initialValue) {
+  let closed = false;
+  let { promise, resolve, reject } = createResolvablePromise();
+  function assertStream() {
+    if (closed) {
+      throw new Error("Value stream is already closed.");
+    }
+  }
+  function createWrapped(val, initial) {
+    if (initial) {
+      return {
+        type: STREAMABLE_VALUE_TYPE,
+        curr: val,
+        next: promise
+      };
+    }
+    return {
+      curr: val,
+      next: promise
+    };
+  }
+  return {
+    value: createWrapped(initialValue, true),
+    update(value) {
+      assertStream();
+      const resolvePrevious = resolve;
+      const resolvable = createResolvablePromise();
+      promise = resolvable.promise;
+      resolve = resolvable.resolve;
+      reject = resolvable.reject;
+      resolvePrevious(createWrapped(value));
+    },
+    error(error) {
+      assertStream();
+      closed = true;
+      reject(error);
+    },
+    done(...args) {
+      assertStream();
+      closed = true;
+      if (args.length) {
+        resolve({ curr: args[0] });
+        return;
+      }
+      resolve({});
+    }
+  };
+}
+function render(options) {
+  const ui = createStreamableUI(options.initial);
+  const functions = options.functions ? Object.entries(options.functions).map(
+    ([name, { description, parameters }]) => {
+      return {
+        name,
+        description,
+        parameters: zodToJsonSchema(parameters)
+      };
+    }
+  ) : void 0;
+  const tools = options.tools ? Object.entries(options.tools).map(
+    ([name, { description, parameters }]) => {
+      return {
+        type: "function",
+        function: {
+          name,
+          description,
+          parameters: zodToJsonSchema(parameters)
+        }
+      };
+    }
+  ) : void 0;
+  let finished;
+  async function handleRender(args, renderer, res) {
+    if (!renderer)
+      return;
+    if (finished)
+      await finished.promise;
+    finished = createResolvablePromise();
+    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);
+      finished == null ? void 0 : finished.resolve(void 0);
+    } else if (value && typeof value === "object" && Symbol.asyncIterator in value) {
+      for await (const node of value) {
+        res.update(node);
+      }
+      finished == null ? void 0 : finished.resolve(void 0);
+    } else if (value && typeof value === "object" && Symbol.iterator in value) {
+      const it = value;
+      while (true) {
+        const { done, value: value2 } = it.next();
+        if (done)
+          break;
+        res.update(value2);
+      }
+      finished == null ? void 0 : finished.resolve(void 0);
+    } else {
+      res.update(value);
+      finished == null ? void 0 : finished.resolve(void 0);
+    }
+  }
+  (async () => {
+    let hasFunction = false;
+    let text = "";
+    consumeStream(
+      OpenAIStream(
+        await options.provider.chat.completions.create({
+          model: options.model,
+          messages: options.messages,
+          temperature: options.temperature,
+          stream: true,
+          ...functions ? {
+            functions
+          } : {},
+          ...tools ? {
+            tools
+          } : {}
+        }),
+        {
+          async experimental_onFunctionCall(functionCallPayload) {
+            var _a, _b;
+            hasFunction = true;
+            handleRender(
+              functionCallPayload.arguments,
+              (_b = (_a = options.functions) == null ? void 0 : _a[functionCallPayload.name]) == null ? void 0 : _b.render,
+              ui
+            );
+          },
+          ...tools ? {
+            async experimental_onToolCall(toolCallPayload) {
+              var _a, _b;
+              hasFunction = true;
+              for (const tool of toolCallPayload.tools) {
+                handleRender(
+                  tool.func.arguments,
+                  (_b = (_a = options.tools) == null ? void 0 : _a[tool.func.name]) == null ? void 0 : _b.render,
+                  ui
+                );
+              }
+            }
+          } : {},
+          onToken(token) {
+            text += token;
+            if (hasFunction)
+              return;
+            handleRender({ content: text, done: false }, options.text, ui);
+          },
+          async onFinal() {
+            if (hasFunction)
+              return;
+            handleRender({ content: text, done: true }, options.text, ui);
+            await (finished == null ? void 0 : finished.promise);
+            ui.done();
+          }
+        }
+      )
+    );
+  })();
+  return ui.value;
+}
+
+// rsc/provider.tsx
+import * as React2 from "react";
+import { InternalAIProvider } from "./rsc-shared";
+import { jsx as jsx2 } from "react/jsx-runtime";
+async function innerAction({
+  action,
+  options
+}, state, ...args) {
+  "use server";
+  return await withAIState(
+    {
+      state,
+      options
+    },
+    async () => {
+      const result = await action(...args);
+      sealMutableAIState();
+      return [getAIStateDeltaPromise(), result];
+    }
+  );
+}
+function wrapAction(action, options) {
+  return innerAction.bind(null, { action, options });
+}
+function createAI({
+  actions,
+  initialAIState,
+  initialUIState,
+  unstable_onSetAIState: onSetAIState,
+  unstable_onGetUIState: onGetUIState
+}) {
+  const wrappedActions = {};
+  for (const name in actions) {
+    wrappedActions[name] = wrapAction(actions[name], {
+      onSetAIState
+    });
+  }
+  const wrappedSyncUIState = onGetUIState ? wrapAction(onGetUIState, {}) : void 0;
+  async function AI(props) {
+    var _a, _b;
+    if ("useState" in React2) {
+      throw new Error(
+        "This component can only be used inside Server Components."
+      );
+    }
+    let uiState = (_a = props.initialUIState) != null ? _a : initialUIState;
+    let aiState = (_b = props.initialAIState) != null ? _b : initialAIState;
+    let aiStateDelta = void 0;
+    if (wrappedSyncUIState) {
+      const [newAIStateDelta, newUIState] = await wrappedSyncUIState(aiState);
+      if (newUIState !== void 0) {
+        aiStateDelta = newAIStateDelta;
+        uiState = newUIState;
+      }
+    }
+    return /* @__PURE__ */ jsx2(
+      InternalAIProvider,
+      {
+        wrappedActions,
+        wrappedSyncUIState,
+        initialUIState: uiState,
+        initialAIState: aiState,
+        initialAIStatePatch: aiStateDelta,
+        children: props.children
+      }
+    );
+  }
+  return AI;
+}
+export {
+  createAI,
+  createStreamableUI,
+  createStreamableValue,
+  getAIState,
+  getMutableAIState,
+  render
+};
+//# sourceMappingURL=rsc-server.mjs.map