@chelone/core 0.6.0 → 0.7.0

package/dist/assistant/assistant-session.d.ts

@@ -16,6 +16,12 @@ export interface CreateAssistantSessionOptions {
 export interface AssistantSession extends MicroStore<AssistantSessionState> {
     /** Resolves when the turn, with its tool rounds, ends. */
     send(text: string): Promise<void>;
+    /**
+     * After an error, runs the last user message again: whatever the failed
+     * turn added after it is dropped and no second user message is added.
+     * Does nothing unless the status is `error`.
+     */
+    retry(): Promise<void>;
     stop(): void;
     reset(): void;
 }

package/dist/assistant/assistant-session.js

@@ -1,185 +1,208 @@
 import { createMicroStore } from "../store/micro-store.js";
-const toError = (error) => error instanceof Error ? error : new Error(String(error));
-const issuesText = (issues) => issues.map((issue) => issue.message).join("; ");
+// src/assistant/assistant-session.ts
+var toError = (error) => error instanceof Error ? error : new Error(String(error));
+var issuesText = (issues) => issues.map((issue) => issue.message).join("; ");
+/** Resolves with `undefined` when the signal aborts before the promise settles. */
 function raceAbort(promise, signal) {
-  return new Promise((resolve, reject) => {
-    const onAbort = () => resolve(void 0);
-    if (signal.aborted) return onAbort();
-    signal.addEventListener("abort", onAbort, { once: true });
-    promise.then(resolve, reject).finally(() => {
-      signal.removeEventListener("abort", onAbort);
-    });
-  });
+	return new Promise((resolve, reject) => {
+		const onAbort = () => resolve(void 0);
+		if (signal.aborted) return onAbort();
+		signal.addEventListener("abort", onAbort, { once: true });
+		promise.then(resolve, reject).finally(() => {
+			signal.removeEventListener("abort", onAbort);
+		});
+	});
 }
-function createAssistantSession({
-  transport,
-  tools,
-  maxToolRounds = 5,
-  confirmTool
-}) {
-  const store = createMicroStore({
-    messages: [],
-    status: "idle",
-    error: null
-  });
-  const declarations = Object.fromEntries(
-    Object.entries(tools).map(([name, { description, parameters }]) => [
-      name,
-      { description, parameters }
-    ])
-  );
-  let active = null;
-  let destroyed = false;
-  store.onDestroy(() => {
-    destroyed = true;
-    active?.abort();
-    active = null;
-  });
-  async function runTool(call, signal) {
-    const base = {
-      role: "tool",
-      id: call.id,
-      toolName: call.toolName
-    };
-    const definition = Object.hasOwn(tools, call.toolName) ? tools[call.toolName] : void 0;
-    if (!definition) {
-      return { ...base, error: `Unknown tool: ${call.toolName}` };
-    }
-    const stopped = { ...base, error: "Stopped" };
-    try {
-      let args = call.args;
-      if (definition.schema) {
-        const outcome = await definition.schema["~standard"].validate(args);
-        if (signal.aborted) return stopped;
-        if (outcome.issues) {
-          return {
-            ...base,
-            error: `Invalid arguments: ${issuesText(outcome.issues)}`
-          };
-        }
-        args = outcome.value;
-      }
-      if (definition.confirm) {
-        const answer = await confirmTool?.(call);
-        if (signal.aborted) return stopped;
-        if (!answer) {
-          return { ...base, error: "The user declined to run this tool" };
-        }
-      }
-      return { ...base, result: await definition.handler(args) };
-    } catch (error) {
-      return { ...base, error: toError(error).message };
-    }
-  }
-  async function run(controller) {
-    const { signal } = controller;
-    const update = (patch) => {
-      if (!signal.aborted) store.setState(patch);
-    };
-    for (let round = 0; ; round++) {
-      let content = "";
-      let index = -1;
-      const calls = [];
-      let iterator;
-      try {
-        iterator = transport.send(store.getSnapshot().messages, declarations, { signal })[Symbol.asyncIterator]();
-        for (; ; ) {
-          const step = await raceAbort(iterator.next(), signal);
-          if (!step || step.done || signal.aborted) break;
-          const chunk = step.value;
-          if (chunk.type === "done") break;
-          if (chunk.type === "tool-call") {
-            const { id, toolName, args } = chunk;
-            calls.push({ id, toolName, args });
-            continue;
-          }
-          content += chunk.delta;
-          const text = content;
-          if (index < 0) {
-            index = store.getSnapshot().messages.length;
-            update((s) => ({
-              messages: [...s.messages, { role: "assistant", content: text }]
-            }));
-          } else {
-            update((s) => ({
-              messages: s.messages.map(
-                (m, i) => i === index ? { role: "assistant", content: text } : m
-              )
-            }));
-          }
-        }
-      } catch (error) {
-        if (!signal.aborted) {
-          update(() => ({ status: "error", error: toError(error) }));
-        }
-        return;
-      } finally {
-        iterator?.return?.().catch(() => {
-        });
-      }
-      if (signal.aborted) return;
-      if (calls.length === 0) break;
-      if (round >= maxToolRounds) {
-        update(() => ({
-          status: "error",
-          error: new Error(
-            `The assistant kept calling tools after ${maxToolRounds} rounds`
-          )
-        }));
-        return;
-      }
-      const results = [];
-      for (const call of calls) {
-        const result = await raceAbort(runTool(call, signal), signal);
-        if (!result) return;
-        results.push(result);
-        if (signal.aborted) return;
-      }
-      const assistant = {
-        role: "assistant",
-        content,
-        toolCalls: calls
-      };
-      update((s) => ({
-        messages: index < 0 ? [...s.messages, assistant, ...results] : [
-          ...s.messages.map((m, i) => i === index ? assistant : m),
-          ...results
-        ]
-      }));
-    }
-    update(() => ({ status: "idle" }));
-  }
-  return {
-    ...store,
-    async send(text) {
-      if (destroyed) return;
-      if (!text.trim() || store.getSnapshot().status === "streaming") return;
-      const controller = new AbortController();
-      active = controller;
-      store.setState((s) => ({
-        messages: [...s.messages, { role: "user", content: text }],
-        status: "streaming",
-        error: null
-      }));
-      try {
-        await run(controller);
-      } finally {
-        if (active === controller) active = null;
-      }
-    },
-    stop() {
-      if (!active) return;
-      active.abort();
-      active = null;
-      store.setState({ status: "idle" });
-    },
-    reset() {
-      active?.abort();
-      active = null;
-      store.setState({ messages: [], status: "idle", error: null });
-    }
-  };
+function createAssistantSession({ transport, tools, maxToolRounds = 5, confirmTool }) {
+	const store = createMicroStore({
+		messages: [],
+		status: "idle",
+		error: null
+	});
+	const declarations = Object.fromEntries(Object.entries(tools).map(([name, { description, parameters }]) => [name, {
+		description,
+		parameters
+	}]));
+	let active = null;
+	let destroyed = false;
+	store.onDestroy(() => {
+		destroyed = true;
+		active?.abort();
+		active = null;
+	});
+	async function runTool(call, signal) {
+		const base = {
+			role: "tool",
+			id: call.id,
+			toolName: call.toolName
+		};
+		const definition = Object.hasOwn(tools, call.toolName) ? tools[call.toolName] : void 0;
+		if (!definition) return {
+			...base,
+			error: `Unknown tool: ${call.toolName}`
+		};
+		const stopped = {
+			...base,
+			error: "Stopped"
+		};
+		try {
+			let args = call.args;
+			if (definition.schema) {
+				const outcome = await definition.schema["~standard"].validate(args);
+				if (signal.aborted) return stopped;
+				if (outcome.issues) return {
+					...base,
+					error: `Invalid arguments: ${issuesText(outcome.issues)}`
+				};
+				args = outcome.value;
+			}
+			if (definition.confirm) {
+				const answer = await confirmTool?.(call);
+				if (signal.aborted) return stopped;
+				if (!answer) return {
+					...base,
+					error: "The user declined to run this tool"
+				};
+			}
+			return {
+				...base,
+				result: await definition.handler(args)
+			};
+		} catch (error) {
+			return {
+				...base,
+				error: toError(error).message
+			};
+		}
+	}
+	async function run(controller) {
+		const { signal } = controller;
+		const update = (patch) => {
+			if (!signal.aborted) store.setState(patch);
+		};
+		for (let round = 0;; round++) {
+			let content = "";
+			let index = -1;
+			const calls = [];
+			let iterator;
+			try {
+				iterator = transport.send(store.getSnapshot().messages, declarations, { signal })[Symbol.asyncIterator]();
+				for (;;) {
+					const step = await raceAbort(iterator.next(), signal);
+					if (!step || step.done || signal.aborted) break;
+					const chunk = step.value;
+					if (chunk.type === "done") break;
+					if (chunk.type === "tool-call") {
+						const { id, toolName, args } = chunk;
+						calls.push({
+							id,
+							toolName,
+							args
+						});
+						continue;
+					}
+					content += chunk.delta;
+					const text = content;
+					if (index < 0) {
+						index = store.getSnapshot().messages.length;
+						update((s) => ({ messages: [...s.messages, {
+							role: "assistant",
+							content: text
+						}] }));
+					} else update((s) => ({ messages: s.messages.map((m, i) => i === index ? {
+						role: "assistant",
+						content: text
+					} : m) }));
+				}
+			} catch (error) {
+				if (!signal.aborted) update(() => ({
+					status: "error",
+					error: toError(error)
+				}));
+				return;
+			} finally {
+				iterator?.return?.().catch(() => {});
+			}
+			if (signal.aborted) return;
+			if (calls.length === 0) break;
+			if (round >= maxToolRounds) {
+				update(() => ({
+					status: "error",
+					error: /* @__PURE__ */ new Error(`The assistant kept calling tools after ${maxToolRounds} rounds`)
+				}));
+				return;
+			}
+			const results = [];
+			for (const call of calls) {
+				const result = await raceAbort(runTool(call, signal), signal);
+				if (!result) return;
+				results.push(result);
+				if (signal.aborted) return;
+			}
+			const assistant = {
+				role: "assistant",
+				content,
+				toolCalls: calls
+			};
+			update((s) => ({ messages: index < 0 ? [
+				...s.messages,
+				assistant,
+				...results
+			] : [...s.messages.map((m, i) => i === index ? assistant : m), ...results] }));
+		}
+		update(() => ({ status: "idle" }));
+	}
+	async function start(controller) {
+		active = controller;
+		try {
+			await run(controller);
+		} finally {
+			if (active === controller) active = null;
+		}
+	}
+	return {
+		...store,
+		async send(text) {
+			if (destroyed) return;
+			if (!text.trim() || store.getSnapshot().status === "streaming") return;
+			store.setState((s) => ({
+				messages: [...s.messages, {
+					role: "user",
+					content: text
+				}],
+				status: "streaming",
+				error: null
+			}));
+			await start(new AbortController());
+		},
+		async retry() {
+			if (destroyed || store.getSnapshot().status !== "error") return;
+			const { messages } = store.getSnapshot();
+			let last = messages.length - 1;
+			while (last >= 0 && messages[last]?.role !== "user") last--;
+			if (last < 0) return;
+			store.setState({
+				messages: messages.slice(0, last + 1),
+				status: "streaming",
+				error: null
+			});
+			await start(new AbortController());
+		},
+		stop() {
+			if (!active) return;
+			active.abort();
+			active = null;
+			store.setState({ status: "idle" });
+		},
+		reset() {
+			active?.abort();
+			active = null;
+			store.setState({
+				messages: [],
+				status: "idle",
+				error: null
+			});
+		}
+	};
 }
-export {
-  createAssistantSession
-};
+export { createAssistantSession };

package/dist/assistant/echo-transport.js

@@ -1,31 +1,28 @@
-const wait = (ms, signal) => new Promise((resolve) => {
-  const timer = setTimeout(done, ms);
-  function done() {
-    clearTimeout(timer);
-    signal.removeEventListener("abort", done);
-    resolve();
-  }
-  signal.addEventListener("abort", done, { once: true });
+// src/assistant/echo-transport.ts
+var wait = (ms, signal) => new Promise((resolve) => {
+	const timer = setTimeout(done, ms);
+	function done() {
+		clearTimeout(timer);
+		signal.removeEventListener("abort", done);
+		resolve();
+	}
+	signal.addEventListener("abort", done, { once: true });
 });
-function echoAssistantTransport({
-  delayMs = 0
-} = {}) {
-  return {
-    async *send(messages, _tools, { signal }) {
-      let said = "";
-      for (const message of messages) {
-        if (message.role === "user") said = message.content;
-      }
-      const reply = `Echo: ${said}`;
-      for (const delta of reply) {
-        if (delayMs > 0) await wait(delayMs, signal);
-        if (signal.aborted) return;
-        yield { type: "text", delta };
-      }
-      yield { type: "done" };
-    }
-  };
+/** Replies `Echo: <last user text>` one character at a time, with no model behind it. */
+function echoAssistantTransport({ delayMs = 0 } = {}) {
+	return { async *send(messages, _tools, { signal }) {
+		let said = "";
+		for (const message of messages) if (message.role === "user") said = message.content;
+		const reply = `Echo: ${said}`;
+		for (const delta of reply) {
+			if (delayMs > 0) await wait(delayMs, signal);
+			if (signal.aborted) return;
+			yield {
+				type: "text",
+				delta
+			};
+		}
+		yield { type: "done" };
+	} };
 }
-export {
-  echoAssistantTransport
-};
+export { echoAssistantTransport };

package/dist/assistant/http-transport.d.ts

@@ -0,0 +1,10 @@
+import type { AssistantTransport } from "./types.js";
+export interface HttpAssistantTransportOptions {
+    url: string;
+    /** Resolved for each request so tokens can change between turns. */
+    headers?: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>);
+    credentials?: RequestCredentials;
+    fetch?: typeof globalThis.fetch;
+}
+/** Posts a conversation to an app endpoint that replies with NDJSON AssistantChunks. */
+export declare function httpAssistantTransport(options: HttpAssistantTransportOptions): AssistantTransport;

package/dist/assistant/http-transport.js

@@ -0,0 +1,98 @@
+import { HttpError } from "../data/http-error.js";
+import { isJsonObject, isRecord } from "../guards.js";
+// src/assistant/http-transport.ts
+function parseChunk(line, lineNumber) {
+	const invalid = () => /* @__PURE__ */ new Error(`Invalid assistant chunk at line ${lineNumber}`);
+	let chunk;
+	try {
+		chunk = JSON.parse(line);
+	} catch {
+		throw invalid();
+	}
+	if (isRecord(chunk)) switch (chunk.type) {
+		case "text":
+			if (typeof chunk.delta === "string") return {
+				type: "text",
+				delta: chunk.delta
+			};
+			break;
+		case "tool-call":
+			if (typeof chunk.id === "string" && typeof chunk.toolName === "string" && isJsonObject(chunk.args)) return {
+				type: "tool-call",
+				id: chunk.id,
+				toolName: chunk.toolName,
+				args: chunk.args
+			};
+			break;
+		case "done": return { type: "done" };
+	}
+	throw invalid();
+}
+/** Posts a conversation to an app endpoint that replies with NDJSON AssistantChunks. */
+function httpAssistantTransport(options) {
+	const doFetch = options.fetch ?? ((input, init) => globalThis.fetch(input, init));
+	return { async *send(messages, tools, { signal }) {
+		try {
+			if (signal.aborted) return;
+			const headers = new Headers(typeof options.headers === "function" ? await options.headers() : options.headers);
+			if (signal.aborted) return;
+			headers.set("Content-Type", "application/json");
+			const response = await doFetch(options.url, {
+				method: "POST",
+				headers,
+				credentials: options.credentials,
+				body: JSON.stringify({
+					messages,
+					tools
+				}),
+				signal
+			});
+			if (!response.ok) throw new HttpError(`Assistant request failed (HTTP ${response.status})`, response.status, await response.text());
+			const reader = response.body?.getReader();
+			if (reader) {
+				const decoder = new TextDecoder();
+				let pending = "";
+				let lineNumber = 0;
+				let released = false;
+				const release = () => {
+					if (released) return;
+					released = true;
+					reader.cancel().catch(() => {});
+					reader.releaseLock();
+				};
+				signal.addEventListener("abort", release, { once: true });
+				try {
+					for (;;) {
+						if (signal.aborted) return;
+						const step = await reader.read();
+						if (signal.aborted) return;
+						pending += decoder.decode(step.value, { stream: !step.done });
+						if (step.done) pending += "\n";
+						let end = pending.indexOf("\n");
+						while (end >= 0) {
+							if (signal.aborted) return;
+							lineNumber++;
+							const line = pending.slice(0, end).trim();
+							pending = pending.slice(end + 1);
+							if (line) {
+								const chunk = parseChunk(line, lineNumber);
+								yield chunk;
+								if (chunk.type === "done") return;
+							}
+							end = pending.indexOf("\n");
+						}
+						if (step.done) break;
+					}
+				} finally {
+					signal.removeEventListener("abort", release);
+					release();
+				}
+			}
+			if (signal.aborted) return;
+			yield { type: "done" };
+		} catch (error) {
+			if (!signal.aborted) throw error;
+		}
+	} };
+}
+export { httpAssistantTransport };

package/dist/assistant/types.d.ts

@@ -1,11 +1,5 @@
 import type { StandardSchemaV1 } from "@tanstack/form-core";
-/** What crosses the model boundary: arguments in, results out. */
-export type JsonValue = string | number | boolean | null | JsonValue[] | {
-    [key: string]: JsonValue;
-};
-export type JsonObject = {
-    [key: string]: JsonValue;
-};
+import type { JsonObject, JsonValue } from "../guards.js";
 /** A tool call the model asked for. `id` ties the result back to it. */
 export interface AssistantToolCall {
     id: string;

package/dist/auth/access-control.d.ts

@@ -1,9 +1,17 @@
+import type { ResourceRecord } from "../resource/record.js";
 import type { CanAccessParams } from "./types.js";
-/** One grant. `record` predicate (when present) must pass against a provided record. */
-export interface Permission {
+/**
+ * One grant. `record` predicate (when present) must pass against a provided
+ * record, and reads it as `TRecord` — the same record shape the check is given.
+ */
+export interface Permission<TRecord extends ResourceRecord = ResourceRecord> {
     action: string | string[];
     resource: string;
-    record?: (record: unknown) => boolean;
+    record?: (record: TRecord) => boolean;
 }
-/** Deny-by-default permission matcher (OR across permissions). */
-export declare function canAccessWithPermissions(permissions: Permission[], params: CanAccessParams): boolean;
+/**
+ * Deny-by-default permission matcher (OR across permissions). `TRecord` is fixed
+ * by the permissions and the params together, so a grant's predicate and the
+ * record it reads are the same type.
+ */
+export declare function canAccessWithPermissions<TRecord extends ResourceRecord = ResourceRecord>(permissions: Permission<TRecord>[], params: CanAccessParams<TRecord>): boolean;