@assistant-ui/store 0.0.0

package/dist/tapApi.js

@@ -0,0 +1,52 @@
+// src/tapApi.ts
+import { tapEffect, tapMemo, tapRef } from "@assistant-ui/tap";
+var ReadonlyApiHandler = class {
+  constructor(getApi) {
+    this.getApi = getApi;
+  }
+  get(_, prop) {
+    return this.getApi()[prop];
+  }
+  ownKeys() {
+    return Object.keys(this.getApi());
+  }
+  has(_, prop) {
+    return prop in this.getApi();
+  }
+  getOwnPropertyDescriptor(_, prop) {
+    return Object.getOwnPropertyDescriptor(this.getApi(), prop);
+  }
+  set() {
+    return false;
+  }
+  defineProperty() {
+    return false;
+  }
+  deleteProperty() {
+    return false;
+  }
+};
+var tapApi = (api, options) => {
+  const ref = tapRef(api);
+  tapEffect(() => {
+    ref.current = api;
+  });
+  const apiProxy = tapMemo(
+    () => new Proxy({}, new ReadonlyApiHandler(() => ref.current)),
+    []
+  );
+  const key = options?.key;
+  const state = api.getState();
+  return tapMemo(
+    () => ({
+      key,
+      state,
+      api: apiProxy
+    }),
+    [state, key]
+  );
+};
+export {
+  tapApi
+};
+//# sourceMappingURL=tapApi.js.map

package/dist/tapApi.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/tapApi.ts"],"sourcesContent":["import { tapEffect, tapMemo, tapRef } from \"@assistant-ui/tap\";\n\n/**\n * API object type\n */\nexport interface ApiObject {\n  [key: string]: ((...args: any[]) => any) | ApiObject;\n}\n\n/**\n * Readonly API handler for creating stable proxies\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\n/**\n * Wraps an API object to make it stable across renders while keeping getState reactive.\n * This is the recommended pattern for scope resources.\n *\n * @example\n * ```typescript\n * export const FooResource = resource(() => {\n *   const [state, setState] = tapState({ bar: \"Hello\" });\n *\n *   const updateBar = (newBar: string) => {\n *     setState({ bar: newBar });\n *   };\n *\n *   return tapApi({\n *     getState: () => state,\n *     updateBar,\n *   });\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;AAY3C,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;AAsBO,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/dist/tapLookupResources.d.ts

@@ -0,0 +1,44 @@
+import { ResourceElement } from "@assistant-ui/tap";
+import { ApiObject } from "./tapApi";
+/**
+ * Creates a lookup-based resource collection for managing lists of items.
+ * Returns both the combined state array and an API function to lookup specific items.
+ *
+ * @param elements - Array of resource elements, each returning { key, state, api }
+ * @returns Object with { state: TState[], api: (lookup) => TApi }
+ *
+ * The api function accepts { index: number } or { key: string } for lookups.
+ * Consumers can wrap it to rename the key field (e.g., to "id" or "toolCallId").
+ *
+ * @example
+ * ```typescript
+ * const foos = tapLookupResources(
+ *   items.map((item) => FooItem({ id: item.id }, { key: item.id }))
+ * );
+ *
+ * // Access state array
+ * const allStates = foos.state;
+ *
+ * // Wrap to rename key field to "id"
+ * const wrappedApi = (lookup: { index: number } | { id: string }) => {
+ *   if ("id" in lookup) {
+ *     return foos.api({ key: lookup.id });
+ *   } else {
+ *     return foos.api(lookup);
+ *   }
+ * };
+ * ```
+ */
+export declare const tapLookupResources: <TState, TApi extends ApiObject>(elements: ResourceElement<{
+    key: string | undefined;
+    state: TState;
+    api: TApi;
+}>[]) => {
+    state: TState[];
+    api: (lookup: {
+        index: number;
+    } | {
+        key: string;
+    }) => TApi;
+};
+//# sourceMappingURL=tapLookupResources.d.ts.map

package/dist/tapLookupResources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tapLookupResources.d.ts","sourceRoot":"","sources":["../src/tapLookupResources.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAgB,MAAM,mBAAmB,CAAC;AAClE,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,kBAAkB,GAAI,MAAM,EAAE,IAAI,SAAS,SAAS,EAC/D,UAAU,eAAe,CAAC;IACxB,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,IAAI,CAAC;CACX,CAAC,EAAE,KACH;IACD,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,GAAG,EAAE,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC;CAqB5D,CAAC"}

package/dist/tapLookupResources.js

@@ -0,0 +1,21 @@
+// src/tapLookupResources.ts
+import { tapResources } from "@assistant-ui/tap";
+var tapLookupResources = (elements) => {
+  const resources = tapResources(elements);
+  return {
+    state: resources.map((r) => r.state),
+    api: (lookup) => {
+      const value = "index" in lookup ? resources[lookup.index]?.api : resources.find((r) => r.key === lookup.key)?.api;
+      if (!value) {
+        throw new Error(
+          `tapLookupResources: Resource not found for lookup: ${JSON.stringify(lookup)}`
+        );
+      }
+      return value;
+    }
+  };
+};
+export {
+  tapLookupResources
+};
+//# sourceMappingURL=tapLookupResources.js.map

package/dist/tapLookupResources.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/tapLookupResources.ts"],"sourcesContent":["import { ResourceElement, tapResources } from \"@assistant-ui/tap\";\nimport { ApiObject } from \"./tapApi\";\n\n/**\n * Creates a lookup-based resource collection for managing lists of items.\n * Returns both the combined state array and an API function to lookup specific items.\n *\n * @param elements - Array of resource elements, each returning { key, state, api }\n * @returns Object with { state: TState[], api: (lookup) => TApi }\n *\n * The api function accepts { index: number } or { key: string } for lookups.\n * Consumers can wrap it to rename the key field (e.g., to \"id\" or \"toolCallId\").\n *\n * @example\n * ```typescript\n * const foos = tapLookupResources(\n *   items.map((item) => FooItem({ id: item.id }, { key: item.id }))\n * );\n *\n * // Access state array\n * const allStates = foos.state;\n *\n * // Wrap to rename key field to \"id\"\n * const wrappedApi = (lookup: { index: number } | { id: string }) => {\n *   if (\"id\" in lookup) {\n *     return foos.api({ key: lookup.id });\n *   } else {\n *     return foos.api(lookup);\n *   }\n * };\n * ```\n */\nexport const tapLookupResources = <TState, TApi extends ApiObject>(\n  elements: ResourceElement<{\n    key: string | undefined;\n    state: TState;\n    api: TApi;\n  }>[],\n): {\n  state: TState[];\n  api: (lookup: { index: number } | { key: string }) => TApi;\n} => {\n  const resources = tapResources(elements);\n\n  return {\n    state: resources.map((r) => r.state),\n    api: (lookup: { index: number } | { key: string }) => {\n      const value =\n        \"index\" in lookup\n          ? resources[lookup.index]?.api\n          : resources.find((r) => r.key === lookup.key)?.api;\n\n      if (!value) {\n        throw new Error(\n          `tapLookupResources: Resource not found for lookup: ${JSON.stringify(lookup)}`,\n        );\n      }\n\n      return value;\n    },\n  };\n};\n"],"mappings":";AAAA,SAA0B,oBAAoB;AAgCvC,IAAM,qBAAqB,CAChC,aAQG;AACH,QAAM,YAAY,aAAa,QAAQ;AAEvC,SAAO;AAAA,IACL,OAAO,UAAU,IAAI,CAAC,MAAM,EAAE,KAAK;AAAA,IACnC,KAAK,CAAC,WAAgD;AACpD,YAAM,QACJ,WAAW,SACP,UAAU,OAAO,KAAK,GAAG,MACzB,UAAU,KAAK,CAAC,MAAM,EAAE,QAAQ,OAAO,GAAG,GAAG;AAEnD,UAAI,CAAC,OAAO;AACV,cAAM,IAAI;AAAA,UACR,sDAAsD,KAAK,UAAU,MAAM,CAAC;AAAA,QAC9E;AAAA,MACF;AAEA,aAAO;AAAA,IACT;AAAA,EACF;AACF;","names":[]}

package/dist/tapStoreList.d.ts

@@ -0,0 +1,76 @@
+import type { ContravariantResource } from "@assistant-ui/tap";
+import { ApiObject } from "./tapApi";
+/**
+ * Resource props that will be passed to each item resource
+ */
+export type TapStoreListResourceProps<TProps> = {
+    initialValue: TProps;
+    remove: () => void;
+};
+/**
+ * Configuration for tapStoreList hook
+ */
+export type TapStoreListConfig<TProps, TState, TApi extends ApiObject> = {
+    /**
+     * Initial values for the list items
+     */
+    initialValues: TProps[];
+    /**
+     * Resource function that creates an element for each item
+     * Should return a ResourceElement with { key, state, api }
+     *
+     * The resource will receive { initialValue, remove } as props.
+     */
+    resource: ContravariantResource<{
+        key: string | undefined;
+        state: TState;
+        api: TApi;
+    }, TapStoreListResourceProps<TProps>>;
+    /**
+     * Optional ID generator function for new items
+     * If not provided, items must include an ID when added
+     */
+    idGenerator?: () => string;
+};
+/**
+ * Creates a stateful list with add functionality, rendering each item via the provided resource.
+ * Returns state array, api lookup function, and add method.
+ *
+ * @param config - Configuration object with initialValues, resource, and optional idGenerator
+ * @returns Object with { state: TState[], api: (lookup) => TApi, add: (id?) => void }
+ *
+ * @example
+ * ```typescript
+ * const todoList = tapStoreList({
+ *   initialValues: [
+ *     { id: "1", text: "First todo" },
+ *     { id: "2", text: "Second todo" }
+ *   ],
+ *   resource: (props) => TodoItemResource(props, { key: props.id }),
+ *   idGenerator: () => `todo-${Date.now()}`
+ * });
+ *
+ * // Access state array
+ * const allTodos = todoList.state;
+ *
+ * // Lookup specific item
+ * const firstTodo = todoList.api({ index: 0 });
+ * const specificTodo = todoList.api({ key: "1" });
+ *
+ * // Add new item
+ * todoList.add(); // Uses idGenerator
+ * todoList.add("custom-id"); // Uses provided id
+ * ```
+ */
+export declare const tapStoreList: <TProps extends {
+    id: string;
+}, TState, TApi extends ApiObject>(config: TapStoreListConfig<TProps, TState, TApi>) => {
+    state: TState[];
+    api: (lookup: {
+        index: number;
+    } | {
+        id: string;
+    }) => TApi;
+    add: (id?: string) => void;
+};
+//# sourceMappingURL=tapStoreList.d.ts.map

package/dist/tapStoreList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tapStoreList.d.ts","sourceRoot":"","sources":["../src/tapStoreList.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAE/D,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAErC;;GAEG;AACH,MAAM,MAAM,yBAAyB,CAAC,MAAM,IAAI;IAC9C,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,IAAI,CAAC;CACpB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,SAAS,SAAS,IAAI;IACvE;;OAEG;IACH,aAAa,EAAE,MAAM,EAAE,CAAC;IAMxB;;;;;OAKG;IACH,QAAQ,EAAE,qBAAqB,CAC7B;QACE,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;QACxB,KAAK,EAAE,MAAM,CAAC;QACd,GAAG,EAAE,IAAI,CAAC;KACX,EACD,yBAAyB,CAAC,MAAM,CAAC,CAClC,CAAC;IACF;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,MAAM,CAAC;CAC5B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,YAAY,GACvB,MAAM,SAAS;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,EAC7B,MAAM,EACN,IAAI,SAAS,SAAS,EAEtB,QAAQ,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,KAC/C;IACD,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,GAAG,EAAE,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC;IAC1D,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;CA8C5B,CAAC"}

package/dist/tapStoreList.js

@@ -0,0 +1,46 @@
+// src/tapStoreList.ts
+import { tapState } from "@assistant-ui/tap";
+import { tapLookupResources } from "./tapLookupResources.js";
+var tapStoreList = (config) => {
+  const { initialValues, resource: Resource, idGenerator } = config;
+  const [items, setItems] = tapState(initialValues);
+  const lookup = tapLookupResources(
+    items.map(
+      (item) => Resource(
+        {
+          initialValue: item,
+          remove: () => {
+            setItems(items.filter((i) => i !== item));
+          }
+        },
+        {
+          key: item.id
+        }
+      )
+    )
+  );
+  const add = (id) => {
+    const newId = id ?? idGenerator?.();
+    if (!newId) {
+      throw new Error(
+        "tapStoreList: Either provide an id to add() or configure an idGenerator"
+      );
+    }
+    const newItem = { id: newId };
+    setItems([...items, newItem]);
+  };
+  return {
+    state: lookup.state,
+    api: (query) => {
+      if ("index" in query) {
+        return lookup.api({ index: query.index });
+      }
+      return lookup.api({ key: query.id });
+    },
+    add
+  };
+};
+export {
+  tapStoreList
+};
+//# sourceMappingURL=tapStoreList.js.map

package/dist/tapStoreList.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/tapStoreList.ts"],"sourcesContent":["import { tapState } from \"@assistant-ui/tap\";\nimport type { ContravariantResource } from \"@assistant-ui/tap\";\nimport { tapLookupResources } from \"./tapLookupResources\";\nimport { ApiObject } from \"./tapApi\";\n\n/**\n * Resource props that will be passed to each item resource\n */\nexport type TapStoreListResourceProps<TProps> = {\n  initialValue: TProps;\n  remove: () => void;\n};\n\n/**\n * Configuration for tapStoreList hook\n */\nexport type TapStoreListConfig<TProps, TState, TApi extends ApiObject> = {\n  /**\n   * Initial values for the list items\n   */\n  initialValues: TProps[];\n\n  // TODO we can't use Resource type here because of contravariance\n  // I think we need a special type in tap that correctly handles the contravariance\n  // or change the behavior of the Resource type\n\n  /**\n   * Resource function that creates an element for each item\n   * Should return a ResourceElement with { key, state, api }\n   *\n   * The resource will receive { initialValue, remove } as props.\n   */\n  resource: ContravariantResource<\n    {\n      key: string | undefined;\n      state: TState;\n      api: TApi;\n    },\n    TapStoreListResourceProps<TProps>\n  >;\n  /**\n   * Optional ID generator function for new items\n   * If not provided, items must include an ID when added\n   */\n  idGenerator?: () => string;\n};\n\n/**\n * Creates a stateful list with add functionality, rendering each item via the provided resource.\n * Returns state array, api lookup function, and add method.\n *\n * @param config - Configuration object with initialValues, resource, and optional idGenerator\n * @returns Object with { state: TState[], api: (lookup) => TApi, add: (id?) => void }\n *\n * @example\n * ```typescript\n * const todoList = tapStoreList({\n *   initialValues: [\n *     { id: \"1\", text: \"First todo\" },\n *     { id: \"2\", text: \"Second todo\" }\n *   ],\n *   resource: (props) => TodoItemResource(props, { key: props.id }),\n *   idGenerator: () => `todo-${Date.now()}`\n * });\n *\n * // Access state array\n * const allTodos = todoList.state;\n *\n * // Lookup specific item\n * const firstTodo = todoList.api({ index: 0 });\n * const specificTodo = todoList.api({ key: \"1\" });\n *\n * // Add new item\n * todoList.add(); // Uses idGenerator\n * todoList.add(\"custom-id\"); // Uses provided id\n * ```\n */\nexport const tapStoreList = <\n  TProps extends { id: string },\n  TState,\n  TApi extends ApiObject,\n>(\n  config: TapStoreListConfig<TProps, TState, TApi>,\n): {\n  state: TState[];\n  api: (lookup: { index: number } | { id: string }) => TApi;\n  add: (id?: string) => void;\n} => {\n  const { initialValues, resource: Resource, idGenerator } = config;\n\n  const [items, setItems] = tapState<TProps[]>(initialValues);\n\n  const lookup = tapLookupResources(\n    items.map((item) =>\n      Resource(\n        {\n          initialValue: item,\n          remove: () => {\n            setItems(items.filter((i) => i !== item));\n          },\n        },\n        {\n          key: item.id,\n        },\n      ),\n    ),\n  );\n\n  const add = (id?: string) => {\n    const newId = id ?? idGenerator?.();\n    if (!newId) {\n      throw new Error(\n        \"tapStoreList: Either provide an id to add() or configure an idGenerator\",\n      );\n    }\n\n    // Create a new item with the generated/provided id\n    // This assumes TProps has an 'id' field - users will need to ensure their props type supports this\n    const newItem = { id: newId } as TProps;\n    setItems([...items, newItem]);\n  };\n\n  return {\n    state: lookup.state,\n    api: (query: { index: number } | { id: string }) => {\n      if (\"index\" in query) {\n        return lookup.api({ index: query.index });\n      }\n      return lookup.api({ key: query.id });\n    },\n    add,\n  };\n};\n"],"mappings":";AAAA,SAAS,gBAAgB;AAEzB,SAAS,0BAA0B;AA2E5B,IAAM,eAAe,CAK1B,WAKG;AACH,QAAM,EAAE,eAAe,UAAU,UAAU,YAAY,IAAI;AAE3D,QAAM,CAAC,OAAO,QAAQ,IAAI,SAAmB,aAAa;AAE1D,QAAM,SAAS;AAAA,IACb,MAAM;AAAA,MAAI,CAAC,SACT;AAAA,QACE;AAAA,UACE,cAAc;AAAA,UACd,QAAQ,MAAM;AACZ,qBAAS,MAAM,OAAO,CAAC,MAAM,MAAM,IAAI,CAAC;AAAA,UAC1C;AAAA,QACF;AAAA,QACA;AAAA,UACE,KAAK,KAAK;AAAA,QACZ;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,QAAM,MAAM,CAAC,OAAgB;AAC3B,UAAM,QAAQ,MAAM,cAAc;AAClC,QAAI,CAAC,OAAO;AACV,YAAM,IAAI;AAAA,QACR;AAAA,MACF;AAAA,IACF;AAIA,UAAM,UAAU,EAAE,IAAI,MAAM;AAC5B,aAAS,CAAC,GAAG,OAAO,OAAO,CAAC;AAAA,EAC9B;AAEA,SAAO;AAAA,IACL,OAAO,OAAO;AAAA,IACd,KAAK,CAAC,UAA8C;AAClD,UAAI,WAAW,OAAO;AACpB,eAAO,OAAO,IAAI,EAAE,OAAO,MAAM,MAAM,CAAC;AAAA,MAC1C;AACA,aAAO,OAAO,IAAI,EAAE,KAAK,MAAM,GAAG,CAAC;AAAA,IACrC;AAAA,IACA;AAAA,EACF;AACF;","names":[]}

package/dist/types.d.ts

@@ -0,0 +1,86 @@
+import type { ResourceElement } from "@assistant-ui/tap";
+/**
+ * Module augmentation interface for assistant-ui store type extensions.
+ *
+ * @example
+ * ```typescript
+ * declare module "@assistant-ui/store" {
+ *   interface AssistantScopeRegistry {
+ *     foo: {
+ *       value: { getState: () => { bar: string }; updateBar: (bar: string) => void };
+ *       source: "root";
+ *       query: Record<string, never>;
+ *     };
+ *   }
+ * }
+ * ```
+ */
+export interface AssistantScopeRegistry {
+}
+export type AssistantScopes = keyof AssistantScopeRegistry extends never ? Record<"ERROR: No scopes were defined", ScopeDefinition> : {
+    [K in keyof AssistantScopeRegistry]: AssistantScopeRegistry[K];
+};
+/**
+ * Helper type to extract the value type from a scope definition
+ */
+export type ScopeValue<T extends ScopeDefinition> = T["value"];
+/**
+ * Helper type to extract the source type from a scope definition
+ */
+export type ScopeSource<T extends ScopeDefinition> = T["source"];
+/**
+ * Helper type to extract the query type from a scope definition
+ */
+export type ScopeQuery<T extends ScopeDefinition> = T["query"];
+/**
+ * Type for a scope field - a function that returns the current API value,
+ * with source and query metadata attached
+ */
+export type ScopeField<T extends ScopeDefinition> = (() => ScopeValue<T>) & ({
+    source: ScopeSource<T>;
+    query: ScopeQuery<T>;
+} | {
+    source: null;
+    query: null;
+});
+/**
+ * Props passed to a derived scope resource element
+ */
+export type DerivedScopeProps<T extends ScopeDefinition> = {
+    get: (parent: AssistantClient) => ScopeValue<T>;
+    source: ScopeSource<T>;
+    query: ScopeQuery<T>;
+};
+/**
+ * Input type for scope definitions - ResourceElement that returns the API value
+ * Can optionally include source/query metadata via DerivedScope
+ */
+export type ScopeInput<T extends ScopeDefinition> = ResourceElement<{
+    api: ScopeValue<T>;
+}>;
+/**
+ * Map of scope names to their input definitions
+ */
+export type ScopesInput = {
+    [K in keyof AssistantScopes]?: ScopeInput<AssistantScopes[K]>;
+};
+/**
+ * Unsubscribe function type
+ */
+export type Unsubscribe = () => void;
+/**
+ * State type extracted from all scopes
+ */
+export type AssistantState = {
+    [K in keyof AssistantScopes]: ReturnType<AssistantScopes[K]["value"]["getState"]>;
+};
+/**
+ * The assistant client type with all registered scopes
+ */
+export type AssistantClient = {
+    [K in keyof AssistantScopes]: ScopeField<AssistantScopes[K]>;
+} & {
+    subscribe(listener: () => void): Unsubscribe;
+    flushSync(): void;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAmBzD;;;;;;;;;;;;;;;GAeG;AAEH,MAAM,WAAW,sBAAsB;CAAG;AAE1C,MAAM,MAAM,eAAe,GAAG,MAAM,sBAAsB,SAAS,KAAK,GACpE,MAAM,CAAC,+BAA+B,EAAE,eAAe,CAAC,GACxD;KAAG,CAAC,IAAI,MAAM,sBAAsB,GAAG,sBAAsB,CAAC,CAAC,CAAC;CAAE,CAAC;AAEvE;;GAEG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,eAAe,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC;AAE/D;;GAEG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,eAAe,IAAI,CAAC,CAAC,QAAQ,CAAC,CAAC;AAEjE;;GAEG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,eAAe,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC;AAE/D;;;GAGG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,eAAe,IAAI,CAAC,MAAM,UAAU,CAAC,CAAC,CAAC,CAAC,GACvE,CACI;IACE,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;IACvB,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;CACtB,GACD;IACE,MAAM,EAAE,IAAI,CAAC;IACb,KAAK,EAAE,IAAI,CAAC;CACb,CACJ,CAAC;AAEJ;;GAEG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,SAAS,eAAe,IAAI;IACzD,GAAG,EAAE,CAAC,MAAM,EAAE,eAAe,KAAK,UAAU,CAAC,CAAC,CAAC,CAAC;IAChD,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;IACvB,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;CACtB,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,eAAe,IAAI,eAAe,CAAC;IAClE,GAAG,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;CACpB,CAAC,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG;KACvB,CAAC,IAAI,MAAM,eAAe,CAAC,CAAC,EAAE,UAAU,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;CAC9D,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC;AAErC;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG;KAC1B,CAAC,IAAI,MAAM,eAAe,GAAG,UAAU,CACtC,eAAe,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,UAAU,CAAC,CACxC;CACF,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;KAC3B,CAAC,IAAI,MAAM,eAAe,GAAG,UAAU,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;CAC7D,GAAG;IACF,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,WAAW,CAAC;IAC7C,SAAS,IAAI,IAAI,CAAC;CACnB,CAAC"}

package/dist/types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/useAssistantClient.d.ts

@@ -0,0 +1,42 @@
+import type { AssistantClient, AssistantScopes, ScopesInput, ScopeField } from "./types";
+/**
+ * Hook to mount and access root scopes
+ */
+export declare const useRootScopes: (rootScopes: ScopesInput) => {
+    scopes: {};
+    subscribe?: never;
+    flushSync?: never;
+} | {
+    scopes: { [K in "ERROR: No scopes were defined"]: ScopeField<AssistantScopes[K]>; };
+    subscribe: (callback: () => void) => () => void;
+    flushSync: () => void;
+};
+/**
+ * Hook to mount and access derived scopes
+ */
+export declare const useDerivedScopes: (derivedScopes: ScopesInput, parentClient: AssistantClient) => {
+    "ERROR: No scopes were defined"?: ScopeField<import("./types").ScopeDefinition<any, any, any>>;
+};
+/**
+ * Hook to access or extend the AssistantClient
+ *
+ * @example Without config - returns the client from context:
+ * ```typescript
+ * const client = useAssistantClient();
+ * const fooState = client.foo.getState();
+ * ```
+ *
+ * @example With config - creates a new client with additional scopes:
+ * ```typescript
+ * const client = useAssistantClient({
+ *   message: DerivedScope({
+ *     source: "thread",
+ *     query: { type: "index", index: 0 },
+ *     get: () => messageApi,
+ *   }),
+ * });
+ * ```
+ */
+export declare function useAssistantClient(): AssistantClient;
+export declare function useAssistantClient(scopes: ScopesInput): AssistantClient;
+//# sourceMappingURL=useAssistantClient.d.ts.map

package/dist/useAssistantClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAssistantClient.d.ts","sourceRoot":"","sources":["../src/useAssistantClient.tsx"],"names":[],"mappings":"AAUA,OAAO,KAAK,EACV,eAAe,EACf,eAAe,EACf,WAAW,EACX,UAAU,EAGX,MAAM,SAAS,CAAC;AA6FjB;;GAEG;AACH,eAAO,MAAM,aAAa,GAAI,YAAY,WAAW;;;;;YA1B1C,GACF,CAAC,mCAAuB,GAAG,UAAU,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,GAC3D;0BACqB,MAAM,IAAI;;CAyBrC,CAAC;AAqEF;;GAEG;AACH,eAAO,MAAM,gBAAgB,GAC3B,eAAe,WAAW,EAC1B,cAAc,eAAe;;CAK9B,CAAC;AAyBF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,kBAAkB,IAAI,eAAe,CAAC;AACtD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,WAAW,GAAG,eAAe,CAAC"}

package/dist/useAssistantClient.js

@@ -0,0 +1,153 @@
+// src/useAssistantClient.tsx
+import { useMemo } from "react";
+import { useResource } from "@assistant-ui/tap/react";
+import {
+  resource,
+  tapMemo,
+  tapResource,
+  tapResources,
+  tapEffectEvent
+} from "@assistant-ui/tap";
+import { asStore } from "./asStore.js";
+import { useAssistantContextValue } from "./AssistantContext.js";
+import { splitScopes } from "./utils/splitScopes.js";
+var RootScopeResource = resource(
+  ({
+    scopeName,
+    element
+  }) => {
+    const store = tapResource(asStore(element));
+    return tapMemo(() => {
+      const scopeFunction = (() => store.getState().api);
+      scopeFunction.source = "root";
+      scopeFunction.query = {};
+      return [
+        scopeName,
+        {
+          scopeFunction,
+          subscribe: store.subscribe,
+          flushSync: store.flushSync
+        }
+      ];
+    }, [scopeName, store]);
+  }
+);
+var RootScopesResource = resource((scopes) => {
+  const resultEntries = tapResources(
+    Object.entries(scopes).map(
+      ([scopeName, element]) => RootScopeResource(
+        {
+          scopeName,
+          element
+        },
+        { key: scopeName }
+      )
+    )
+  );
+  return tapMemo(() => {
+    if (resultEntries.length === 0) {
+      return {
+        scopes: {}
+      };
+    }
+    return {
+      scopes: Object.fromEntries(
+        resultEntries.map(([scopeName, { scopeFunction }]) => [
+          scopeName,
+          scopeFunction
+        ])
+      ),
+      subscribe: (callback) => {
+        const unsubscribes = resultEntries.map(([, { subscribe }]) => {
+          return subscribe(() => {
+            console.log("Callback called for");
+            callback();
+          });
+        });
+        return () => {
+          unsubscribes.forEach((unsubscribe) => unsubscribe());
+        };
+      },
+      flushSync: () => {
+        resultEntries.forEach(([, { flushSync }]) => {
+          flushSync();
+        });
+      }
+    };
+  }, [...resultEntries]);
+});
+var useRootScopes = (rootScopes) => {
+  return useResource(RootScopesResource(rootScopes));
+};
+var DerivedScopeResource = resource(
+  ({
+    scopeName,
+    element,
+    parentClient
+  }) => {
+    const get = tapEffectEvent(element.props.get);
+    const source = element.props.source;
+    const query = element.props.query;
+    return tapMemo(() => {
+      const scopeFunction = (() => get(parentClient));
+      scopeFunction.source = source;
+      scopeFunction.query = query;
+      return [scopeName, scopeFunction];
+    }, [scopeName, get, source, JSON.stringify(query), parentClient]);
+  }
+);
+var DerivedScopesResource = resource(
+  ({
+    scopes,
+    parentClient
+  }) => {
+    const resultEntries = tapResources(
+      Object.entries(scopes).map(
+        ([scopeName, element]) => DerivedScopeResource(
+          {
+            scopeName,
+            element,
+            parentClient
+          },
+          { key: scopeName }
+        )
+      )
+    );
+    return tapMemo(() => {
+      return Object.fromEntries(resultEntries);
+    }, [...resultEntries]);
+  }
+);
+var useDerivedScopes = (derivedScopes, parentClient) => {
+  return useResource(
+    DerivedScopesResource({ scopes: derivedScopes, parentClient })
+  );
+};
+var useExtendedAssistantClientImpl = (scopes) => {
+  const baseClient = useAssistantContextValue();
+  const { rootScopes, derivedScopes } = splitScopes(scopes);
+  const rootFields = useRootScopes(rootScopes);
+  const derivedFields = useDerivedScopes(derivedScopes, baseClient);
+  return useMemo(() => {
+    return {
+      ...baseClient,
+      ...rootFields.scopes,
+      ...derivedFields,
+      subscribe: rootFields.subscribe ?? baseClient.subscribe,
+      flushSync: rootFields.flushSync ?? baseClient.flushSync
+    };
+  }, [baseClient, rootFields, derivedFields]);
+};
+function useAssistantClient(scopes) {
+  if (scopes) {
+    return useExtendedAssistantClientImpl(scopes);
+  } else {
+    return useAssistantContextValue();
+  }
+}
+export {
+  useAssistantClient,
+  useDerivedScopes,
+  useRootScopes
+};
+//# sourceMappingURL=useAssistantClient.js.map

package/dist/useAssistantClient.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/useAssistantClient.tsx"],"sourcesContent":["import { useMemo } from \"react\";\nimport { useResource } from \"@assistant-ui/tap/react\";\nimport {\n  resource,\n  tapMemo,\n  tapResource,\n  tapResources,\n  tapEffectEvent,\n  ResourceElement,\n} from \"@assistant-ui/tap\";\nimport type {\n  AssistantClient,\n  AssistantScopes,\n  ScopesInput,\n  ScopeField,\n  ScopeInput,\n  DerivedScopeProps,\n} from \"./types\";\nimport { asStore } from \"./asStore\";\nimport { useAssistantContextValue } from \"./AssistantContext\";\nimport { splitScopes } from \"./utils/splitScopes\";\n\n/**\n * Resource for a single root scope\n * Returns a tuple of [scopeName, {scopeFunction, subscribe, flushSync}]\n */\nconst RootScopeResource = resource(\n  <K extends keyof AssistantScopes>({\n    scopeName,\n    element,\n  }: {\n    scopeName: K;\n    element: ScopeInput<AssistantScopes[K]>;\n  }) => {\n    const store = tapResource(asStore(element));\n\n    return tapMemo(() => {\n      const scopeFunction = (() => store.getState().api) as ScopeField<\n        AssistantScopes[K]\n      >;\n      scopeFunction.source = \"root\";\n      scopeFunction.query = {} as AssistantScopes[K][\"query\"];\n\n      return [\n        scopeName,\n        {\n          scopeFunction,\n          subscribe: store.subscribe,\n          flushSync: store.flushSync,\n        },\n      ] as const;\n    }, [scopeName, store]);\n  },\n);\n\n/**\n * Resource for all root scopes\n * Mounts each root scope and returns an object mapping scope names to their stores\n */\nconst RootScopesResource = resource((scopes: ScopesInput) => {\n  const resultEntries = tapResources(\n    Object.entries(scopes).map(([scopeName, element]) =>\n      RootScopeResource(\n        {\n          scopeName: scopeName as keyof AssistantScopes,\n          element: element as ScopeInput<\n            AssistantScopes[keyof AssistantScopes]\n          >,\n        },\n        { key: scopeName },\n      ),\n    ),\n  );\n\n  return tapMemo(() => {\n    if (resultEntries.length === 0) {\n      return {\n        scopes: {},\n      };\n    }\n\n    return {\n      scopes: Object.fromEntries(\n        resultEntries.map(([scopeName, { scopeFunction }]) => [\n          scopeName,\n          scopeFunction,\n        ]),\n      ) as {\n        [K in keyof typeof scopes]: ScopeField<AssistantScopes[K]>;\n      },\n      subscribe: (callback: () => void) => {\n        const unsubscribes = resultEntries.map(([, { subscribe }]) => {\n          return subscribe(() => {\n            console.log(\"Callback called for\");\n            callback();\n          });\n        });\n        return () => {\n          unsubscribes.forEach((unsubscribe) => unsubscribe());\n        };\n      },\n      flushSync: () => {\n        resultEntries.forEach(([, { flushSync }]) => {\n          flushSync();\n        });\n      },\n    };\n  }, [...resultEntries]);\n});\n\n/**\n * Hook to mount and access root scopes\n */\nexport const useRootScopes = (rootScopes: ScopesInput) => {\n  return useResource(RootScopesResource(rootScopes));\n};\n\n/**\n * Resource for a single derived scope\n * Returns a tuple of [scopeName, scopeFunction] where scopeFunction has source and query\n */\nconst DerivedScopeResource = resource(\n  <K extends keyof AssistantScopes>({\n    scopeName,\n    element,\n    parentClient,\n  }: {\n    scopeName: K;\n    element: ResourceElement<\n      AssistantScopes[K],\n      DerivedScopeProps<AssistantScopes[K]>\n    >;\n    parentClient: AssistantClient;\n  }) => {\n    const get = tapEffectEvent(element.props.get);\n    const source = element.props.source;\n    const query = element.props.query;\n    return tapMemo(() => {\n      const scopeFunction = (() => get(parentClient)) as ScopeField<\n        AssistantScopes[K]\n      >;\n      scopeFunction.source = source;\n      scopeFunction.query = query;\n\n      return [scopeName, scopeFunction] as const;\n    }, [scopeName, get, source, JSON.stringify(query), parentClient]);\n  },\n);\n\n/**\n * Resource for all derived scopes\n * Builds stable scope functions with source and query metadata\n */\nconst DerivedScopesResource = resource(\n  ({\n    scopes,\n    parentClient,\n  }: {\n    scopes: ScopesInput;\n    parentClient: AssistantClient;\n  }) => {\n    const resultEntries = tapResources(\n      Object.entries(scopes).map(([scopeName, element]) =>\n        DerivedScopeResource(\n          {\n            scopeName: scopeName as keyof AssistantScopes,\n            element: element as ScopeInput<\n              AssistantScopes[keyof AssistantScopes]\n            >,\n            parentClient,\n          },\n          { key: scopeName },\n        ),\n      ),\n    );\n\n    return tapMemo(() => {\n      return Object.fromEntries(resultEntries) as {\n        [K in keyof typeof scopes]: ScopeField<AssistantScopes[K]>;\n      };\n    }, [...resultEntries]);\n  },\n);\n\n/**\n * Hook to mount and access derived scopes\n */\nexport const useDerivedScopes = (\n  derivedScopes: ScopesInput,\n  parentClient: AssistantClient,\n) => {\n  return useResource(\n    DerivedScopesResource({ scopes: derivedScopes, parentClient }),\n  );\n};\n\nconst useExtendedAssistantClientImpl = (\n  scopes: ScopesInput,\n): AssistantClient => {\n  const baseClient = useAssistantContextValue();\n  const { rootScopes, derivedScopes } = splitScopes(scopes);\n\n  // Mount the scopes to keep them alive\n  const rootFields = useRootScopes(rootScopes);\n  const derivedFields = useDerivedScopes(derivedScopes, baseClient);\n\n  return useMemo(() => {\n    // Merge base client with extended client\n    // If baseClient is the default proxy, spreading it will be a no-op\n    return {\n      ...baseClient,\n      ...rootFields.scopes,\n      ...derivedFields,\n      subscribe: rootFields.subscribe ?? baseClient.subscribe,\n      flushSync: rootFields.flushSync ?? baseClient.flushSync,\n    } as AssistantClient;\n  }, [baseClient, rootFields, derivedFields]);\n};\n\n/**\n * Hook to access or extend the AssistantClient\n *\n * @example Without config - returns the client from context:\n * ```typescript\n * const client = useAssistantClient();\n * const fooState = client.foo.getState();\n * ```\n *\n * @example With config - creates a new client with additional scopes:\n * ```typescript\n * const client = useAssistantClient({\n *   message: DerivedScope({\n *     source: \"thread\",\n *     query: { type: \"index\", index: 0 },\n *     get: () => messageApi,\n *   }),\n * });\n * ```\n */\nexport function useAssistantClient(): AssistantClient;\nexport function useAssistantClient(scopes: ScopesInput): AssistantClient;\nexport function useAssistantClient(scopes?: ScopesInput): AssistantClient {\n  if (scopes) {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    return useExtendedAssistantClientImpl(scopes);\n  } else {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    return useAssistantContextValue();\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/useAssistantState.d.ts

@@ -0,0 +1,18 @@
+import type { AssistantState } from "./types";
+/**
+ * Hook to access a slice of the assistant state with automatic subscription
+ *
+ * @param selector - Function to select a slice of the state
+ * @returns The selected state slice
+ *
+ * @example
+ * ```typescript
+ * const client = useAssistantClient({
+ *   foo: RootScope({ ... }),
+ * });
+ *
+ * const bar = useAssistantState((state) => state.foo.bar);
+ * ```
+ */
+export declare const useAssistantState: <T>(selector: (state: AssistantState) => T) => T;
+//# sourceMappingURL=useAssistantState.d.ts.map

package/dist/useAssistantState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAssistantState.d.ts","sourceRoot":"","sources":["../src/useAssistantState.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAmB,cAAc,EAAE,MAAM,SAAS,CAAC;AAsC/D;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iBAAiB,GAAI,CAAC,EACjC,UAAU,CAAC,KAAK,EAAE,cAAc,KAAK,CAAC,KACrC,CAuBF,CAAC"}