zidane-ui 0.0.0-stage → 9.0.2

package/dist/adapters/live.js

@@ -0,0 +1,164 @@
+import { writable } from "../chat/headless/store.js";
+import { applyLiveEvent, finishLive } from "../chat/headless/streams/live-events.js";
+import { SessionStreamStore } from "../chat/headless/streams/store.js";
+import { transcriptSnapshot } from "../chat/headless/streams/transcript.js";
+//#region src/adapters/live.ts
+/**
+* Creates the stores a {@link ChatHost} exposes: the session list, per-session transcripts, and pending interactions.
+*
+* @param options - The initial sessions and the transcript open and close hooks.
+*/
+function createLiveState(options = {}) {
+	const sessions = writable(options.sessions ?? []);
+	const store = new SessionStreamStore({
+		batch: false,
+		markdown: {}
+	});
+	const transcripts = /* @__PURE__ */ new Map();
+	const pendings = /* @__PURE__ */ new Map();
+	const allPending = writable([]);
+	const readables = /* @__PURE__ */ new Map();
+	const transcript = (sessionId) => {
+		let t = transcripts.get(sessionId);
+		if (!t) {
+			t = {
+				state: transcriptState(store, sessionId),
+				get echoes() {
+					return store.pendingEchoes(sessionId);
+				},
+				set echoes(next) {
+					const echoes = store.pendingEchoes(sessionId);
+					echoes.splice(0, echoes.length, ...next);
+				}
+			};
+			transcripts.set(sessionId, t);
+		}
+		return t;
+	};
+	const pending = (sessionId) => {
+		let p = pendings.get(sessionId);
+		if (!p) {
+			p = writable([]);
+			pendings.set(sessionId, p);
+		}
+		return p;
+	};
+	const patchSession = (sessionId, patch) => sessions.set((all) => all.some((s) => s.id === sessionId) ? all.map((s) => s.id === sessionId ? {
+		...s,
+		...patch
+	} : s) : all);
+	return {
+		sessions,
+		transcript,
+		readable(sessionId, extra) {
+			let r = readables.get(sessionId);
+			if (r) return r;
+			const { state } = transcript(sessionId);
+			let subscribers = 0;
+			r = {
+				get: state.get,
+				subscribe(onChange) {
+					const off = state.subscribe(onChange);
+					if (subscribers++ === 0) options.onOpen?.(sessionId);
+					let done = false;
+					return () => {
+						if (done) return;
+						done = true;
+						off();
+						if (--subscribers === 0) options.onClose?.(sessionId);
+					};
+				},
+				...extra?.loadEarlier ? { loadEarlier: extra.loadEarlier } : {}
+			};
+			readables.set(sessionId, r);
+			return r;
+		},
+		hydrate(sessionId, events, patch) {
+			const t = transcript(sessionId);
+			t.echoes = [];
+			t.state.set((s) => ({
+				...s,
+				...patch,
+				events: [...events],
+				hydrated: true
+			}));
+		},
+		apply(sessionId, event, echo) {
+			transcript(sessionId);
+			store.applySignal({
+				kind: "event",
+				sessionId,
+				event,
+				...echo ? { echo } : {}
+			});
+		},
+		echoPrompt(sessionId, text, attachments) {
+			transcript(sessionId);
+			store.appendUserPrompt(sessionId, text, void 0, attachments ?? []);
+		},
+		setRunning(sessionId, running, status) {
+			transcript(sessionId).state.set((s) => s.running === running ? s : {
+				...s,
+				running,
+				events: running ? s.events : finishLive(s.events)
+			});
+			patchSession(sessionId, {
+				status: status ?? (running ? "running" : "completed"),
+				updatedAt: Date.now()
+			});
+		},
+		patchSession,
+		pending,
+		allPending,
+		addInteraction(sessionId, request) {
+			if (allPending.get().some((i) => i.requestId === request.id)) return;
+			const item = {
+				requestId: request.id,
+				sessionId,
+				request
+			};
+			pending(sessionId).set((all) => [...all, item]);
+			allPending.set((all) => [...all, item]);
+		},
+		resolveInteraction(requestId) {
+			for (const p of pendings.values()) if (p.get().some((i) => i.requestId === requestId)) p.set((all) => all.filter((i) => i.requestId !== requestId));
+			if (allPending.get().some((i) => i.requestId === requestId)) allPending.set((all) => all.filter((i) => i.requestId !== requestId));
+		},
+		interactionSession(requestId) {
+			for (const p of pendings.values()) {
+				const hit = p.get().find((i) => i.requestId === requestId);
+				if (hit) return hit.sessionId;
+			}
+		}
+	};
+}
+/**
+* A session's transcript state as a writable store over the session stream
+* store: reads are the store's snapshots, a write sets the events, the run
+* flag and the page state (`hydrated`, `hasEarlier`, `loadingEarlier`) in
+* one notification.
+*/
+function transcriptState(store, sessionId) {
+	let last;
+	const get = () => last = transcriptSnapshot(store, sessionId, last);
+	return {
+		get,
+		set(next) {
+			const prev = get();
+			const resolved = typeof next === "function" ? next(prev) : next;
+			if (Object.is(resolved, prev)) return;
+			store.write(sessionId, {
+				...resolved.events !== prev.events ? { events: resolved.events } : {},
+				running: resolved.running,
+				page: resolved.hydrated ? {
+					firstSeq: store.getPageSnapshot(sessionId).firstSeq,
+					hasMore: resolved.hasEarlier ?? false,
+					loadingEarlier: resolved.loadingEarlier ?? false
+				} : null
+			});
+		},
+		subscribe: (onChange) => store.subscribeSession(sessionId, onChange)
+	};
+}
+//#endregion
+export { applyLiveEvent, createLiveState, finishLive };

package/dist/adapters/run-host.d.ts

@@ -0,0 +1,60 @@
+import { Readable } from "../chat/headless/store.js";
+import { ChatAttachment, ChatEvent, ChatHost, ChatModelProvider, ChatSession, SendInput } from "../chat/headless/host.js";
+import { InteractionRequest, InteractionResponse } from "zidane/chat";
+//#region src/adapters/run-host.d.ts
+/** What {@link createRunHost} hands to the `run` function for one sent prompt. */
+interface RunContext {
+  /** Id of the session the prompt was sent to. */
+  sessionId: string;
+  /** The prompt text. */
+  prompt: string;
+  /** Files sent with the prompt. Empty when there are none. */
+  attachments: readonly ChatAttachment[];
+  /** The model the user picked, as `provider/model` or a bare id. Absent when none was picked. */
+  model?: string;
+  /** The reasoning effort the user picked. Absent when none was picked. */
+  thinking?: SendInput['thinking'];
+  /** Aborted on interrupt. */
+  signal: AbortSignal;
+  /** Streams an event into the session's transcript. Markdown and thinking events with `streaming` grow the open block; any other event is a new row. */
+  emit(event: ChatEvent): void;
+  /** Ask the user; resolves with the answer, or `null` when dismissed or interrupted. */
+  ask(request: InteractionRequest): Promise<InteractionResponse | null>;
+  /** Receive messages the user steers into this run. Without a listener, `steer` reports false. */
+  onSteer(listener: (message: string) => void): void;
+}
+/** Runs the agent for one prompt. Called once per sent prompt with a {@link RunContext}. The run ends when the returned promise settles; a rejection shows as an error row. */
+type RunFn = (context: RunContext) => void | Promise<void>;
+/** Options for {@link createRunHost}. */
+interface RunHostOptions {
+  /** The function that runs the agent for each sent prompt. */
+  run: RunFn;
+  /** Sessions to start with (default: none; the user creates them). */
+  sessions?: readonly ChatSession[];
+  /** Their existing events, per session id. */
+  transcripts?: Record<string, readonly ChatEvent[]>;
+  /** Providers and models the host offers, fixed or live (a model's details change). Default: none. */
+  models?: readonly ChatModelProvider[] | Readable<readonly ChatModelProvider[]>;
+  /** New session ids (default: `crypto.randomUUID()`). */
+  newId?: () => string;
+}
+/** The {@link ChatHost} {@link createRunHost} returns, plus what only an in-memory host can do. */
+interface RunHost extends ChatHost {
+  /**
+   * Adds a session with a history, as a new session first in the list (a saved or shared one). Its events show as they are; the agent's own memory of them is the app's concern.
+   *
+   * @param session - The session's title.
+   * @param events - Its transcript events, oldest first.
+   */
+  restore(session: {
+    title: string;
+  }, events: readonly ChatEvent[]): ChatSession;
+}
+/**
+ * Creates a {@link ChatHost} around a run function. Sessions, transcripts, and pending interactions live in memory; the app supplies the agent through `run`.
+ *
+ * @param options - The `run` function and optional initial sessions, transcripts, and models.
+ */
+declare function createRunHost(options: RunHostOptions): RunHost;
+//#endregion
+export { RunContext, RunFn, RunHost, RunHostOptions, createRunHost };

package/dist/adapters/run-host.js

@@ -0,0 +1,173 @@
+import { constant } from "../chat/headless/store.js";
+import { createLiveState } from "./live.js";
+//#region src/adapters/run-host.ts
+/**
+* Creates a {@link ChatHost} around a run function. Sessions, transcripts, and pending interactions live in memory; the app supplies the agent through `run`.
+*
+* @param options - The `run` function and optional initial sessions, transcripts, and models.
+*/
+function createRunHost(options) {
+	const state = createLiveState({ sessions: options.sessions ?? [] });
+	for (const s of options.sessions ?? []) state.hydrate(s.id, options.transcripts?.[s.id] ?? []);
+	const runs = /* @__PURE__ */ new Map();
+	const waiters = /* @__PURE__ */ new Map();
+	const newId = options.newId ?? (() => crypto.randomUUID());
+	const settle = (requestId, response) => {
+		state.resolveInteraction(requestId);
+		const waiter = waiters.get(requestId);
+		waiters.delete(requestId);
+		waiter?.(response);
+	};
+	const send = async (input) => {
+		const { sessionId } = input;
+		if (runs.has(sessionId)) {
+			runs.get(sessionId).queued.push(input);
+			return;
+		}
+		if (!state.transcript(sessionId).state.get().hydrated) state.hydrate(sessionId, []);
+		const active = {
+			controller: new AbortController(),
+			queued: []
+		};
+		runs.set(sessionId, active);
+		state.echoPrompt(sessionId, input.prompt, input.attachments);
+		state.setRunning(sessionId, true);
+		const live = () => runs.get(sessionId) === active;
+		const asked = /* @__PURE__ */ new Set();
+		let failed = false;
+		try {
+			await options.run({
+				sessionId,
+				prompt: input.prompt,
+				attachments: input.attachments ?? [],
+				...input.model ? { model: input.model } : {},
+				...input.thinking ? { thinking: input.thinking } : {},
+				signal: active.controller.signal,
+				emit(event) {
+					if (live()) state.apply(sessionId, event);
+				},
+				ask(request) {
+					if (!live()) return Promise.resolve(null);
+					asked.add(request.id);
+					return new Promise((resolve) => {
+						waiters.set(request.id, resolve);
+						state.addInteraction(sessionId, request);
+					});
+				},
+				onSteer(listener) {
+					active.steer = listener;
+				}
+			});
+		} catch (error) {
+			if (live() && !active.controller.signal.aborted) {
+				failed = true;
+				state.apply(sessionId, {
+					kind: "error",
+					text: error instanceof Error ? error.message : String(error)
+				});
+			}
+		}
+		for (const id of asked) if (waiters.has(id)) settle(id, null);
+		if (!live()) return;
+		runs.delete(sessionId);
+		state.setRunning(sessionId, false, failed ? "error" : "completed");
+		const next = active.queued.shift();
+		if (next !== void 0) {
+			const started = send(next);
+			runs.get(sessionId)?.queued.push(...active.queued);
+			await started;
+		}
+	};
+	const host = {
+		restore({ title }, events) {
+			const now = Date.now();
+			const session = {
+				id: newId(),
+				title,
+				status: "idle",
+				createdAt: now,
+				updatedAt: now
+			};
+			state.sessions.set((all) => [session, ...all]);
+			state.hydrate(session.id, events);
+			return session;
+		},
+		sessions: {
+			list: state.sessions,
+			async create(input) {
+				const now = Date.now();
+				const session = {
+					id: newId(),
+					title: input?.title ?? "New session",
+					status: "idle",
+					createdAt: now,
+					updatedAt: now
+				};
+				state.sessions.set((all) => [session, ...all]);
+				state.hydrate(session.id, []);
+				return session;
+			},
+			async rename(sessionId, title) {
+				state.patchSession(sessionId, {
+					title,
+					updatedAt: Date.now()
+				});
+			},
+			async setArchived(sessionId, archived) {
+				state.patchSession(sessionId, { archived });
+			},
+			async remove(sessionId) {
+				host.interrupt(sessionId);
+				state.sessions.set((all) => all.filter((s) => s.id !== sessionId));
+			}
+		},
+		transcript: (sessionId) => {
+			if (!state.transcript(sessionId).state.get().hydrated) state.hydrate(sessionId, []);
+			return state.readable(sessionId);
+		},
+		send,
+		interrupt(sessionId) {
+			const active = runs.get(sessionId);
+			if (!active) return;
+			runs.delete(sessionId);
+			active.controller.abort();
+			for (const i of state.pending(sessionId).get()) settle(i.requestId, null);
+			state.setRunning(sessionId, false, "idle");
+		},
+		async steer(sessionId, message) {
+			const active = runs.get(sessionId);
+			if (!active?.steer) return false;
+			state.apply(sessionId, {
+				kind: "user-prompt",
+				text: message
+			});
+			active.steer(message);
+			return true;
+		},
+		async followUp(sessionId, message) {
+			const active = runs.get(sessionId);
+			if (!active) return false;
+			active.queued.push({
+				sessionId,
+				prompt: message
+			});
+			return true;
+		},
+		interactions: {
+			pending: state.pending,
+			async answer(requestId, response) {
+				settle(requestId, response);
+			},
+			async cancel(requestId) {
+				settle(requestId, null);
+			}
+		},
+		models: isReadable(options.models) ? options.models : constant(options.models ?? [])
+	};
+	return host;
+}
+function isReadable(value) {
+	return typeof value === "object" && value !== null && typeof value.subscribe === "function";
+}
+//#endregion
+export { createRunHost };

package/dist/adapters/server-approvals-host.d.ts

@@ -0,0 +1,23 @@
+import { ApprovalsHost } from "../approvals/headless/host.js";
+import { ServerClient } from "zidane/ipc/browser";
+//#region src/adapters/server-approvals-host.d.ts
+/** Options for {@link createServerApprovalsHost}. */
+interface ServerApprovalsHostOptions {
+  /** The client to speak through, shared with the chat host (`createServerHost({ client })`) and other areas' hosts. */
+  client: ServerClient;
+  /**
+   * `false` leaves out `resolve` and `denyAll`, for a token without the `approve` scope.
+   * Default: `client.can('approvals.resolve')` once the handshake has landed, `true` before it.
+   */
+  canApprove?: boolean;
+  /** Called with errors no caller receives (a failed listing). Default: a console warning. */
+  onError?: (error: unknown) => void;
+}
+/**
+ * Creates an {@link ApprovalsHost} on a running zidane-server.
+ *
+ * @param options - The shared client, whether the token may answer approvals, and where background errors go.
+ */
+declare function createServerApprovalsHost(options: ServerApprovalsHostOptions): ApprovalsHost;
+//#endregion
+export { ServerApprovalsHostOptions, createServerApprovalsHost };

package/dist/adapters/server-approvals-host.js

@@ -0,0 +1,62 @@
+import { createPendingApprovals } from "../approvals/headless/pending.js";
+import { createSafelist } from "../approvals/headless/safelist.js";
+//#region src/adapters/server-approvals-host.ts
+/**
+* Creates an {@link ApprovalsHost} on a running zidane-server.
+*
+* @param options - The shared client, whether the token may answer approvals, and where background errors go.
+*/
+function createServerApprovalsHost(options) {
+	const { client } = options;
+	const canApprove = options.canApprove ?? (client.hello() === null || client.can("approvals.resolve"));
+	const onError = options.onError ?? ((error) => console.warn("createServerApprovalsHost:", error));
+	const offers = (method) => client.hello() === null || client.can(method);
+	const pending = createPendingApprovals((sink) => {
+		let live = true;
+		const list = () => {
+			client.call("approvals.listPending", {}).then((requests) => {
+				if (live && Array.isArray(requests)) sink.merge(requests);
+			}).catch((error) => {
+				if (live) onError(error);
+			});
+		};
+		const offSignal = client.onSignal((signal) => {
+			if (signal.kind === "approval:request") sink.add(signal.request);
+			else if (signal.kind === "approval:resolved") sink.drop(signal.requestId);
+		});
+		const offOpen = client.onOpen(() => list());
+		if (client.hello()) list();
+		return () => {
+			live = false;
+			offSignal();
+			offOpen();
+		};
+	});
+	return {
+		pending,
+		...offers("safelist.list") ? { safelist: createSafelist({
+			list: async () => (await client.call("safelist.list", {})).projects,
+			...offers("safelist.remove") ? { remove: async (project, entry) => {
+				await client.call("safelist.remove", {
+					project,
+					entry
+				});
+			} } : {}
+		}) } : {},
+		...canApprove ? {
+			async resolve(requestId, decision) {
+				if (!pending.take(requestId)) return;
+				await client.call("approvals.resolve", {
+					requestId,
+					decision
+				});
+			},
+			async denyAll(sessionId) {
+				pending.takeAll(sessionId);
+				await client.call("approvals.denyAll", sessionId === void 0 ? {} : { sessionId });
+			}
+		} : {}
+	};
+}
+//#endregion
+export { createServerApprovalsHost };

package/dist/adapters/server-client.d.ts

@@ -0,0 +1,2 @@
+import { SERVER_AUTH_CHECK_PATH, ServerCallError, ServerClient, ServerClientOptions, ServerClientState, ServerConnectionError, ServerRefusal, createServerClient } from "zidane/ipc/browser";
+export { SERVER_AUTH_CHECK_PATH, ServerCallError, type ServerClient, type ServerClientOptions, type ServerClientState, ServerConnectionError, type ServerRefusal, createServerClient };

package/dist/adapters/server-client.js

@@ -0,0 +1 @@
+export { SERVER_AUTH_CHECK_PATH, ServerCallError, ServerConnectionError, createServerClient } from "zidane/ipc/browser";

package/dist/adapters/server-composer-host.d.ts

@@ -0,0 +1,21 @@
+import { ComposerHost } from "../chat/headless/composer/host.js";
+import { ServerClient } from "zidane/ipc/browser";
+//#region src/adapters/server-composer-host.d.ts
+/** Options for {@link createServerComposerHost}. */
+interface ServerComposerHostOptions {
+  /** The client to speak through, shared with the chat host (`createServerHost(…).client`). */
+  client: ServerClient;
+}
+/** The {@link ComposerHost} {@link createServerComposerHost} returns. */
+interface ServerComposerHost extends ComposerHost {
+  /** Stops listening to the client (it leaves the client open). */
+  close(): void;
+}
+/**
+ * Creates a {@link ComposerHost} over a zidane-server client.
+ *
+ * @param options - The client to speak through.
+ */
+declare function createServerComposerHost(options: ServerComposerHostOptions): ServerComposerHost;
+//#endregion
+export { ServerComposerHost, ServerComposerHostOptions, createServerComposerHost };