@assistant-ui/react 0.11.35 → 0.11.36

package/dist/utils/tap-store/derived-scopes.d.ts

@@ -0,0 +1,81 @@
+import type { AssistantApi, AssistantApiField } from "../../context/react/AssistantApiContext";
+import type { AssistantEvent, AssistantEventCallback, AssistantEventSelector } from "../../types/EventTypes";
+import type { ResourceElement, Unsubscribe } from "@assistant-ui/tap";
+/**
+ * Extract the API return type from an AssistantApiField
+ */
+type ExtractApiType<T> = T extends AssistantApiField<infer TApi, any> ? TApi : never;
+/**
+ * Extract the metadata type from an AssistantApiField
+ *
+ * Used in DerivedScopesInput to validate that each field's source/query types match
+ * the expected types from AssistantApi.
+ */
+type ExtractMeta<T> = T extends AssistantApiField<any, infer TMeta> ? TMeta : never;
+/**
+ * Get only the field names from AssistantApi (exclude method names)
+ */
+type AssistantApiFieldNames = {
+    [K in keyof AssistantApi]: AssistantApi[K] extends {
+        source: any;
+        query: any;
+    } ? K : never;
+}[keyof AssistantApi];
+/**
+ * Configuration for a derived scope field - infers types from the actual values provided
+ */
+export type DerivedScopeConfig<TSource extends string | null, TQuery, TApi> = {
+    source: TSource;
+    query: TQuery;
+    get: () => TApi;
+};
+/**
+ * Type for the special `on` callback function
+ */
+export type OnCallbackFn = <TEvent extends AssistantEvent>(selector: AssistantEventSelector<TEvent>, callback: AssistantEventCallback<TEvent>) => Unsubscribe;
+/**
+ * Type for the special `subscribe` callback function
+ */
+export type SubscribeCallbackFn = (listener: () => void) => Unsubscribe;
+/**
+ * Type for the special `flushSync` callback function
+ */
+export type FlushSyncCallbackFn = () => void;
+/**
+ * Type for special non-field functions in AssistantApi
+ */
+export type SpecialCallbacks = {
+    on?: OnCallbackFn;
+    subscribe?: SubscribeCallbackFn;
+    flushSync?: FlushSyncCallbackFn;
+};
+/**
+ * Type for the scopes parameter - allows both DerivedScope elements and special callbacks.
+ * Field names are restricted to valid AssistantApi field names.
+ * TypeScript validates that the source/query/get types match the expected field type.
+ */
+export type DerivedScopesInput = {
+    [K in AssistantApiFieldNames]?: ResourceElement<AssistantApiField<ExtractApiType<AssistantApi[K]>, {
+        source: ExtractMeta<AssistantApi[K]>["source"];
+        query: ExtractMeta<AssistantApi[K]>["query"];
+    }>>;
+} & SpecialCallbacks;
+/**
+ * DerivedScope resource - memoizes an AssistantApiField based on source and query.
+ * The get callback always calls the most recent version (useEffectEvent pattern).
+ * TypeScript infers TSource, TQuery, and TApi from the config object.
+ * Validation happens at the DerivedScopesInput level.
+ */
+export declare const DerivedScope: <TSource extends string | null, TQuery, TApi>(props: DerivedScopeConfig<TSource, TQuery, TApi>, options?: {
+    key?: string | number;
+} | undefined) => ResourceElement<AssistantApiField<TApi, {
+    source: TSource;
+    query: TQuery;
+}>, DerivedScopeConfig<TSource, TQuery, TApi>>;
+/**
+ * DerivedScopes resource - takes an object of DerivedScope resource elements and special callbacks,
+ * and returns a Partial<AssistantApi> with all the derived fields.
+ */
+export declare const DerivedScopes: import("@assistant-ui/tap").ResourceElementConstructor<Partial<AssistantApi>, DerivedScopesInput>;
+export {};
+//# sourceMappingURL=derived-scopes.d.ts.map

package/dist/utils/tap-store/derived-scopes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"derived-scopes.d.ts","sourceRoot":"","sources":["../../../src/utils/tap-store/derived-scopes.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,YAAY,EACZ,iBAAiB,EAClB,MAAM,yCAAyC,CAAC;AACjD,OAAO,KAAK,EACV,cAAc,EACd,sBAAsB,EACtB,sBAAsB,EACvB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEtE;;GAEG;AACH,KAAK,cAAc,CAAC,CAAC,IACnB,CAAC,SAAS,iBAAiB,CAAC,MAAM,IAAI,EAAE,GAAG,CAAC,GAAG,IAAI,GAAG,KAAK,CAAC;AAE9D;;;;;GAKG;AACH,KAAK,WAAW,CAAC,CAAC,IAChB,CAAC,SAAS,iBAAiB,CAAC,GAAG,EAAE,MAAM,KAAK,CAAC,GAAG,KAAK,GAAG,KAAK,CAAC;AAEhE;;GAEG;AACH,KAAK,sBAAsB,GAAG;KAC3B,CAAC,IAAI,MAAM,YAAY,GAAG,YAAY,CAAC,CAAC,CAAC,SAAS;QAAE,MAAM,EAAE,GAAG,CAAC;QAAC,KAAK,EAAE,GAAG,CAAA;KAAE,GAC1E,CAAC,GACD,KAAK;CACV,CAAC,MAAM,YAAY,CAAC,CAAC;AAEtB;;GAEG;AACH,MAAM,MAAM,kBAAkB,CAAC,OAAO,SAAS,MAAM,GAAG,IAAI,EAAE,MAAM,EAAE,IAAI,IAAI;IAC5E,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,IAAI,CAAC;CACjB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,MAAM,SAAS,cAAc,EACvD,QAAQ,EAAE,sBAAsB,CAAC,MAAM,CAAC,EACxC,QAAQ,EAAE,sBAAsB,CAAC,MAAM,CAAC,KACrC,WAAW,CAAC;AAEjB;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,WAAW,CAAC;AAExE;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG,MAAM,IAAI,CAAC;AAE7C;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,CAAC,EAAE,YAAY,CAAC;IAClB,SAAS,CAAC,EAAE,mBAAmB,CAAC;IAChC,SAAS,CAAC,EAAE,mBAAmB,CAAC;CACjC,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAAG;KAC9B,CAAC,IAAI,sBAAsB,CAAC,CAAC,EAAE,eAAe,CAC7C,iBAAiB,CACf,cAAc,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,EAC/B;QACE,MAAM,EAAE,WAAW,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;QAC/C,KAAK,EAAE,WAAW,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;KAC9C,CACF,CACF;CACF,GAAG,gBAAgB,CAAC;AAErB;;;;;GAKG;AACH,eAAO,MAAM,YAAY,GACtB,OAAO,SAAS,MAAM,GAAG,IAAI,EAAE,MAAM,EAAE,IAAI;;;YAKhC,OAAO;WACR,MAAM;8CAgBlB,CAAC;AAmBF;;;GAGG;AACH,eAAO,MAAM,aAAa,mGAyCzB,CAAC"}

package/dist/utils/tap-store/derived-scopes.js

@@ -0,0 +1,67 @@
+// src/utils/tap-store/derived-scopes.ts
+import { resource, tapEffect } from "@assistant-ui/tap";
+import { tapMemo, tapRef, tapResource, tapResources } from "@assistant-ui/tap";
+import { createAssistantApiField } from "../../context/react/AssistantApiContext.js";
+var DerivedScope = resource(
+  (config) => {
+    const getRef = tapRef(config.get);
+    tapEffect(() => {
+      getRef.current = config.get;
+    });
+    return tapMemo(() => {
+      return createAssistantApiField({
+        source: config.source,
+        query: config.query,
+        get: () => getRef.current()
+      });
+    }, [config.source, JSON.stringify(config.query)]);
+  }
+);
+var ScopeFieldWithNameResource = resource(
+  (config) => {
+    const field = tapResource(config.scopeElement);
+    return tapMemo(
+      () => [config.fieldName, field],
+      [config.fieldName, field]
+    );
+  }
+);
+var DerivedScopes = resource(
+  (scopes) => {
+    const { on, subscribe, flushSync, ...scopeFields } = scopes;
+    const callbacksRef = tapRef({ on, subscribe, flushSync });
+    tapEffect(() => {
+      callbacksRef.current = { on, subscribe, flushSync };
+    });
+    const results = tapResources(
+      Object.entries(scopeFields).map(
+        ([fieldName, scopeElement]) => ScopeFieldWithNameResource(
+          {
+            fieldName,
+            scopeElement
+          },
+          { key: fieldName }
+        )
+      )
+    );
+    return tapMemo(() => {
+      const result = Object.fromEntries(results);
+      const {
+        on: onCb,
+        subscribe: subCb,
+        flushSync: flushCb
+      } = callbacksRef.current;
+      if (onCb) {
+        result.on = (selector, callback) => onCb(selector, callback);
+      }
+      if (subCb) result.subscribe = (listener) => subCb(listener);
+      if (flushCb) result.flushSync = () => flushCb();
+      return result;
+    }, [...results]);
+  }
+);
+export {
+  DerivedScope,
+  DerivedScopes
+};
+//# sourceMappingURL=derived-scopes.js.map

package/dist/utils/tap-store/derived-scopes.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/tap-store/derived-scopes.ts"],"sourcesContent":["import { resource, tapEffect } from \"@assistant-ui/tap\";\nimport { tapMemo, tapRef, tapResource, tapResources } from \"@assistant-ui/tap\";\nimport { createAssistantApiField } from \"../../context/react/AssistantApiContext\";\nimport type {\n  AssistantApi,\n  AssistantApiField,\n} from \"../../context/react/AssistantApiContext\";\nimport type {\n  AssistantEvent,\n  AssistantEventCallback,\n  AssistantEventSelector,\n} from \"../../types/EventTypes\";\nimport type { ResourceElement, Unsubscribe } from \"@assistant-ui/tap\";\n\n/**\n * Extract the API return type from an AssistantApiField\n */\ntype ExtractApiType<T> =\n  T extends AssistantApiField<infer TApi, any> ? TApi : never;\n\n/**\n * Extract the metadata type from an AssistantApiField\n *\n * Used in DerivedScopesInput to validate that each field's source/query types match\n * the expected types from AssistantApi.\n */\ntype ExtractMeta<T> =\n  T extends AssistantApiField<any, infer TMeta> ? TMeta : never;\n\n/**\n * Get only the field names from AssistantApi (exclude method names)\n */\ntype AssistantApiFieldNames = {\n  [K in keyof AssistantApi]: AssistantApi[K] extends { source: any; query: any }\n    ? K\n    : never;\n}[keyof AssistantApi];\n\n/**\n * Configuration for a derived scope field - infers types from the actual values provided\n */\nexport type DerivedScopeConfig<TSource extends string | null, TQuery, TApi> = {\n  source: TSource;\n  query: TQuery;\n  get: () => TApi;\n};\n\n/**\n * Type for the special `on` callback function\n */\nexport type OnCallbackFn = <TEvent extends AssistantEvent>(\n  selector: AssistantEventSelector<TEvent>,\n  callback: AssistantEventCallback<TEvent>,\n) => Unsubscribe;\n\n/**\n * Type for the special `subscribe` callback function\n */\nexport type SubscribeCallbackFn = (listener: () => void) => Unsubscribe;\n\n/**\n * Type for the special `flushSync` callback function\n */\nexport type FlushSyncCallbackFn = () => void;\n\n/**\n * Type for special non-field functions in AssistantApi\n */\nexport type SpecialCallbacks = {\n  on?: OnCallbackFn;\n  subscribe?: SubscribeCallbackFn;\n  flushSync?: FlushSyncCallbackFn;\n};\n\n/**\n * Type for the scopes parameter - allows both DerivedScope elements and special callbacks.\n * Field names are restricted to valid AssistantApi field names.\n * TypeScript validates that the source/query/get types match the expected field type.\n */\nexport type DerivedScopesInput = {\n  [K in AssistantApiFieldNames]?: ResourceElement<\n    AssistantApiField<\n      ExtractApiType<AssistantApi[K]>,\n      {\n        source: ExtractMeta<AssistantApi[K]>[\"source\"];\n        query: ExtractMeta<AssistantApi[K]>[\"query\"];\n      }\n    >\n  >;\n} & SpecialCallbacks;\n\n/**\n * DerivedScope resource - memoizes an AssistantApiField based on source and query.\n * The get callback always calls the most recent version (useEffectEvent pattern).\n * TypeScript infers TSource, TQuery, and TApi from the config object.\n * Validation happens at the DerivedScopesInput level.\n */\nexport const DerivedScope = resource(\n  <TSource extends string | null, TQuery, TApi>(\n    config: DerivedScopeConfig<TSource, TQuery, TApi>,\n  ): AssistantApiField<\n    TApi,\n    {\n      source: TSource;\n      query: TQuery;\n    }\n  > => {\n    const getRef = tapRef(config.get);\n    tapEffect(() => {\n      getRef.current = config.get;\n    });\n\n    return tapMemo(() => {\n      return createAssistantApiField({\n        source: config.source,\n        query: config.query,\n        get: () => getRef.current(),\n      });\n    }, [config.source, JSON.stringify(config.query)]);\n  },\n);\n\n/**\n * Helper resource to wrap each scope field - stable resource identity for proper memoization.\n * Creating this outside the map ensures tapResources can properly track and memoize each field.\n */\nconst ScopeFieldWithNameResource = resource(\n  (config: {\n    fieldName: string;\n    scopeElement: ReturnType<typeof DerivedScope>;\n  }) => {\n    const field = tapResource(config.scopeElement);\n    return tapMemo(\n      () => [config.fieldName, field] as const,\n      [config.fieldName, field],\n    );\n  },\n);\n\n/**\n * DerivedScopes resource - takes an object of DerivedScope resource elements and special callbacks,\n * and returns a Partial<AssistantApi> with all the derived fields.\n */\nexport const DerivedScopes = resource(\n  (scopes: DerivedScopesInput): Partial<AssistantApi> => {\n    const { on, subscribe, flushSync, ...scopeFields } = scopes;\n    const callbacksRef = tapRef({ on, subscribe, flushSync });\n    tapEffect(() => {\n      callbacksRef.current = { on, subscribe, flushSync };\n    });\n\n    const results = tapResources(\n      Object.entries(scopeFields).map(([fieldName, scopeElement]) =>\n        ScopeFieldWithNameResource(\n          {\n            fieldName,\n            scopeElement: scopeElement as ReturnType<typeof DerivedScope>,\n          },\n          { key: fieldName },\n        ),\n      ),\n    );\n\n    return tapMemo(() => {\n      const result = Object.fromEntries(results) as Partial<AssistantApi>;\n\n      const {\n        on: onCb,\n        subscribe: subCb,\n        flushSync: flushCb,\n      } = callbacksRef.current;\n\n      if (onCb) {\n        result.on = <TEvent extends AssistantEvent>(\n          selector: AssistantEventSelector<TEvent>,\n          callback: AssistantEventCallback<TEvent>,\n        ) => onCb(selector, callback);\n      }\n      if (subCb) result.subscribe = (listener) => subCb(listener);\n      if (flushCb) result.flushSync = () => flushCb();\n\n      return result;\n    }, [...results]);\n  },\n);\n"],"mappings":";AAAA,SAAS,UAAU,iBAAiB;AACpC,SAAS,SAAS,QAAQ,aAAa,oBAAoB;AAC3D,SAAS,+BAA+B;AA+FjC,IAAM,eAAe;AAAA,EAC1B,CACE,WAOG;AACH,UAAM,SAAS,OAAO,OAAO,GAAG;AAChC,cAAU,MAAM;AACd,aAAO,UAAU,OAAO;AAAA,IAC1B,CAAC;AAED,WAAO,QAAQ,MAAM;AACnB,aAAO,wBAAwB;AAAA,QAC7B,QAAQ,OAAO;AAAA,QACf,OAAO,OAAO;AAAA,QACd,KAAK,MAAM,OAAO,QAAQ;AAAA,MAC5B,CAAC;AAAA,IACH,GAAG,CAAC,OAAO,QAAQ,KAAK,UAAU,OAAO,KAAK,CAAC,CAAC;AAAA,EAClD;AACF;AAMA,IAAM,6BAA6B;AAAA,EACjC,CAAC,WAGK;AACJ,UAAM,QAAQ,YAAY,OAAO,YAAY;AAC7C,WAAO;AAAA,MACL,MAAM,CAAC,OAAO,WAAW,KAAK;AAAA,MAC9B,CAAC,OAAO,WAAW,KAAK;AAAA,IAC1B;AAAA,EACF;AACF;AAMO,IAAM,gBAAgB;AAAA,EAC3B,CAAC,WAAsD;AACrD,UAAM,EAAE,IAAI,WAAW,WAAW,GAAG,YAAY,IAAI;AACrD,UAAM,eAAe,OAAO,EAAE,IAAI,WAAW,UAAU,CAAC;AACxD,cAAU,MAAM;AACd,mBAAa,UAAU,EAAE,IAAI,WAAW,UAAU;AAAA,IACpD,CAAC;AAED,UAAM,UAAU;AAAA,MACd,OAAO,QAAQ,WAAW,EAAE;AAAA,QAAI,CAAC,CAAC,WAAW,YAAY,MACvD;AAAA,UACE;AAAA,YACE;AAAA,YACA;AAAA,UACF;AAAA,UACA,EAAE,KAAK,UAAU;AAAA,QACnB;AAAA,MACF;AAAA,IACF;AAEA,WAAO,QAAQ,MAAM;AACnB,YAAM,SAAS,OAAO,YAAY,OAAO;AAEzC,YAAM;AAAA,QACJ,IAAI;AAAA,QACJ,WAAW;AAAA,QACX,WAAW;AAAA,MACb,IAAI,aAAa;AAEjB,UAAI,MAAM;AACR,eAAO,KAAK,CACV,UACA,aACG,KAAK,UAAU,QAAQ;AAAA,MAC9B;AACA,UAAI,MAAO,QAAO,YAAY,CAAC,aAAa,MAAM,QAAQ;AAC1D,UAAI,QAAS,QAAO,YAAY,MAAM,QAAQ;AAE9C,aAAO;AAAA,IACT,GAAG,CAAC,GAAG,OAAO,CAAC;AAAA,EACjB;AACF;","names":[]}

package/dist/utils/tap-store/index.d.ts

@@ -1,3 +1,4 @@
 export { type Store, asStore } from "./store";
 export { tapApi, type ApiObject } from "./tap-api";
+export { DerivedScope, type DerivedScopeConfig, type OnCallbackFn, type SubscribeCallbackFn, type FlushSyncCallbackFn, type SpecialCallbacks, type DerivedScopesInput, } from "./derived-scopes";
 //# sourceMappingURL=index.d.ts.map

package/dist/utils/tap-store/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/tap-store/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAC9C,OAAO,EAAE,MAAM,EAAE,KAAK,SAAS,EAAE,MAAM,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/tap-store/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAC9C,OAAO,EAAE,MAAM,EAAE,KAAK,SAAS,EAAE,MAAM,WAAW,CAAC;AACnD,OAAO,EACL,YAAY,EACZ,KAAK,kBAAkB,EACvB,KAAK,YAAY,EACjB,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,GACxB,MAAM,kBAAkB,CAAC"}

package/dist/utils/tap-store/index.js

@@ -1,7 +1,11 @@
 // src/utils/tap-store/index.ts
 import { asStore } from "./store.js";
 import { tapApi } from "./tap-api.js";
+import {
+  DerivedScope
+} from "./derived-scopes.js";
 export {
+  DerivedScope,
   asStore,
   tapApi
 };

package/dist/utils/tap-store/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/utils/tap-store/index.ts"],"sourcesContent":["export { type Store, asStore } from \"./store\";\nexport { tapApi, type ApiObject } from \"./tap-api\";\n"],"mappings":";AAAA,SAAqB,eAAe;AACpC,SAAS,cAA8B;","names":[]}
+{"version":3,"sources":["../../../src/utils/tap-store/index.ts"],"sourcesContent":["export { type Store, asStore } from \"./store\";\nexport { tapApi, type ApiObject } from \"./tap-api\";\nexport {\n  DerivedScope,\n  type DerivedScopeConfig,\n  type OnCallbackFn,\n  type SubscribeCallbackFn,\n  type FlushSyncCallbackFn,\n  type SpecialCallbacks,\n  type DerivedScopesInput,\n} from \"./derived-scopes\";\n"],"mappings":";AAAA,SAAqB,eAAe;AACpC,SAAS,cAA8B;AACvC;AAAA,EACE;AAAA,OAOK;","names":[]}

package/dist/utils/tap-store/tap-api.js

@@ -27,7 +27,7 @@ var ReadonlyApiHandler = class {
   }
 };
 var tapApi = (api, options) => {
-  const ref = tapRef(() => api);
+  const ref = tapRef(api);
   tapEffect(() => {
     ref.current = api;
   });

package/dist/utils/tap-store/tap-api.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/utils/tap-store/tap-api.ts"],"sourcesContent":["import { tapEffect, tapMemo, tapRef } from \"@assistant-ui/tap\";\n\nexport interface ApiObject {\n  [key: string]: ((...args: any[]) => any) | ApiObject;\n}\n\nclass ReadonlyApiHandler<TApi extends ApiObject> implements ProxyHandler<TApi> {\n  constructor(private readonly getApi: () => TApi) {}\n\n  get(_: unknown, prop: string | symbol) {\n    return this.getApi()[prop as keyof TApi];\n  }\n\n  ownKeys(): ArrayLike<string | symbol> {\n    return Object.keys(this.getApi() as object);\n  }\n\n  has(_: unknown, prop: string | symbol) {\n    return prop in (this.getApi() as object);\n  }\n\n  getOwnPropertyDescriptor(_: unknown, prop: string | symbol) {\n    return Object.getOwnPropertyDescriptor(this.getApi(), prop);\n  }\n\n  set() {\n    return false;\n  }\n  defineProperty() {\n    return false;\n  }\n  deleteProperty() {\n    return false;\n  }\n}\n\nexport const tapApi = <TApi extends ApiObject & { getState: () => any }>(\n  api: TApi,\n  options?: {\n    key?: string | undefined;\n  },\n) => {\n  const ref = tapRef(() => api);\n  tapEffect(() => {\n    ref.current = api;\n  });\n\n  const apiProxy = tapMemo(\n    () =>\n      new Proxy<TApi>({} as TApi, new ReadonlyApiHandler(() => ref.current)),\n    [],\n  );\n\n  const key = options?.key;\n  const state = api.getState();\n\n  return tapMemo(\n    () => ({\n      key,\n      state,\n      api: apiProxy,\n    }),\n    [state, key],\n  );\n};\n"],"mappings":";AAAA,SAAS,WAAW,SAAS,cAAc;AAM3C,IAAM,qBAAN,MAA+E;AAAA,EAC7E,YAA6B,QAAoB;AAApB;AAAA,EAAqB;AAAA,EAElD,IAAI,GAAY,MAAuB;AACrC,WAAO,KAAK,OAAO,EAAE,IAAkB;AAAA,EACzC;AAAA,EAEA,UAAsC;AACpC,WAAO,OAAO,KAAK,KAAK,OAAO,CAAW;AAAA,EAC5C;AAAA,EAEA,IAAI,GAAY,MAAuB;AACrC,WAAO,QAAS,KAAK,OAAO;AAAA,EAC9B;AAAA,EAEA,yBAAyB,GAAY,MAAuB;AAC1D,WAAO,OAAO,yBAAyB,KAAK,OAAO,GAAG,IAAI;AAAA,EAC5D;AAAA,EAEA,MAAM;AACJ,WAAO;AAAA,EACT;AAAA,EACA,iBAAiB;AACf,WAAO;AAAA,EACT;AAAA,EACA,iBAAiB;AACf,WAAO;AAAA,EACT;AACF;AAEO,IAAM,SAAS,CACpB,KACA,YAGG;AACH,QAAM,MAAM,OAAO,MAAM,GAAG;AAC5B,YAAU,MAAM;AACd,QAAI,UAAU;AAAA,EAChB,CAAC;AAED,QAAM,WAAW;AAAA,IACf,MACE,IAAI,MAAY,CAAC,GAAW,IAAI,mBAAmB,MAAM,IAAI,OAAO,CAAC;AAAA,IACvE,CAAC;AAAA,EACH;AAEA,QAAM,MAAM,SAAS;AACrB,QAAM,QAAQ,IAAI,SAAS;AAE3B,SAAO;AAAA,IACL,OAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA,KAAK;AAAA,IACP;AAAA,IACA,CAAC,OAAO,GAAG;AAAA,EACb;AACF;","names":[]}
+{"version":3,"sources":["../../../src/utils/tap-store/tap-api.ts"],"sourcesContent":["import { tapEffect, tapMemo, tapRef } from \"@assistant-ui/tap\";\n\nexport interface ApiObject {\n  [key: string]: ((...args: any[]) => any) | ApiObject;\n}\n\nclass ReadonlyApiHandler<TApi extends ApiObject> implements ProxyHandler<TApi> {\n  constructor(private readonly getApi: () => TApi) {}\n\n  get(_: unknown, prop: string | symbol) {\n    return this.getApi()[prop as keyof TApi];\n  }\n\n  ownKeys(): ArrayLike<string | symbol> {\n    return Object.keys(this.getApi() as object);\n  }\n\n  has(_: unknown, prop: string | symbol) {\n    return prop in (this.getApi() as object);\n  }\n\n  getOwnPropertyDescriptor(_: unknown, prop: string | symbol) {\n    return Object.getOwnPropertyDescriptor(this.getApi(), prop);\n  }\n\n  set() {\n    return false;\n  }\n  defineProperty() {\n    return false;\n  }\n  deleteProperty() {\n    return false;\n  }\n}\n\nexport const tapApi = <TApi extends ApiObject & { getState: () => any }>(\n  api: TApi,\n  options?: {\n    key?: string | undefined;\n  },\n) => {\n  const ref = tapRef(api);\n  tapEffect(() => {\n    ref.current = api;\n  });\n\n  const apiProxy = tapMemo(\n    () =>\n      new Proxy<TApi>({} as TApi, new ReadonlyApiHandler(() => ref.current)),\n    [],\n  );\n\n  const key = options?.key;\n  const state = api.getState();\n\n  return tapMemo(\n    () => ({\n      key,\n      state,\n      api: apiProxy,\n    }),\n    [state, key],\n  );\n};\n"],"mappings":";AAAA,SAAS,WAAW,SAAS,cAAc;AAM3C,IAAM,qBAAN,MAA+E;AAAA,EAC7E,YAA6B,QAAoB;AAApB;AAAA,EAAqB;AAAA,EAElD,IAAI,GAAY,MAAuB;AACrC,WAAO,KAAK,OAAO,EAAE,IAAkB;AAAA,EACzC;AAAA,EAEA,UAAsC;AACpC,WAAO,OAAO,KAAK,KAAK,OAAO,CAAW;AAAA,EAC5C;AAAA,EAEA,IAAI,GAAY,MAAuB;AACrC,WAAO,QAAS,KAAK,OAAO;AAAA,EAC9B;AAAA,EAEA,yBAAyB,GAAY,MAAuB;AAC1D,WAAO,OAAO,yBAAyB,KAAK,OAAO,GAAG,IAAI;AAAA,EAC5D;AAAA,EAEA,MAAM;AACJ,WAAO;AAAA,EACT;AAAA,EACA,iBAAiB;AACf,WAAO;AAAA,EACT;AAAA,EACA,iBAAiB;AACf,WAAO;AAAA,EACT;AACF;AAEO,IAAM,SAAS,CACpB,KACA,YAGG;AACH,QAAM,MAAM,OAAO,GAAG;AACtB,YAAU,MAAM;AACd,QAAI,UAAU;AAAA,EAChB,CAAC;AAED,QAAM,WAAW;AAAA,IACf,MACE,IAAI,MAAY,CAAC,GAAW,IAAI,mBAAmB,MAAM,IAAI,OAAO,CAAC;AAAA,IACvE,CAAC;AAAA,EACH;AAEA,QAAM,MAAM,SAAS;AACrB,QAAM,QAAQ,IAAI,SAAS;AAE3B,SAAO;AAAA,IACL,OAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA,KAAK;AAAA,IACP;AAAA,IACA,CAAC,OAAO,GAAG;AAAA,EACb;AACF;","names":[]}

package/package.json

@@ -28,7 +28,7 @@
     "conversational-ui",
     "conversational-ai"
   ],
-  "version": "0.11.35",
+  "version": "0.11.36",
   "license": "MIT",
   "type": "module",
   "exports": {
@@ -48,8 +48,8 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "assistant-cloud": "^0.1.5",
-    "@assistant-ui/tap": "^0.1.4",
+    "assistant-cloud": "^0.1.6",
+    "@assistant-ui/tap": "^0.1.5",
     "@radix-ui/primitive": "^1.1.3",
     "@radix-ui/react-compose-refs": "^1.1.2",
     "@radix-ui/react-context": "^1.1.2",
@@ -59,7 +59,7 @@
     "@radix-ui/react-use-callback-ref": "^1.1.1",
     "@radix-ui/react-use-escape-keydown": "^1.1.1",
     "@standard-schema/spec": "^1.0.0",
-    "assistant-stream": "^0.2.38",
+    "assistant-stream": "^0.2.39",
     "json-schema": "^0.4.0",
     "nanoid": "5.1.6",
     "react-textarea-autosize": "^8.5.9",
@@ -81,14 +81,14 @@
     }
   },
   "devDependencies": {
-    "@stryker-mutator/core": "^9.2.0",
-    "@stryker-mutator/vitest-runner": "^9.2.0",
+    "@stryker-mutator/core": "^9.3.0",
+    "@stryker-mutator/vitest-runner": "^9.3.0",
     "@types/json-schema": "^7.0.15",
-    "@types/node": "^24.9.1",
+    "@types/node": "^24.10.0",
     "eslint": "^9",
-    "eslint-config-next": "16.0.0",
+    "eslint-config-next": "16.0.1",
     "tsx": "^4.20.6",
-    "vitest": "^4.0.1",
+    "vitest": "^4.0.6",
     "@assistant-ui/x-buildutils": "0.0.1"
   },
   "publishConfig": {

package/src/client/AssistantClient.ts

@@ -7,8 +7,7 @@ import {
   tapResource,
 } from "@assistant-ui/tap";
 import { ThreadListClientApi, ThreadListClientState } from "./types/ThreadList";
-import { AssistantRuntime } from "../legacy-runtime/runtime/AssistantRuntime";
-import { ModelContextProvider } from "../model-context";
+import { Tools } from "../model-context";
 import { asStore, Store, tapApi } from "../utils/tap-store";
 import { useResource } from "@assistant-ui/tap/react";
 import { useMemo } from "react";
@@ -22,14 +21,23 @@ import { EventManager } from "../legacy-runtime/client/EventManagerRuntimeClient
 import {
   AssistantApi,
   createAssistantApiField,
+  useAssistantApiImpl,
+  extendApi,
 } from "../context/react/AssistantApiContext";
 import { ToolUIClient } from "./ToolUIClient";
 import { withEventsProvider } from "./EventContext";
+import { withModelContextProvider } from "./ModelContext";
+import { withToolUIProvider } from "./ToolUIContext";
 import { ToolUIApi, ToolUIState } from "./types/ToolUI";
+import { ToolsApi, ToolsState } from "./types/Tools";
+import { ModelContextApi, ModelContextState } from "./types/ModelContext";
+import { ModelContext as ModelContextResource } from "./ModelContextClient";
 
 type AssistantClientState = {
   readonly threads: ThreadListClientState;
   readonly toolUIs: ToolUIState;
+  readonly tools: ToolsState;
+  readonly modelContext: ModelContextState;
 };
 
 type AssistantClientApi = {
@@ -37,39 +45,53 @@ type AssistantClientApi = {
 
   readonly threads: ThreadListClientApi;
   readonly toolUIs: ToolUIApi;
+  readonly tools: ToolsApi;
+  readonly modelContext: ModelContextApi;
 
   on<TEvent extends AssistantEvent>(
     event: TEvent,
     callback: AssistantEventCallback<TEvent>,
   ): Unsubscribe;
-
-  registerModelContextProvider(provider: ModelContextProvider): Unsubscribe;
-
-  /** @internal */
-  __internal_getRuntime?(): AssistantRuntime;
 };
 
 const AssistantStore = resource(
   ({
     threads: threadsEl,
-    registerModelContextProvider,
-    __internal_runtime,
+    modelContext: modelContextEl,
+    tools: toolsEl,
   }: AssistantClientProps) => {
     const events = tapInlineResource(EventManager());
-
-    const { threads, toolUIs } = withEventsProvider(events, () => {
-      return {
-        toolUIs: tapInlineResource(ToolUIClient()),
-        threads: tapResource(threadsEl, [threadsEl]),
-      };
-    });
+    const toolUIsResource = tapInlineResource(ToolUIClient());
+
+    const { threads, toolUIs, tools, modelContext } = withEventsProvider(
+      events,
+      () => {
+        const modelContextResource = tapResource(
+          modelContextEl ?? ModelContextResource(),
+          [modelContextEl],
+        );
+
+        return withModelContextProvider(modelContextResource.api, () => {
+          return withToolUIProvider(toolUIsResource.api, () => {
+            return {
+              toolUIs: toolUIsResource,
+              modelContext: modelContextResource,
+              tools: tapResource(toolsEl ?? Tools({}), [toolsEl]),
+              threads: tapResource(threadsEl, [threadsEl]),
+            };
+          });
+        });
+      },
+    );
 
     const state = tapMemo<AssistantClientState>(
       () => ({
         threads: threads.state,
         toolUIs: toolUIs.state,
+        tools: tools.state,
+        modelContext: modelContext.state,
       }),
-      [threads.state, toolUIs.state],
+      [threads.state, toolUIs.state, tools.state, modelContext.state],
     );
 
     return tapApi<AssistantClientApi>({
@@ -77,13 +99,9 @@ const AssistantStore = resource(
 
       threads: threads.api,
       toolUIs: toolUIs.api,
+      tools: tools.api,
+      modelContext: modelContext.api,
       on: events.on,
-
-      registerModelContextProvider:
-        registerModelContextProvider ?? (() => () => {}),
-      ...(__internal_runtime && {
-        __internal_getRuntime: () => __internal_runtime,
-      }),
     });
   },
 );
@@ -103,6 +121,16 @@ const getClientFromStore = (client: Store<{ api: AssistantClientApi }>) => {
       query: {},
       get: () => client.getState().api.toolUIs,
     }),
+    tools: createAssistantApiField({
+      source: "root",
+      query: {},
+      get: () => client.getState().api.tools,
+    }),
+    modelContext: createAssistantApiField({
+      source: "root",
+      query: {},
+      get: () => client.getState().api.modelContext,
+    }),
     thread: createAssistantApiField({
       source: "threads",
       query: { type: "main" },
@@ -118,14 +146,6 @@ const getClientFromStore = (client: Store<{ api: AssistantClientApi }>) => {
       query: {},
       get: () => client.getState().api.threads.thread("main").composer,
     }),
-    registerModelContextProvider(provider: ModelContextProvider) {
-      return client.getState().api.registerModelContextProvider(provider);
-    },
-    ...(client.getState().api.__internal_getRuntime && {
-      __internal_getRuntime() {
-        return client.getState().api.__internal_getRuntime!();
-      },
-    }),
     on(selector, callback) {
       const { event, scope } = normalizeEventSelector(selector);
       if (scope === "*") return client.getState().api.on(event, callback);
@@ -155,15 +175,21 @@ export type AssistantClientProps = {
     state: ThreadListClientState;
     api: ThreadListClientApi;
   }>;
-  registerModelContextProvider?: (
-    provider: ModelContextProvider,
-  ) => Unsubscribe;
-
-  /** @internal */
-  __internal_runtime?: AssistantRuntime;
+  modelContext?: ResourceElement<{
+    state: ModelContextState;
+    api: ModelContextApi;
+  }>;
+  tools?:
+    | ResourceElement<{
+        state: ToolsState;
+        api: ToolsApi;
+      }>
+    | undefined;
 };
 
 export const useAssistantClient = (props: AssistantClientProps) => {
+  const api = useAssistantApiImpl();
   const client = useResource(asStore(AssistantStore(props)));
-  return useMemo(() => getClientFromStore(client), [client]);
+  const clientApi = useMemo(() => getClientFromStore(client), [client]);
+  return useMemo(() => extendApi(api, clientApi), [api, clientApi]);
 };

package/src/client/ModelContext.ts

@@ -0,0 +1,28 @@
+import {
+  createContext,
+  tapContext,
+  withContextProvider,
+  Unsubscribe,
+} from "@assistant-ui/tap";
+import { ModelContextProvider } from "../model-context/ModelContextTypes";
+
+export type ModelContextRegistrar = ModelContextProvider & {
+  register: (provider: ModelContextProvider) => Unsubscribe;
+};
+
+const ModelContextContext = createContext<ModelContextRegistrar | null>(null);
+
+export const withModelContextProvider = <TResult>(
+  modelContext: ModelContextRegistrar,
+  fn: () => TResult,
+) => {
+  return withContextProvider(ModelContextContext, modelContext, fn);
+};
+
+export const tapModelContext = () => {
+  const modelContext = tapContext(ModelContextContext);
+  if (!modelContext)
+    throw new Error("Model context is not available in this context");
+
+  return modelContext;
+};

package/src/client/ModelContextClient.ts

@@ -0,0 +1,16 @@
+import { resource, tapState } from "@assistant-ui/tap";
+import { tapApi } from "../utils/tap-store";
+import { CompositeContextProvider } from "../utils/CompositeContextProvider";
+import type { ModelContextState, ModelContextApi } from "./types/ModelContext";
+
+export const ModelContext = resource(() => {
+  const [state] = tapState<ModelContextState>(() => ({}));
+  const composite = new CompositeContextProvider();
+
+  return tapApi<ModelContextApi>({
+    getState: () => state,
+    getModelContext: () => composite.getModelContext(),
+    subscribe: (callback) => composite.subscribe(callback),
+    register: (provider) => composite.registerModelContextProvider(provider),
+  });
+});

package/src/client/ToolUIClient.ts

@@ -3,7 +3,11 @@ import { tapApi } from "../utils/tap-store";
 import { ToolUIState, ToolUIApi } from "./types/ToolUI";
 
 export const ToolUIClient = resource(() => {
-  const [state, setState] = tapState<ToolUIState>(() => ({}));
+  const [state, setState] = tapState<ToolUIState>(() => ({
+    tools: {},
+    fallback: [],
+    layout: [],
+  }));
 
   return tapApi<ToolUIApi>({
     getState: () => state,
@@ -12,7 +16,10 @@ export const ToolUIClient = resource(() => {
       setState((prev) => {
         return {
           ...prev,
-          [toolName]: [...(prev[toolName] ?? []), render],
+          tools: {
+            ...prev.tools,
+            [toolName]: [...(prev.tools[toolName] ?? []), render],
+          },
         };
       });
 
@@ -20,7 +27,47 @@ export const ToolUIClient = resource(() => {
         setState((prev) => {
           return {
             ...prev,
-            [toolName]: prev[toolName]?.filter((r) => r !== render) ?? [],
+            tools: {
+              ...prev.tools,
+              [toolName]:
+                prev.tools[toolName]?.filter((r) => r !== render) ?? [],
+            },
+          };
+        });
+      };
+    },
+
+    setFallbackToolUI: (render) => {
+      setState((prev) => {
+        return {
+          ...prev,
+          fallback: [...prev.fallback, render],
+        };
+      });
+
+      return () => {
+        setState((prev) => {
+          return {
+            ...prev,
+            fallback: prev.fallback.filter((r) => r !== render),
+          };
+        });
+      };
+    },
+
+    setToolUILayout: (render) => {
+      setState((prev) => {
+        return {
+          ...prev,
+          layout: [...prev.layout, render],
+        };
+      });
+
+      return () => {
+        setState((prev) => {
+          return {
+            ...prev,
+            layout: prev.layout.filter((r) => r !== render),
           };
         });
       };

package/src/client/ToolUIContext.ts

@@ -0,0 +1,22 @@
+import {
+  createContext,
+  tapContext,
+  withContextProvider,
+} from "@assistant-ui/tap";
+import type { ToolUIApi } from "./types/ToolUI";
+
+const ToolUIContext = createContext<ToolUIApi | null>(null);
+
+export const withToolUIProvider = <TResult>(
+  toolUIs: ToolUIApi,
+  fn: () => TResult,
+) => {
+  return withContextProvider(ToolUIContext, toolUIs, fn);
+};
+
+export const tapToolUI = () => {
+  const toolUIs = tapContext(ToolUIContext);
+  if (!toolUIs) throw new Error("ToolUI context is not available");
+
+  return toolUIs;
+};

package/src/client/Tools.ts

@@ -0,0 +1,68 @@
+import { resource, tapState, tapEffect } from "@assistant-ui/tap";
+import { tapApi } from "../utils/tap-store";
+import { tapModelContext } from "./ModelContext";
+import { tapToolUI } from "./ToolUIContext";
+import { ToolsState, ToolsApi } from "./types/Tools";
+import type { Tool } from "assistant-stream";
+import {
+  type Toolkit,
+  FallbackSymbol,
+  LayoutSymbol,
+} from "../model-context/toolbox";
+
+export const Tools = resource(({ toolkit }: { toolkit?: Toolkit }) => {
+  const [state] = tapState<ToolsState>(() => ({}));
+
+  const modelContext = tapModelContext();
+  const toolUI = tapToolUI();
+
+  tapEffect(() => {
+    if (!toolkit) return;
+    const unsubscribes: (() => void)[] = [];
+
+    // Register fallback UI
+    const fallback = toolkit[FallbackSymbol];
+    if (fallback?.render) {
+      unsubscribes.push(toolUI.setFallbackToolUI(fallback.render));
+    }
+
+    // Register layout
+    const layout = toolkit[LayoutSymbol];
+    if (layout?.render) {
+      unsubscribes.push(toolUI.setToolUILayout(layout.render));
+    }
+
+    // Register tool UIs (exclude symbols)
+    for (const [toolName, tool] of Object.entries(toolkit)) {
+      if (tool.render) {
+        unsubscribes.push(toolUI.setToolUI(toolName, tool.render));
+      }
+    }
+
+    // Register tools with model context (exclude symbols)
+    const toolsWithoutRender = Object.entries(toolkit).reduce(
+      (acc, [name, tool]) => {
+        const { render, ...rest } = tool;
+        acc[name] = rest;
+        return acc;
+      },
+      {} as Record<string, Tool<any, any>>,
+    );
+
+    const modelContextProvider = {
+      getModelContext: () => ({
+        tools: toolsWithoutRender,
+      }),
+    };
+
+    unsubscribes.push(modelContext.register(modelContextProvider));
+
+    return () => {
+      unsubscribes.forEach((fn) => fn());
+    };
+  }, [toolkit, modelContext, toolUI]);
+
+  return tapApi<ToolsApi>({
+    getState: () => state,
+  });
+});