ai 3.0.5 → 3.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "3.0.5",
+  "version": "3.0.6",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -20,44 +20,37 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs",
-      "module": "./dist/index.mjs",
       "require": "./dist/index.js"
     },
     "./rsc": {
-      "types": "./rsc/dist/index.d.mts",
+      "types": "./rsc/dist/index.d.ts",
       "react-server": "./rsc/dist/rsc-server.mjs",
-      "import": "./rsc/dist/rsc-client.mjs",
-      "module": "./rsc/dist/rsc-client.mjs"
+      "import": "./rsc/dist/rsc-client.mjs"
     },
     "./prompts": {
       "types": "./prompts/dist/index.d.ts",
       "import": "./prompts/dist/index.mjs",
-      "module": "./prompts/dist/index.mjs",
       "require": "./prompts/dist/index.js"
     },
     "./react": {
       "types": "./react/dist/index.d.ts",
       "react-server": "./react/dist/index.server.mjs",
       "import": "./react/dist/index.mjs",
-      "module": "./react/dist/index.mjs",
       "require": "./react/dist/index.js"
     },
     "./svelte": {
       "types": "./svelte/dist/index.d.ts",
       "import": "./svelte/dist/index.mjs",
-      "module": "./svelte/dist/index.mjs",
       "require": "./svelte/dist/index.js"
     },
     "./vue": {
       "types": "./vue/dist/index.d.ts",
       "import": "./vue/dist/index.mjs",
-      "module": "./vue/dist/index.mjs",
       "require": "./vue/dist/index.js"
     },
     "./solid": {
       "types": "./solid/dist/index.d.ts",
       "import": "./solid/dist/index.mjs",
-      "module": "./solid/dist/index.mjs",
       "require": "./solid/dist/index.js"
     }
   },

package/rsc/dist/index.d.ts

@@ -0,0 +1,167 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+import OpenAI from 'openai';
+import { z } from 'zod';
+
+type AIAction<T = any, R = any> = (...args: T[]) => Promise<R>;
+type AIActions<T = any, R = any> = Record<string, AIAction<T, R>>;
+type AIProviderProps<AIState = any, UIState = any, Actions = any> = {
+    children: React.ReactNode;
+    initialAIState?: AIState;
+    initialUIState?: UIState;
+    /** $ActionTypes is only added for type inference and is never used at runtime **/
+    $ActionTypes?: Actions;
+};
+type AIProvider<AIState = any, UIState = any, Actions = any> = (props: AIProviderProps<AIState, UIState, Actions>) => Promise<React.ReactElement>;
+type InferAIState<T, Fallback> = T extends AIProvider<infer AIState, any, any> ? AIState : Fallback;
+type InferUIState<T, Fallback> = T extends AIProvider<any, infer UIState, any> ? UIState : Fallback;
+type InferActions<T, Fallback> = T extends AIProvider<any, any, infer Actions> ? Actions : Fallback;
+type OnSetAIState<S> = ({ key, state, done, }: {
+    key: string | number | symbol | undefined;
+    state: S;
+    done: boolean;
+}) => void | Promise<void>;
+type OnGetUIState<S> = AIAction<void, S | undefined>;
+type ValueOrUpdater<T> = T | ((current: T) => T);
+type MutableAIState<AIState> = {
+    get: () => AIState;
+    update: (newState: ValueOrUpdater<AIState>) => void;
+    done: ((newState: AIState) => void) | (() => void);
+};
+
+/**
+ * Get the current AI state.
+ * If `key` is provided, it will return the value of the specified key in the
+ * AI state, if it's an object. If it's not an object, it will throw an error.
+ *
+ * @example const state = getAIState() // Get the entire AI state
+ * @example const field = getAIState('key') // Get the value of the key
+ */
+declare function getAIState<AI extends AIProvider = any>(): InferAIState<AI, any>;
+declare function getAIState<AI extends AIProvider = any>(key: keyof InferAIState<AI, any>): InferAIState<AI, any>[typeof key];
+/**
+ * Get the mutable AI state. Note that you must call `.close()` when finishing
+ * updating the AI state.
+ *
+ * @example
+ * ```tsx
+ * const state = getMutableAIState()
+ * state.update({ ...state.get(), key: 'value' })
+ * state.update((currentState) => ({ ...currentState, key: 'value' }))
+ * state.done()
+ * ```
+ *
+ * @example
+ * ```tsx
+ * const state = getMutableAIState()
+ * state.done({ ...state.get(), key: 'value' }) // Done with a new state
+ * ```
+ */
+declare function getMutableAIState<AI extends AIProvider = any>(): MutableAIState<InferAIState<AI, any>>;
+declare function getMutableAIState<AI extends AIProvider = any>(key: keyof InferAIState<AI, any>): MutableAIState<InferAIState<AI, any>[typeof key]>;
+
+/**
+ * Create a piece of changable UI that can be streamed to the client.
+ * On the client side, it can be rendered as a normal React node.
+ */
+declare function createStreamableUI(initialValue?: React.ReactNode): {
+    value: react_jsx_runtime.JSX.Element;
+    update(value: React.ReactNode): void;
+    append(value: React.ReactNode): void;
+    error(error: any): void;
+    done(...args: any): void;
+};
+/**
+ * Create a wrapped, changable value that can be streamed to the client.
+ * On the client side, the value can be accessed via the useStreamableValue() hook.
+ */
+declare function createStreamableValue<T = any>(initialValue?: T): {
+    value: {
+        type: symbol;
+        curr: T | undefined;
+        next: Promise<any>;
+    } | {
+        curr: T | undefined;
+        next: Promise<any>;
+        type?: undefined;
+    };
+    update(value: T): void;
+    error(error: any): void;
+    done(...args: any): void;
+};
+type Streamable = ReactNode | Promise<ReactNode>;
+type Renderer<T> = (props: T) => Streamable | Generator<Streamable, Streamable, void> | AsyncGenerator<Streamable, Streamable, void>;
+/**
+ * `render` is a helper function to create a streamable UI from some LLMs.
+ * Currently, it only supports OpenAI's GPT models with Function Calling and Assistants Tools.
+ */
+declare function render<TS extends {
+    [name: string]: z.Schema;
+} = {}, FS extends {
+    [name: string]: z.Schema;
+} = {}>(options: {
+    /**
+     * The model name to use. Must be OpenAI SDK compatible. Tools and Functions are only supported
+     * GPT models (3.5/4), OpenAI Assistants, Mistral small and large, and Fireworks firefunction-v1.
+     *
+     * @example "gpt-3.5-turbo"
+     */
+    model: string;
+    /**
+     * The provider instance to use. Currently the only provider available is OpenAI.
+     * This needs to match the model name.
+     */
+    provider: OpenAI;
+    messages: Parameters<typeof OpenAI.prototype.chat.completions.create>[0]['messages'];
+    text?: Renderer<{
+        content: string;
+        done: boolean;
+    }>;
+    tools?: {
+        [name in keyof TS]: {
+            description?: string;
+            parameters: TS[name];
+            render: Renderer<z.infer<TS[name]>>;
+        };
+    };
+    functions?: {
+        [name in keyof FS]: {
+            description?: string;
+            parameters: FS[name];
+            render: Renderer<z.infer<FS[name]>>;
+        };
+    };
+    initial?: ReactNode;
+    temperature?: number;
+}): ReactNode;
+
+declare function createAI<AIState = any, UIState = any, Actions extends AIActions = {}>({ actions, initialAIState, initialUIState, unstable_onSetAIState: onSetAIState, unstable_onGetUIState: onGetUIState, }: {
+    actions: Actions;
+    initialAIState?: AIState;
+    initialUIState?: UIState;
+    unstable_onSetAIState?: OnSetAIState<AIState>;
+    unstable_onGetUIState?: OnGetUIState<UIState>;
+}): AIProvider<AIState, UIState, Actions>;
+
+declare const STREAMABLE_VALUE_TYPE: unique symbol;
+
+type StreamableValue = {
+    curr?: any;
+    next?: Promise<StreamableValue>;
+    type: typeof STREAMABLE_VALUE_TYPE;
+};
+declare function useStreamableValue(streamableValue: StreamableValue): any[];
+
+declare function useUIState<AI extends AIProvider = any>(): [InferUIState<AI, any>, (v: InferUIState<AI, any> | ((v_: InferUIState<AI, any>) => InferUIState<AI, any>)) => void];
+declare function useAIState<AI extends AIProvider = any>(): [
+    InferAIState<AI, any>,
+    (newState: ValueOrUpdater<InferAIState<AI, any>>) => void
+];
+declare function useAIState<AI extends AIProvider = any>(key: keyof InferAIState<AI, any>): [
+    InferAIState<AI, any>[typeof key],
+    (newState: ValueOrUpdater<InferAIState<AI, any>[typeof key]>) => void
+];
+declare function useActions<AI extends AIProvider = any>(): InferActions<AI, any>;
+declare function useSyncUIState(): () => Promise<void>;
+
+export { createAI, createStreamableUI, createStreamableValue, getAIState, getMutableAIState, render, useAIState, useActions, useStreamableValue, useSyncUIState, useUIState };

package/rsc/dist/index.mjs

@@ -1 +1,18 @@
-//# sourceMappingURL=index.mjs.map
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// rsc/index.ts
+var rsc_exports = {};
+module.exports = __toCommonJS(rsc_exports);

package/rsc/dist/rsc-server.d.mts

@@ -2,7 +2,6 @@ import * as react_jsx_runtime from 'react/jsx-runtime';
 import { ReactNode } from 'react';
 import OpenAI from 'openai';
 import { z } from 'zod';
-import './rsc-shared.mjs';
 
 type AIAction<T = any, R = any> = (...args: T[]) => Promise<R>;
 type AIActions<T = any, R = any> = Record<string, AIAction<T, R>>;

package/rsc/dist/rsc-server.mjs

@@ -745,7 +745,7 @@ function createFunctionCallTransformer(callbacks) {
                 type: "function",
                 func: {
                   name: tool.function.name,
-                  arguments: tool.function.arguments
+                  arguments: JSON.parse(tool.function.arguments)
                 }
               });
             }
@@ -842,6 +842,7 @@ function createFunctionCallTransformer(callbacks) {
 
 // rsc/constants.ts
 var STREAMABLE_VALUE_TYPE = Symbol.for("ui.streamable.value");
+var DEV_DEFAULT_STREAMABLE_WARNING_TIME = 15 * 1e3;
 
 // rsc/streamable.tsx
 import { Fragment as Fragment2, jsxs as jsxs2 } from "react/jsx-runtime";
@@ -849,27 +850,39 @@ function createStreamableUI(initialValue) {
   let currentValue = initialValue;
   let closed = false;
   let { row, resolve, reject } = createSuspensedChunk(initialValue);
-  function assertStream() {
+  function assertStream(method) {
     if (closed) {
-      throw new Error("UI stream is already closed.");
+      throw new Error(method + ": UI stream is already closed.");
     }
   }
+  let warningTimeout;
+  function warnUnclosedStream() {
+    if (process.env.NODE_ENV === "development") {
+      if (warningTimeout) {
+        clearTimeout(warningTimeout);
+      }
+      warningTimeout = setTimeout(() => {
+        console.warn(
+          "The streamable UI has been slow to update. This may be a bug or a performance issue or you forgot to call `.done()`."
+        );
+      }, DEV_DEFAULT_STREAMABLE_WARNING_TIME);
+    }
+  }
+  warnUnclosedStream();
   return {
     value: row,
     update(value) {
-      assertStream();
+      assertStream(".update()");
       const resolvable = createResolvablePromise();
-      resolve({ value, done: false, next: resolvable.promise });
+      currentValue = value;
+      resolve({ value: currentValue, done: false, next: resolvable.promise });
       resolve = resolvable.resolve;
       reject = resolvable.reject;
-      currentValue = value;
+      warnUnclosedStream();
     },
     append(value) {
-      assertStream();
+      assertStream(".append()");
       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 {
@@ -878,14 +891,24 @@ function createStreamableUI(initialValue) {
           value
         ] });
       }
+      resolve({ value: currentValue, done: false, next: resolvable.promise });
+      resolve = resolvable.resolve;
+      reject = resolvable.reject;
+      warnUnclosedStream();
     },
     error(error) {
-      assertStream();
+      assertStream(".error()");
+      if (warningTimeout) {
+        clearTimeout(warningTimeout);
+      }
       closed = true;
       reject(error);
     },
     done(...args) {
-      assertStream();
+      assertStream(".done()");
+      if (warningTimeout) {
+        clearTimeout(warningTimeout);
+      }
       closed = true;
       if (args.length) {
         resolve({ value: args[0], done: true });
@@ -898,11 +921,25 @@ function createStreamableUI(initialValue) {
 function createStreamableValue(initialValue) {
   let closed = false;
   let { promise, resolve, reject } = createResolvablePromise();
-  function assertStream() {
+  function assertStream(method) {
     if (closed) {
-      throw new Error("Value stream is already closed.");
+      throw new Error(method + ": Value stream is already closed.");
     }
   }
+  let warningTimeout;
+  function warnUnclosedStream() {
+    if (process.env.NODE_ENV === "development") {
+      if (warningTimeout) {
+        clearTimeout(warningTimeout);
+      }
+      warningTimeout = setTimeout(() => {
+        console.warn(
+          "The streamable UI has been slow to update. This may be a bug or a performance issue or you forgot to call `.done()`."
+        );
+      }, DEV_DEFAULT_STREAMABLE_WARNING_TIME);
+    }
+  }
+  warnUnclosedStream();
   function createWrapped(val, initial) {
     if (initial) {
       return {
@@ -919,21 +956,28 @@ function createStreamableValue(initialValue) {
   return {
     value: createWrapped(initialValue, true),
     update(value) {
-      assertStream();
+      assertStream(".update()");
       const resolvePrevious = resolve;
       const resolvable = createResolvablePromise();
       promise = resolvable.promise;
       resolve = resolvable.resolve;
       reject = resolvable.reject;
       resolvePrevious(createWrapped(value));
+      warnUnclosedStream();
     },
     error(error) {
-      assertStream();
+      assertStream(".error()");
+      if (warningTimeout) {
+        clearTimeout(warningTimeout);
+      }
       closed = true;
       reject(error);
     },
     done(...args) {
-      assertStream();
+      assertStream(".done()");
+      if (warningTimeout) {
+        clearTimeout(warningTimeout);
+      }
       closed = true;
       if (args.length) {
         resolve({ curr: args[0] });