@assistant-ui/eve 0.0.19 → 0.0.20

package/src/eveCloudSessions.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, it } from "vitest";
+import { createEveCloudSessions } from "./eveCloudSessions";
+
+describe("createEveCloudSessions", () => {
+  it("hands a waiting thread the session its first turn creates", async () => {
+    const sessions = createEveCloudSessions();
+    const waiting = sessions.wait("thread-1");
+
+    sessions.resolve("thread-1", "session-1");
+    sessions.resolve("thread-1", "session-2");
+
+    await expect(waiting).resolves.toBe("session-1");
+    await expect(sessions.wait("thread-1")).resolves.toBe("session-1");
+  });
+
+  it("keeps a session resolved before the thread list asks for it", async () => {
+    const sessions = createEveCloudSessions();
+
+    sessions.resolve("thread-1", "session-1");
+
+    await expect(sessions.wait("thread-1")).resolves.toBe("session-1");
+  });
+
+  it("rejects the wait when the first turn fails, then waits for the next session", async () => {
+    const sessions = createEveCloudSessions();
+    const first = sessions.wait("thread-1");
+
+    sessions.reject("thread-1", new Error("no session"));
+    await expect(first).rejects.toThrow("no session");
+
+    const second = sessions.wait("thread-1");
+    sessions.resolve("thread-1", "session-2");
+    await expect(second).resolves.toBe("session-2");
+  });
+
+  it("ignores a rejection once the thread has a session", async () => {
+    const sessions = createEveCloudSessions();
+
+    sessions.resolve("thread-1", "session-1");
+    sessions.reject("thread-1", new Error("staged"));
+
+    await expect(sessions.wait("thread-1")).resolves.toBe("session-1");
+  });
+
+  it("does not surface a rejection nobody waits for", async () => {
+    const sessions = createEveCloudSessions();
+    void sessions.wait("thread-1");
+
+    sessions.reject("thread-1", new Error("no session"));
+    sessions.reject("thread-2", new Error("no session"));
+    sessions.resolve("thread-1", "session-1");
+
+    await expect(sessions.wait("thread-1")).resolves.toBe("session-1");
+  });
+
+  it("rejects a pending wait when the thread's runtime unmounts", async () => {
+    const sessions = createEveCloudSessions();
+    const waiting = sessions.wait("thread-1");
+
+    sessions.release("thread-1");
+
+    await expect(waiting).rejects.toThrow(
+      "The thread's eve runtime unmounted before its first turn created a session.",
+    );
+  });
+
+  it("keeps threads apart", async () => {
+    const sessions = createEveCloudSessions();
+    const first = sessions.wait("thread-1");
+    const second = sessions.wait("thread-2");
+
+    sessions.resolve("thread-2", "session-2");
+    sessions.resolve("thread-1", "session-1");
+
+    await expect(first).resolves.toBe("session-1");
+    await expect(second).resolves.toBe("session-2");
+  });
+});

package/src/eveCloudSessions.ts

@@ -0,0 +1,59 @@
+type PendingSession = {
+  readonly promise: Promise<string>;
+  readonly resolve: (sessionId: string) => void;
+  readonly reject: (error: unknown) => void;
+  sessionId?: string;
+};
+
+const createPendingSession = (): PendingSession => {
+  let resolve!: (sessionId: string) => void;
+  let reject!: (error: unknown) => void;
+  const promise = new Promise<string>((onResolve, onReject) => {
+    resolve = onResolve;
+    reject = onReject;
+  });
+  // A thread can fail its first turn before the thread list asks for its session.
+  promise.catch(() => {});
+  return { promise, resolve, reject };
+};
+
+/** Lets the cloud thread list wait for the eve session a new thread's first turn creates, because eve assigns a session id only once that turn is accepted while a cloud thread takes its external id when it is created. */
+export const createEveCloudSessions = () => {
+  const pending = new Map<string, PendingSession>();
+
+  const get = (threadId: string) => {
+    let session = pending.get(threadId);
+    if (!session) {
+      session = createPendingSession();
+      pending.set(threadId, session);
+    }
+    return session;
+  };
+
+  return {
+    wait: (threadId: string) => get(threadId).promise,
+    resolve: (threadId: string, sessionId: string) => {
+      const session = get(threadId);
+      if (session.sessionId !== undefined) return;
+      session.sessionId = sessionId;
+      session.resolve(sessionId);
+    },
+    reject: (threadId: string, error: Error) => {
+      const session = pending.get(threadId);
+      if (!session || session.sessionId !== undefined) return;
+      pending.delete(threadId);
+      session.reject(error);
+    },
+    release: (threadId: string) => {
+      const session = pending.get(threadId);
+      pending.delete(threadId);
+      session?.reject(
+        new Error(
+          "The thread's eve runtime unmounted before its first turn created a session.",
+        ),
+      );
+    },
+  };
+};
+
+export type EveCloudSessions = ReturnType<typeof createEveCloudSessions>;

package/src/hooks.ts

@@ -13,6 +13,8 @@ export const useEveError = () => eveExtras.use((e) => e.error, undefined);
  * Read the current Eve session cursor from the runtime extras. Persist it to
  * resume the session later via `initialSession`. `undefined` when no session
  * exists yet or outside an Eve runtime.
+ *
+ * With `cloud`, each cloud thread already keeps its session, so there is nothing to persist.
  */
 export const useEveSession = (): EveRuntimeExtras["session"] | undefined =>
   eveExtras.use((e) => e.session, undefined);
@@ -29,6 +31,8 @@ export const useEveEvents = (): EveRuntimeExtras["events"] =>
  * recreates the owned session, and clears events and projected data. Pending
  * staged messages and tool execution state are discarded. Safe to render
  * outside an Eve runtime; invoking the returned function there throws.
+ *
+ * With `cloud`, it starts a new thread instead, leaving the current thread and its session in the list.
  */
 export const useEveReset = () => {
   const aui = useAui();

package/src/sdkIdentity.ts

@@ -0,0 +1,9 @@
+import type { SdkIdentity } from "assistant-cloud";
+
+export const EVE_SDK: SdkIdentity = {
+  name: "@assistant-ui/eve",
+  version:
+    typeof __AUI_PACKAGE_VERSION__ === "string"
+      ? __AUI_PACKAGE_VERSION__
+      : "0.0.0",
+};