@assistant-ui/core 0.1.2 → 0.1.3

package/dist/utils/json/is-json.js

@@ -0,0 +1,33 @@
+export function isRecord(value) {
+    return value != null && typeof value === "object" && !Array.isArray(value);
+}
+export function isJSONValue(value, currentDepth = 0) {
+    // Protect against too deep recursion
+    if (currentDepth > 100) {
+        return false;
+    }
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "boolean") {
+        return true;
+    }
+    // Handle special number cases
+    if (typeof value === "number") {
+        return !Number.isNaN(value) && Number.isFinite(value);
+    }
+    if (Array.isArray(value)) {
+        return value.every((item) => isJSONValue(item, currentDepth + 1));
+    }
+    if (isRecord(value)) {
+        return Object.entries(value).every(([key, val]) => typeof key === "string" && isJSONValue(val, currentDepth + 1));
+    }
+    return false;
+}
+export function isJSONArray(value) {
+    return Array.isArray(value) && value.every(isJSONValue);
+}
+export function isJSONObject(value) {
+    return (isRecord(value) &&
+        Object.entries(value).every(([key, val]) => typeof key === "string" && isJSONValue(val)));
+}
+//# sourceMappingURL=is-json.js.map

package/dist/utils/json/is-json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-json.js","sourceRoot":"","sources":["../../../src/utils/json/is-json.ts"],"names":[],"mappings":"AAMA,MAAM,UAAU,QAAQ,CAAC,KAAc;IACrC,OAAO,KAAK,IAAI,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAC7E,CAAC;AAED,MAAM,UAAU,WAAW,CACzB,KAAc,EACd,eAAuB,CAAC;IAExB,qCAAqC;IACrC,IAAI,YAAY,GAAG,GAAG,EAAE,CAAC;QACvB,OAAO,KAAK,CAAC;IACf,CAAC;IAED,IACE,KAAK,KAAK,IAAI;QACd,OAAO,KAAK,KAAK,QAAQ;QACzB,OAAO,KAAK,KAAK,SAAS,EAC1B,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,8BAA8B;IAC9B,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IACxD,CAAC;IAED,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACzB,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,WAAW,CAAC,IAAI,EAAE,YAAY,GAAG,CAAC,CAAC,CAAC,CAAC;IACpE,CAAC;IAED,IAAI,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QACpB,OAAO,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,KAAK,CAChC,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,EAAE,CACb,OAAO,GAAG,KAAK,QAAQ,IAAI,WAAW,CAAC,GAAG,EAAE,YAAY,GAAG,CAAC,CAAC,CAChE,CAAC;IACJ,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAED,MAAM,UAAU,WAAW,CAAC,KAAc;IACxC,OAAO,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;AAC1D,CAAC;AAED,MAAM,UAAU,YAAY,CAAC,KAAc;IACzC,OAAO,CACL,QAAQ,CAAC,KAAK,CAAC;QACf,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,KAAK,CACzB,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,EAAE,CAAC,OAAO,GAAG,KAAK,QAAQ,IAAI,WAAW,CAAC,GAAG,CAAC,CAC5D,CACF,CAAC;AACJ,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@assistant-ui/core",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Framework-agnostic core runtime for assistant-ui",
   "keywords": [
     "assistant",
@@ -57,21 +57,21 @@
     "nanoid": "^5.1.6"
   },
   "peerDependencies": {
-    "@assistant-ui/store": "^0.2.1",
-    "@assistant-ui/tap": "^0.5.1",
+    "@assistant-ui/store": "^0.2.2",
+    "@assistant-ui/tap": "^0.5.2",
     "@types/react": "*",
     "react": "^18 || ^19",
-    "zod": "^4.0.0",
+    "assistant-cloud": "^0.1.21",
     "zustand": "^5.0.11"
   },
   "peerDependenciesMeta": {
     "@types/react": {
       "optional": true
     },
-    "react": {
+    "assistant-cloud": {
       "optional": true
     },
-    "zod": {
+    "react": {
       "optional": true
     },
     "zustand": {
@@ -83,9 +83,10 @@
     "react": "^19.2.4",
     "vitest": "^4.0.18",
     "zustand": "^5.0.11",
-    "@assistant-ui/store": "0.2.1",
-    "@assistant-ui/tap": "0.5.1",
-    "@assistant-ui/x-buildutils": "0.0.1"
+    "assistant-cloud": "0.1.21",
+    "@assistant-ui/store": "0.2.2",
+    "@assistant-ui/tap": "0.5.2",
+    "@assistant-ui/x-buildutils": "0.0.2"
   },
   "publishConfig": {
     "access": "public",

package/src/model-context/frame/provider.ts

@@ -1,7 +1,6 @@
 import { ModelContextProvider, ModelContext } from "../types";
 import type { Unsubscribe } from "../../types";
-import { Tool } from "assistant-stream";
-import { z } from "zod";
+import { Tool, toJSONSchema } from "assistant-stream";
 import {
   FrameMessage,
   FRAME_MESSAGE_CHANNEL,
@@ -11,10 +10,7 @@ import {
 
 const serializeTool = (tool: Tool<any, any>): SerializedTool => ({
   ...(tool.description && { description: tool.description }),
-  parameters:
-    tool.parameters instanceof z.ZodType
-      ? ((z as any).toJSONSchema?.(tool.parameters) ?? tool.parameters)
-      : tool.parameters,
+  parameters: tool.parameters ? toJSONSchema(tool.parameters) : undefined,
   ...(tool.disabled !== undefined && { disabled: tool.disabled }),
   ...(tool.type && { type: tool.type }),
 });

package/src/react/index.ts

@@ -1,10 +1,11 @@
-import "./types/store-augmentation";
+/// <reference path="./types/store-augmentation.ts" />
 
 export * from "./model-context";
 export * from "./client";
 export * from "./types";
 export * from "./providers";
 export { RuntimeAdapter } from "./RuntimeAdapter";
+export * from "./runtimes";
 
 // AssistantProvider base
 export {

package/src/react/runtimes/RemoteThreadListHookInstanceManager.tsx

@@ -0,0 +1,176 @@
+import {
+  FC,
+  useCallback,
+  useRef,
+  useEffect,
+  memo,
+  PropsWithChildren,
+  ComponentType,
+  useMemo,
+} from "react";
+import { UseBoundStore, StoreApi, create } from "zustand";
+import { useAui } from "@assistant-ui/store";
+import { ThreadListItemRuntimeProvider } from "../providers/ThreadListItemRuntimeProvider";
+import type { ThreadRuntimeCore } from "../../runtime/interfaces/thread-runtime-core";
+import type { ThreadListRuntimeCore } from "../../runtime/interfaces/thread-list-runtime-core";
+import type { AssistantRuntime } from "../../runtime/api/assistant-runtime";
+import { BaseSubscribable } from "../../subscribable";
+import { ThreadRuntimeImpl } from "../../runtime/api/thread-runtime";
+import { ThreadListRuntimeImpl } from "../../runtime/api/thread-list-runtime";
+
+type RemoteThreadListHook = () => AssistantRuntime;
+
+type RemoteThreadListHookInstance = {
+  runtime?: ThreadRuntimeCore;
+};
+export class RemoteThreadListHookInstanceManager extends BaseSubscribable {
+  private useRuntimeHook: UseBoundStore<
+    StoreApi<{ useRuntime: RemoteThreadListHook }>
+  >;
+  private instances = new Map<string, RemoteThreadListHookInstance>();
+  private useAliveThreadsKeysChanged = create(() => ({}));
+  private parent: ThreadListRuntimeCore;
+
+  constructor(
+    runtimeHook: RemoteThreadListHook,
+    parent: ThreadListRuntimeCore,
+  ) {
+    super();
+    this.parent = parent;
+    this.useRuntimeHook = create(() => ({ useRuntime: runtimeHook }));
+  }
+
+  public startThreadRuntime(threadId: string) {
+    if (!this.instances.has(threadId)) {
+      this.instances.set(threadId, {});
+      this.useAliveThreadsKeysChanged.setState({}, true);
+    }
+
+    return new Promise<ThreadRuntimeCore>((resolve, reject) => {
+      const callback = () => {
+        const instance = this.instances.get(threadId);
+        if (!instance) {
+          dispose();
+          reject(new Error("Thread was deleted before runtime was started"));
+        } else if (!instance.runtime) {
+          return; // misc update
+        } else {
+          dispose();
+          resolve(instance.runtime);
+        }
+      };
+      const dispose = this.subscribe(callback);
+      callback();
+    });
+  }
+
+  public getThreadRuntimeCore(threadId: string) {
+    const instance = this.instances.get(threadId);
+    if (!instance) return undefined;
+    return instance.runtime;
+  }
+
+  public stopThreadRuntime(threadId: string) {
+    this.instances.delete(threadId);
+    this.useAliveThreadsKeysChanged.setState({}, true);
+  }
+
+  public setRuntimeHook(newRuntimeHook: RemoteThreadListHook) {
+    const prevRuntimeHook = this.useRuntimeHook.getState().useRuntime;
+    if (prevRuntimeHook !== newRuntimeHook) {
+      this.useRuntimeHook.setState({ useRuntime: newRuntimeHook }, true);
+    }
+  }
+
+  private _InnerActiveThreadProvider: FC<{
+    threadId: string;
+  }> = ({ threadId }) => {
+    const { useRuntime } = this.useRuntimeHook();
+    const runtime = useRuntime();
+
+    const threadBinding = (runtime.thread as ThreadRuntimeImpl)
+      .__internal_threadBinding;
+
+    const updateRuntime = useCallback(() => {
+      const aliveThread = this.instances.get(threadId);
+      if (!aliveThread)
+        throw new Error("Thread not found. This is a bug in assistant-ui.");
+
+      aliveThread.runtime = threadBinding.getState();
+      this._notifySubscribers();
+    }, [threadId, threadBinding]);
+
+    const isMounted = useRef(false);
+    if (!isMounted.current) {
+      updateRuntime();
+    }
+
+    useEffect(() => {
+      isMounted.current = true;
+      updateRuntime();
+      return threadBinding.outerSubscribe(updateRuntime);
+    }, [threadBinding, updateRuntime]);
+
+    const aui = useAui();
+    const initPromiseRef = useRef<Promise<unknown> | undefined>(undefined);
+
+    useEffect(() => {
+      const runtimeCore = threadBinding.getState();
+      const setGetInitializePromise = (runtimeCore as Record<string, unknown>)[
+        "__internal_setGetInitializePromise"
+      ];
+      if (typeof setGetInitializePromise === "function") {
+        setGetInitializePromise.call(runtimeCore, () => initPromiseRef.current);
+      }
+    }, [threadBinding]);
+
+    useEffect(() => {
+      return runtime.threads.main.unstable_on("initialize", () => {
+        const state = aui.threadListItem().getState();
+        if (state.status === "new") {
+          initPromiseRef.current = aui.threadListItem().initialize();
+
+          const dispose = runtime.thread.unstable_on("runEnd", () => {
+            dispose();
+
+            aui.threadListItem().generateTitle();
+          });
+        }
+      });
+    }, [runtime, aui]);
+
+    return null;
+  };
+
+  private _OuterActiveThreadProvider: FC<{
+    threadId: string;
+    provider: ComponentType<PropsWithChildren>;
+  }> = memo(({ threadId, provider: Provider }) => {
+    const runtime = useMemo(
+      () => new ThreadListRuntimeImpl(this.parent).getItemById(threadId),
+      [threadId],
+    );
+
+    return (
+      <ThreadListItemRuntimeProvider runtime={runtime}>
+        <Provider>
+          <this._InnerActiveThreadProvider threadId={threadId} />
+        </Provider>
+      </ThreadListItemRuntimeProvider>
+    );
+  });
+
+  public __internal_RenderThreadRuntimes: FC<{
+    provider: ComponentType<PropsWithChildren>;
+  }> = ({ provider }) => {
+    this.useAliveThreadsKeysChanged(); // trigger re-render on alive threads change
+
+    return Array.from(this.instances.keys()).map((threadId) => (
+      <this._OuterActiveThreadProvider
+        key={threadId}
+        threadId={threadId}
+        provider={provider}
+      />
+    ));
+  };
+}