@ai-sdk/rsc 3.0.122 → 3.0.124

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @ai-sdk/rsc
 
+## 3.0.124
+
+### Patch Changes
+
+- Updated dependencies [8c65988]
+- Updated dependencies [527a163]
+  - ai@7.0.124
+  - @ai-sdk/provider@4.0.21
+  - @ai-sdk/provider-utils@5.0.53
+
+## 3.0.123
+
+### Patch Changes
+
+- ede5b89: chore: migrate package builds from tsup to tsdown
+- Updated dependencies [05cdac6]
+- Updated dependencies [4514fc1]
+- Updated dependencies [ede5b89]
+- Updated dependencies [2a625cf]
+- Updated dependencies [50a26d5]
+  - ai@7.0.123
+  - @ai-sdk/provider@4.0.20
+  - @ai-sdk/provider-utils@5.0.52
+
 ## 3.0.122
 
 ### Patch Changes

package/dist/index.d.ts

@@ -1,55 +1,55 @@
-import { LanguageModelV4, LanguageModelV4StreamResult } from '@ai-sdk/provider';
-import { ProviderOptions, InferSchema } from '@ai-sdk/provider-utils';
-import { Schema, LanguageModelCallOptions, RequestOptions, Prompt, ToolChoice, FinishReason, LanguageModelUsage, CallWarning } from 'ai';
-import { ReactNode } from 'react';
-import * as z3 from 'zod/v3';
-import * as z4 from 'zod/v4';
-
-type JSONValue = string | number | boolean | JSONObject | JSONArray;
+import { LanguageModelV4, LanguageModelV4StreamResult } from "@ai-sdk/provider";
+import { InferSchema, ProviderOptions } from "@ai-sdk/provider-utils";
+import { CallWarning, FinishReason, LanguageModelCallOptions, LanguageModelUsage, Prompt, RequestOptions, Schema, ToolChoice } from "ai";
+import { ReactNode } from "react";
+import * as z3 from "zod/v3";
+import * as z4 from "zod/v4";
+//#region src/types.d.ts
+export type JSONValue = string | number | boolean | JSONObject | JSONArray;
 interface JSONObject {
-    [x: string]: JSONValue | undefined;
+  [x: string]: JSONValue | undefined;
 }
-interface JSONArray extends Array<JSONValue> {
-}
-type AIAction<T = any, R = any> = (...args: T[]) => Promise<R>;
-type AIActions<T = any, R = any> = Record<string, AIAction<T, R>>;
-type ServerWrappedAction<T = unknown> = (aiState: T, ...args: unknown[]) => Promise<[Promise<T>, unknown]>;
-type ServerWrappedActions<T = unknown> = Record<string, ServerWrappedAction<T>>;
-type InternalAIProviderProps<AIState = any, UIState = any> = {
-    children: React.ReactNode;
-    initialUIState: UIState;
-    initialAIState: AIState;
-    initialAIStatePatch: undefined | Promise<AIState>;
-    wrappedActions: ServerWrappedActions<AIState>;
-    wrappedSyncUIState?: ServerWrappedAction<AIState>;
+interface JSONArray extends Array<JSONValue> {}
+export type AIAction<T = any, R = any> = (...args: T[]) => Promise<R>;
+export type AIActions<T = any, R = any> = Record<string, AIAction<T, R>>;
+export type ServerWrappedAction<T = unknown> = (aiState: T, ...args: unknown[]) => Promise<[Promise<T>, unknown]>;
+export type ServerWrappedActions<T = unknown> = Record<string, ServerWrappedAction<T>>;
+export type InternalAIProviderProps<AIState = any, UIState = any> = {
+  children: React.ReactNode;
+  initialUIState: UIState;
+  initialAIState: AIState;
+  initialAIStatePatch: undefined | Promise<AIState>;
+  wrappedActions: ServerWrappedActions<AIState>;
+  wrappedSyncUIState?: ServerWrappedAction<AIState>;
 };
-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;
+export 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 InternalAIStateStorageOptions = {
-    onSetAIState?: OnSetAIState<any>;
+export type AIProvider<AIState = any, UIState = any, Actions = any> = (props: AIProviderProps<AIState, UIState, Actions>) => Promise<React.ReactElement>;
+export type InferAIState<T, Fallback> = T extends AIProvider<infer AIState, any, any> ? AIState : Fallback;
+export type InferUIState<T, Fallback> = T extends AIProvider<any, infer UIState, any> ? UIState : Fallback;
+export type InferActions<T, Fallback> = T extends AIProvider<any, any, infer Actions> ? Actions : Fallback;
+export type InternalAIStateStorageOptions = {
+  onSetAIState?: OnSetAIState<any>;
 };
-type OnSetAIState<S> = ({ key, state, done, }: {
-    key: string | number | symbol | undefined;
-    state: S;
-    done: boolean;
+export 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);
+export type OnGetUIState<S> = AIAction<void, S | undefined>;
+export type ValueOrUpdater<T> = T | ((current: T) => T);
+export type MutableAIState<AIState> = {
+  get: () => AIState;
+  update: (newState: ValueOrUpdater<AIState>) => void;
+  done: ((newState: AIState) => void) | (() => void);
 };
-
+//#endregion
+//#region src/ai-state.d.ts
 /**
  * Get the current AI state.
  * If `key` is provided, it will return the value of the specified key in the
@@ -80,185 +80,182 @@ declare function getAIState<AI extends AIProvider = any>(key: keyof InferAIState
  */
 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]>;
-
-declare function createAI<AIState = any, UIState = any, Actions extends AIActions = {}>({ actions, initialAIState, initialUIState, onSetAIState, onGetUIState, }: {
-    actions: Actions;
-    initialAIState?: AIState;
-    initialUIState?: UIState;
-    /**
-     * This function is called whenever the AI state is updated by an Action.
-     * You can use this to persist the AI state to a database, or to send it to a
-     * logging service.
-     */
-    onSetAIState?: OnSetAIState<AIState>;
-    /**
-     * This function is used to retrieve the UI state based on the AI state.
-     * For example, to render the initial UI state based on a given AI state, or
-     * to sync the UI state when the application is already loaded.
-     *
-     * If returning `undefined`, the client side UI state will not be updated.
-     *
-     * This function must be annotated with the `"use server"` directive.
-     *
-     * @example
-     * ```tsx
-     * onGetUIState: async () => {
-     *   'use server';
-     *
-     *   const currentAIState = getAIState();
-     *   const externalAIState = await loadAIStateFromDatabase();
-     *
-     *   if (currentAIState === externalAIState) return undefined;
-     *
-     *   // Update current AI state and return the new UI state
-     *   const state = getMutableAIState()
-     *   state.done(externalAIState)
-     *
-     *   return <div>...</div>;
-     * }
-     * ```
-     */
-    onGetUIState?: OnGetUIState<UIState>;
+//#endregion
+//#region src/provider.d.ts
+export declare function createAI<AIState = any, UIState = any, Actions extends AIActions = {}>({ actions, initialAIState, initialUIState, onSetAIState, onGetUIState }: {
+  actions: Actions;
+  initialAIState?: AIState;
+  initialUIState?: UIState;
+  /**
+   * This function is called whenever the AI state is updated by an Action.
+   * You can use this to persist the AI state to a database, or to send it to a
+   * logging service.
+   */
+  onSetAIState?: OnSetAIState<AIState>;
+  /**
+   * This function is used to retrieve the UI state based on the AI state.
+   * For example, to render the initial UI state based on a given AI state, or
+   * to sync the UI state when the application is already loaded.
+   *
+   * If returning `undefined`, the client side UI state will not be updated.
+   *
+   * This function must be annotated with the `"use server"` directive.
+   *
+   * @example
+   * ```tsx
+   * onGetUIState: async () => {
+   *   'use server';
+   *
+   *   const currentAIState = getAIState();
+   *   const externalAIState = await loadAIStateFromDatabase();
+   *
+   *   if (currentAIState === externalAIState) return undefined;
+   *
+   *   // Update current AI state and return the new UI state
+   *   const state = getMutableAIState()
+   *   state.done(externalAIState)
+   *
+   *   return <div>...</div>;
+   * }
+   * ```
+   */
+  onGetUIState?: OnGetUIState<UIState>;
 }): AIProvider<AIState, UIState, Actions>;
-
+//#endregion
+//#region src/stream-ui/stream-ui.d.ts
 type Streamable = ReactNode | Promise<ReactNode>;
 type Renderer<T extends Array<any>> = (...args: T) => Streamable | Generator<Streamable, Streamable, void> | AsyncGenerator<Streamable, Streamable, void>;
 type RenderTool<INPUT_SCHEMA extends z4.core.$ZodType | z3.Schema | Schema = any> = {
-    description?: string;
-    inputSchema: INPUT_SCHEMA;
-    generate?: Renderer<[
-        InferSchema<INPUT_SCHEMA>,
-        {
-            toolName: string;
-            toolCallId: string;
-        }
-    ]>;
+  description?: string;
+  inputSchema: INPUT_SCHEMA;
+  generate?: Renderer<[InferSchema<INPUT_SCHEMA>, {
+    toolName: string;
+    toolCallId: string;
+  }]>;
 };
-type RenderText = Renderer<[
-    {
-        /**
-         * The full text content from the model so far.
-         */
-        content: string;
-        /**
-         * The new appended text content from the model since the last `text` call.
-         */
-        delta: string;
-        /**
-         * Whether the model is done generating text.
-         * If `true`, the `content` will be the final output and this call will be the last.
-         */
-        done: boolean;
-    }
-]>;
+type RenderText = Renderer<[{
+  /**
+   * The full text content from the model so far.
+   */
+  content: string;
+  /**
+   * The new appended text content from the model since the last `text` call.
+   */
+  delta: string;
+  /**
+   * Whether the model is done generating text.
+   * If `true`, the `content` will be the final output and this call will be the last.
+   */
+  done: boolean;
+}]>;
 type RenderResult = {
-    value: ReactNode;
+  value: ReactNode;
 } & LanguageModelV4StreamResult;
 /**
  * `streamUI` is a helper function to create a streamable UI from LLMs.
  */
-declare function streamUI<TOOLS extends {
-    [name: string]: z4.core.$ZodType | z3.Schema | Schema;
+export declare function streamUI<TOOLS extends {
+  [name: string]: z4.core.$ZodType | z3.Schema | Schema;
 } = {}>({ model, tools, toolChoice, instructions, system, prompt, messages, allowSystemInMessages, maxRetries, abortSignal, headers, initial, text, providerOptions, onFinish, ...settings }: LanguageModelCallOptions & Omit<RequestOptions, 'timeout'> & Prompt & {
+  /**
+   * The language model to use.
+   */
+  model: LanguageModelV4;
+  /**
+   * The tools that the model can call. The model needs to support calling tools.
+   */
+  tools?: { [name in keyof TOOLS]: RenderTool<TOOLS[name]>; };
+  /**
+   * The tool choice strategy. Default: 'auto'.
+   */
+  toolChoice?: ToolChoice<TOOLS>;
+  text?: RenderText;
+  initial?: ReactNode;
+  /**
+   * Additional provider-specific options. They are passed through
+   * to the provider from the AI SDK and enable provider-specific
+   * functionality that can be fully encapsulated in the provider.
+   */
+  providerOptions?: ProviderOptions;
+  /**
+   * Callback that is called when the LLM response and the final object validation are finished.
+   */
+  onFinish?: (event: {
     /**
-     * The language model to use.
+     * The reason why the generation finished.
      */
-    model: LanguageModelV4;
+    finishReason: FinishReason;
     /**
-     * The tools that the model can call. The model needs to support calling tools.
+     * The token usage of the generated response.
      */
-    tools?: {
-        [name in keyof TOOLS]: RenderTool<TOOLS[name]>;
-    };
+    usage: LanguageModelUsage;
     /**
-     * The tool choice strategy. Default: 'auto'.
+     * The final ui node that was generated.
      */
-    toolChoice?: ToolChoice<TOOLS>;
-    text?: RenderText;
-    initial?: ReactNode;
+    value: ReactNode;
     /**
-     * Additional provider-specific options. They are passed through
-     * to the provider from the AI SDK and enable provider-specific
-     * functionality that can be fully encapsulated in the provider.
+     * Warnings from the model provider (e.g. unsupported settings)
      */
-    providerOptions?: ProviderOptions;
+    warnings?: CallWarning[];
     /**
-     * Callback that is called when the LLM response and the final object validation are finished.
+     * Optional response data.
      */
-    onFinish?: (event: {
-        /**
-         * The reason why the generation finished.
-         */
-        finishReason: FinishReason;
-        /**
-         * The token usage of the generated response.
-         */
-        usage: LanguageModelUsage;
-        /**
-         * The final ui node that was generated.
-         */
-        value: ReactNode;
-        /**
-         * Warnings from the model provider (e.g. unsupported settings)
-         */
-        warnings?: CallWarning[];
-        /**
-         * Optional response data.
-         */
-        response?: {
-            /**
-             * Response headers.
-             */
-            headers?: Record<string, string>;
-        };
-    }) => Promise<void> | void;
+    response?: {
+      /**
+       * Response headers.
+       */
+      headers?: Record<string, string>;
+    };
+  }) => Promise<void> | void;
 }): Promise<RenderResult>;
-
+//#endregion
+//#region src/streamable-ui/create-streamable-ui.d.ts
 type StreamableUIWrapper = {
-    /**
-     * The value of the streamable UI. This can be returned from a Server Action and received by the client.
-     */
-    readonly value: React.ReactNode;
-    /**
-     * This method updates the current UI node. It takes a new UI node and replaces the old one.
-     */
-    update(value: React.ReactNode): StreamableUIWrapper;
-    /**
-     * This method is used to append a new UI node to the end of the old one.
-     * Once appended a new UI node, the previous UI node cannot be updated anymore.
-     *
-     * @example
-     * ```jsx
-     * const ui = createStreamableUI(<div>hello</div>)
-     * ui.append(<div>world</div>)
-     *
-     * // The UI node will be:
-     * // <>
-     * //   <div>hello</div>
-     * //   <div>world</div>
-     * // </>
-     * ```
-     */
-    append(value: React.ReactNode): StreamableUIWrapper;
-    /**
-     * This method is used to signal that there is an error in the UI stream.
-     * It will be thrown on the client side and caught by the nearest error boundary component.
-     */
-    error(error: any): StreamableUIWrapper;
-    /**
-     * This method marks the UI node as finalized. You can either call it without any parameters or with a new UI node as the final state.
-     * Once called, the UI node cannot be updated or appended anymore.
-     *
-     * This method is always **required** to be called, otherwise the response will be stuck in a loading state.
-     */
-    done(...args: [React.ReactNode] | []): StreamableUIWrapper;
+  /**
+   * The value of the streamable UI. This can be returned from a Server Action and received by the client.
+   */
+  readonly value: React.ReactNode;
+  /**
+   * This method updates the current UI node. It takes a new UI node and replaces the old one.
+   */
+  update(value: React.ReactNode): StreamableUIWrapper;
+  /**
+   * This method is used to append a new UI node to the end of the old one.
+   * Once appended a new UI node, the previous UI node cannot be updated anymore.
+   *
+   * @example
+   * ```jsx
+   * const ui = createStreamableUI(<div>hello</div>)
+   * ui.append(<div>world</div>)
+   *
+   * // The UI node will be:
+   * // <>
+   * //   <div>hello</div>
+   * //   <div>world</div>
+   * // </>
+   * ```
+   */
+  append(value: React.ReactNode): StreamableUIWrapper;
+  /**
+   * This method is used to signal that there is an error in the UI stream.
+   * It will be thrown on the client side and caught by the nearest error boundary component.
+   */
+  error(error: any): StreamableUIWrapper;
+  /**
+   * This method marks the UI node as finalized. You can either call it without any parameters or with a new UI node as the final state.
+   * Once called, the UI node cannot be updated or appended anymore.
+   *
+   * This method is always **required** to be called, otherwise the response will be stuck in a loading state.
+   */
+  done(...args: [React.ReactNode] | []): StreamableUIWrapper;
 };
 /**
  * Create a piece of changeable 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): StreamableUIWrapper;
-
+//#endregion
+//#region src/streamable-value/streamable-value.d.ts
 declare const __internal_curr: unique symbol;
 declare const __internal_error: unique symbol;
 /**
@@ -266,56 +263,58 @@ declare const __internal_error: unique symbol;
  * To read the streamed values, use the `readStreamableValue` or `useStreamableValue` APIs.
  */
 type StreamableValue<T = any, E = any> = {
-    [__internal_curr]?: T;
-    [__internal_error]?: E;
+  [__internal_curr]?: T;
+  [__internal_error]?: E;
 };
-
+//#endregion
+//#region src/streamable-value/create-streamable-value.d.ts
 /**
  * Create a wrapped, changeable value that can be streamed to the client.
  * On the client side, the value can be accessed via the readStreamableValue() API.
  */
 declare function createStreamableValue<T = any, E = any>(initialValue?: T | ReadableStream<T>): StreamableValueWrapper<T, E>;
 type StreamableValueWrapper<T, E> = {
-    /**
-     * The value of the streamable. This can be returned from a Server Action and
-     * received by the client. To read the streamed values, use the
-     * `readStreamableValue` or `useStreamableValue` APIs.
-     */
-    readonly value: StreamableValue<T, E>;
-    /**
-     * This method updates the current value with a new one.
-     */
-    update(value: T): StreamableValueWrapper<T, E>;
-    /**
-     * This method is used to append a delta string to the current value. It
-     * requires the current value of the streamable to be a string.
-     *
-     * @example
-     * ```jsx
-     * const streamable = createStreamableValue('hello');
-     * streamable.append(' world');
-     *
-     * // The value will be 'hello world'
-     * ```
-     */
-    append(value: T): StreamableValueWrapper<T, E>;
-    /**
-     * This method is used to signal that there is an error in the value stream.
-     * It will be thrown on the client side when consumed via
-     * `readStreamableValue` or `useStreamableValue`.
-     */
-    error(error: any): StreamableValueWrapper<T, E>;
-    /**
-     * This method marks the value as finalized. You can either call it without
-     * any parameters or with a new value as the final state.
-     * Once called, the value cannot be updated or appended anymore.
-     *
-     * This method is always **required** to be called, otherwise the response
-     * will be stuck in a loading state.
-     */
-    done(...args: [T] | []): StreamableValueWrapper<T, E>;
+  /**
+   * The value of the streamable. This can be returned from a Server Action and
+   * received by the client. To read the streamed values, use the
+   * `readStreamableValue` or `useStreamableValue` APIs.
+   */
+  readonly value: StreamableValue<T, E>;
+  /**
+   * This method updates the current value with a new one.
+   */
+  update(value: T): StreamableValueWrapper<T, E>;
+  /**
+   * This method is used to append a delta string to the current value. It
+   * requires the current value of the streamable to be a string.
+   *
+   * @example
+   * ```jsx
+   * const streamable = createStreamableValue('hello');
+   * streamable.append(' world');
+   *
+   * // The value will be 'hello world'
+   * ```
+   */
+  append(value: T): StreamableValueWrapper<T, E>;
+  /**
+   * This method is used to signal that there is an error in the value stream.
+   * It will be thrown on the client side when consumed via
+   * `readStreamableValue` or `useStreamableValue`.
+   */
+  error(error: any): StreamableValueWrapper<T, E>;
+  /**
+   * This method marks the value as finalized. You can either call it without
+   * any parameters or with a new value as the final state.
+   * Once called, the value cannot be updated or appended anymore.
+   *
+   * This method is always **required** to be called, otherwise the response
+   * will be stuck in a loading state.
+   */
+  done(...args: [T] | []): StreamableValueWrapper<T, E>;
 };
-
+//#endregion
+//#region src/streamable-value/read-streamable-value.d.ts
 /**
  * `readStreamableValue` takes a streamable value created via the `createStreamableValue().value` API,
  * and returns an async iterator.
@@ -346,8 +345,9 @@ type StreamableValueWrapper<T, E> = {
  *
  * This logs out 1, 2, 3 on console.
  */
-declare function readStreamableValue<T = unknown>(streamableValue: StreamableValue<T>): AsyncIterable<T | undefined>;
-
+export declare function readStreamableValue<T = unknown>(streamableValue: StreamableValue<T>): AsyncIterable<T | undefined>;
+//#endregion
+//#region src/streamable-value/use-streamable-value.d.ts
 /**
  * `useStreamableValue` is a React hook that takes a streamable value created via the `createStreamableValue().value` API,
  * and returns the current value, error, and pending state.
@@ -365,18 +365,14 @@ declare function readStreamableValue<T = unknown>(streamableValue: StreamableVal
  * }
  * ```
  */
-declare function useStreamableValue<T = unknown, Error = unknown>(streamableValue?: StreamableValue<T>): [data: T | undefined, error: Error | undefined, pending: boolean];
-
-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 { AIAction, AIActions, AIProvider, AIProviderProps, InferAIState, InferActions, InferUIState, InternalAIProviderProps, InternalAIStateStorageOptions, JSONValue, MutableAIState, OnGetUIState, OnSetAIState, ServerWrappedAction, ServerWrappedActions, StreamableValue, ValueOrUpdater, createAI, createStreamableUI, createStreamableValue, getAIState, getMutableAIState, readStreamableValue, streamUI, useAIState, useActions, useStreamableValue, useSyncUIState, useUIState };
+export declare function useStreamableValue<T = unknown, Error = unknown>(streamableValue?: StreamableValue<T>): [data: T | undefined, error: Error | undefined, pending: boolean];
+//#endregion
+//#region src/shared-client/context.d.ts
+export 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];
+export declare function useActions<AI extends AIProvider = any>(): InferActions<AI, any>;
+export declare function useSyncUIState(): () => Promise<void>;
+//#endregion
+export { type StreamableValue, createStreamableUI, createStreamableValue, getAIState, getMutableAIState, useAIState };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/types.ts","../src/ai-state.tsx","../src/provider.tsx","../src/stream-ui/stream-ui.tsx","../src/streamable-ui/create-streamable-ui.tsx","../src/streamable-value/streamable-value.ts","../src/streamable-value/create-streamable-value.ts","../src/streamable-value/read-streamable-value.tsx","../src/streamable-value/use-streamable-value.tsx","../src/shared-client/context.tsx"],"mappings":"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"}

package/dist/rsc-client.d.ts

@@ -1 +1,2 @@
-export { readStreamableValue, useAIState, useActions, useStreamableValue, useSyncUIState, useUIState } from './rsc-shared.js';
+import { readStreamableValue, useAIState, useActions, useStreamableValue, useSyncUIState, useUIState } from "./rsc-shared.js";
+export { readStreamableValue, useAIState, useActions, useStreamableValue, useSyncUIState, useUIState };

package/dist/rsc-client.js

@@ -1,18 +1,2 @@
-// src/rsc-client.ts
-import {
-  readStreamableValue,
-  useStreamableValue,
-  useUIState,
-  useAIState,
-  useActions,
-  useSyncUIState
-} from "./rsc-shared.js";
-export {
-  readStreamableValue,
-  useAIState,
-  useActions,
-  useStreamableValue,
-  useSyncUIState,
-  useUIState
-};
-//# sourceMappingURL=rsc-client.js.map
+import { readStreamableValue, useAIState, useActions, useStreamableValue, useSyncUIState, useUIState } from "./rsc-shared.js";
+export { readStreamableValue, useAIState, useActions, useStreamableValue, useSyncUIState, useUIState };