ai 2.2.37 → 3.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "2.2.37",
+  "version": "3.0.0",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -12,7 +12,8 @@
     "svelte/dist/**/*",
     "vue/dist/**/*",
     "solid/dist/**/*",
-    "prompts/dist/**/*"
+    "prompts/dist/**/*",
+    "rsc/dist/**/*"
   ],
   "exports": {
     "./package.json": "./package.json",
@@ -22,6 +23,12 @@
       "module": "./dist/index.mjs",
       "require": "./dist/index.js"
     },
+    "./rsc": {
+      "types": "./rsc/dist/rsc-types.d.ts",
+      "react-server": "./rsc/dist/rsc-server.mjs",
+      "import": "./rsc/dist/rsc-client.mjs",
+      "module": "./rsc/dist/rsc-client.mjs"
+    },
     "./prompts": {
       "types": "./prompts/dist/index.d.ts",
       "import": "./prompts/dist/index.mjs",
@@ -56,12 +63,14 @@
   },
   "dependencies": {
     "eventsource-parser": "1.0.0",
+    "jsondiffpatch": "^0.6.0",
     "nanoid": "3.3.6",
     "solid-swr-store": "0.10.7",
     "sswr": "2.0.0",
     "swr": "2.2.0",
     "swr-store": "0.10.6",
-    "swrv": "1.0.4"
+    "swrv": "1.0.4",
+    "zod-to-json-schema": "^3.22.4"
   },
   "devDependencies": {
     "@anthropic-ai/sdk": "0.12.0",
@@ -91,14 +100,15 @@
     "tsup": "^6.7.0",
     "typescript": "5.1.3",
     "vite-plugin-solid": "2.7.2",
-    "@vercel/ai-tsconfig": "0.0.0",
-    "eslint-config-vercel-ai": "0.0.0"
+    "eslint-config-vercel-ai": "0.0.0",
+    "@vercel/ai-tsconfig": "0.0.0"
   },
   "peerDependencies": {
     "react": "^18.2.0",
     "solid-js": "^1.7.7",
     "svelte": "^3.0.0 || ^4.0.0",
-    "vue": "^3.3.4"
+    "vue": "^3.3.4",
+    "zod": "^3.0.0"
   },
   "peerDependenciesMeta": {
     "react": {
@@ -112,6 +122,9 @@
     },
     "solid-js": {
       "optional": true
+    },
+    "zod": {
+      "optional": true
     }
   },
   "engines": {
@@ -137,7 +150,7 @@
   ],
   "scripts": {
     "build": "tsup && cat react/dist/index.server.d.ts >> react/dist/index.d.ts",
-    "clean": "rm -rf dist && rm -rf react/dist && rm -rf svelte/dist && rm -rf vue/dist && rm -rf solid/dist",
+    "clean": "rm -rf dist && rm -rf react/dist && rm -rf svelte/dist && rm -rf vue/dist && rm -rf solid/dist && rm -rf rsc/dist",
     "dev": "tsup --watch",
     "lint": "eslint \"./**/*.ts*\"",
     "type-check": "tsc --noEmit",

package/rsc/dist/rsc-client.d.ts

@@ -0,0 +1 @@
+export { useAIState, useActions, useStreamableValue, useSyncUIState, useUIState } from './rsc-shared';

package/rsc/dist/rsc-client.mjs

@@ -0,0 +1,16 @@
+// rsc/rsc-client.ts
+import {
+  useStreamableValue,
+  useUIState,
+  useAIState,
+  useActions,
+  useSyncUIState
+} from "./rsc-shared";
+export {
+  useAIState,
+  useActions,
+  useStreamableValue,
+  useSyncUIState,
+  useUIState
+};
+//# sourceMappingURL=rsc-client.mjs.map

package/rsc/dist/rsc-client.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../rsc-client.ts"],"sourcesContent":["export {\n  useStreamableValue,\n  useUIState,\n  useAIState,\n  useActions,\n  useSyncUIState,\n} from './rsc-shared';\n"],"mappings":";AAAA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;","names":[]}

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

@@ -0,0 +1,143 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+import OpenAI from 'openai';
+import { z } from 'zod';
+import './rsc-shared';
+
+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> = {
+    children: React.ReactNode;
+    initialAIState?: AIState;
+    initialUIState?: UIState;
+};
+type AIProvider<AIState = any, UIState = any, Actions = any> = (props: AIProviderProps<AIState, UIState>) => Promise<React.ReactElement>;
+type InferAIState<T, Fallback> = T extends AIProvider<infer AIState, any, any> ? AIState : 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<unknown>;
+    } | {
+        curr: T | undefined;
+        next: Promise<unknown>;
+        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. Currently the only models available are OpenAI's
+     * GPT models (3.5/4) with Function Calling and Assistants Tools.
+     *
+     * @example "gpt-3.5-turbo"
+     */
+    model: `gpt-${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>;
+
+export { createAI, createStreamableUI, createStreamableValue, getAIState, getMutableAIState, render };