better-supabase 0.5.1 → 0.6.0

package/dist/eve/index.js

@@ -0,0 +1,504 @@
+import { t as DbException } from "../db-exception-CnWcYPxL.js";
+import { a as tenantClaimPaths, n as claimAt, t as DEFAULT_CLAIMS } from "../claims-PqzCxaTD.js";
+import { i as resolveAuth } from "../resolve-D_IcnvFd.js";
+import { t as isAnonymousUser } from "../view-BeFcRV6G.js";
+import { d as isRecord } from "../block-helpers-DWHxHsEQ.js";
+//#region src/eve/ids.ts
+/** A UUID (version 8) from the SHA-256 of `input`, so the same input always gets the same id. */
+async function stableUuid(input) {
+	const bytes = new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(input))).slice(0, 16);
+	bytes[6] = (bytes[6] ?? 0) & 15 | 128;
+	bytes[8] = (bytes[8] ?? 0) & 63 | 128;
+	const hex = [...bytes].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+	return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+//#endregion
+//#region src/eve/auth.ts
+/** Thrown by `supabaseAuth` so eve answers with `response` instead of downgrading to anonymous. */
+var EveAuthRejection = class extends Error {
+	name = "EveAuthRejection";
+	response;
+	constructor(message, status = 401) {
+		super(message);
+		this.response = new Response(JSON.stringify({ error: message }), {
+			status,
+			headers: { "content-type": "application/json" }
+		});
+	}
+};
+function rolesIn(claims, tenantId, claim) {
+	const memberships = claims[claim];
+	const strings = (value) => Array.isArray(value) ? value.filter((role) => typeof role === "string") : [];
+	if (tenantId === void 0) return [];
+	if (Array.isArray(memberships)) return [...new Set(memberships.flatMap((entry) => isRecord(entry) && entry["id"] === tenantId ? strings(entry["roles"]) : []))];
+	return isRecord(memberships) ? strings(memberships[tenantId]) : [];
+}
+/** The eve principal for a verified Supabase user, or `null` for anyone else. */
+function principalOf(auth, options = {}) {
+	if (auth.kind !== "user") return null;
+	const claims = auth.claims;
+	let tenantId;
+	for (const path of tenantClaimPaths(options.tenantClaim)) tenantId ??= claimAt(claims, path);
+	const issuer = typeof claims["iss"] === "string" ? claims["iss"] : void 0;
+	return {
+		authenticator: "supabase",
+		principalType: "user",
+		principalId: auth.claims.sub,
+		subject: auth.claims.sub,
+		...issuer === void 0 ? {} : { issuer },
+		attributes: {
+			...tenantId === void 0 ? {} : { tenantId },
+			roles: rolesIn(claims, tenantId, options.membershipsClaim ?? DEFAULT_CLAIMS.memberships),
+			isAnonymous: isAnonymousUser(claims) ? "true" : "false",
+			...options.attributes?.(claims)
+		}
+	};
+}
+/**
+* An eve route `AuthFn` that verifies the Supabase session locally (cookie or
+* bearer) and maps the user to a principal. Requests without a session fall
+* through to the next entry; an invalid token is rejected with 401.
+*/
+function supabaseAuth(options) {
+	return async (request) => {
+		const { auth } = await resolveAuth(request, options);
+		if (auth.kind === "invalid") throw new EveAuthRejection("The Supabase session is not valid");
+		return principalOf(auth, options);
+	};
+}
+//#endregion
+//#region src/eve/connections.ts
+/** eve's `ConnectionAuthorizationRequiredError`, matched by name. */
+var ConnectionAuthorizationRequiredError = class extends Error {
+	name = "ConnectionAuthorizationRequiredError";
+	connectionName;
+	constructor(connectionName, options = {}) {
+		super(options.message ?? `Connection "${connectionName}" needs authorization`);
+		this.connectionName = connectionName;
+	}
+};
+/** eve's `ConnectionAuthorizationFailedError`, matched by name. */
+var ConnectionAuthorizationFailedError = class extends Error {
+	name = "ConnectionAuthorizationFailedError";
+	connectionName;
+	reason;
+	retryable;
+	constructor(connectionName, options) {
+		super(options.message ?? `Connection "${connectionName}" failed: ${options.reason}`);
+		this.connectionName = connectionName;
+		this.reason = options.reason;
+		this.retryable = options.retryable;
+	}
+};
+const AUTHORIZATION_HINTS = /* @__PURE__ */ new Set([
+	"CREDENTIAL_AUTHORIZATION_REQUIRED",
+	"CREDENTIAL_NOT_FOUND",
+	"CREDENTIAL_SUBJECT_REQUIRED"
+]);
+function connectionError(name, error) {
+	const hint = "hint" in error ? error.hint : void 0;
+	if (error.kind === "not_found" || typeof hint === "string" && AUTHORIZATION_HINTS.has(hint)) return new ConnectionAuthorizationRequiredError(name, { message: error.message });
+	if (error.kind === "forbidden" || error.kind === "invalid_input") return new ConnectionAuthorizationFailedError(name, {
+		message: error.message,
+		reason: typeof hint === "string" ? hint : error.kind,
+		retryable: false
+	});
+	return new DbException(error);
+}
+/**
+* An eve connection `authorization` over a better-supabase
+* `CredentialProvider` (Vault, Vercel Connect or your own): tokens come from
+* the provider for the app or for the session's user. A user without a stored
+* credential gets eve's authorization flow when the provider supports one.
+*/
+function credentialAuth(options) {
+	const name = options.connection ?? options.ref.provider;
+	const subjectOf = (principal) => {
+		if (options.owner === "app") return { type: "app" };
+		if (principal.type !== "user") throw new ConnectionAuthorizationRequiredError(name, { message: `Connection "${name}" needs a signed-in user` });
+		return principal.issuer === void 0 ? {
+			type: "user",
+			id: principal.id
+		} : {
+			type: "user",
+			id: principal.id,
+			issuer: principal.issuer
+		};
+	};
+	const displayName = options.connection === void 0 ? {} : { displayName: options.connection };
+	const getToken = async ({ principal }) => {
+		const result = await options.provider.getToken(options.ref, {
+			subject: subjectOf(principal),
+			...options.scopes === void 0 ? {} : { scopes: options.scopes }
+		});
+		if (!result.ok) throw connectionError(name, result.error);
+		const { token, expiresAt } = result.data;
+		return expiresAt === void 0 ? { token } : {
+			token,
+			expiresAt: expiresAt.epochMilliseconds
+		};
+	};
+	const { provider, ref } = options;
+	if (options.owner === "app" || options.interactive === false || !provider.capabilities(ref).authorization || !provider.startAuthorization || !provider.completeAuthorization) return {
+		credentialOwner: options.owner,
+		...displayName,
+		getToken
+	};
+	const start = provider.startAuthorization.bind(provider);
+	const complete = provider.completeAuthorization.bind(provider);
+	return {
+		principalType: "user",
+		...displayName,
+		getToken,
+		startAuthorization: async ({ principal, callbackUrl }) => {
+			const result = await start(ref, {
+				subject: subjectOf(principal),
+				redirectUri: callbackUrl,
+				...options.scopes === void 0 ? {} : { scopes: options.scopes }
+			});
+			if (!result.ok) throw connectionError(name, result.error);
+			return { challenge: { url: result.data.url } };
+		},
+		completeAuthorization: async (request) => {
+			const callback = new URL(request.callbackUrl);
+			for (const [key, value] of Object.entries(request.callback.params)) callback.searchParams.set(key, value);
+			const result = await complete(ref, {
+				subject: subjectOf(request.principal),
+				callback
+			});
+			if (!result.ok) throw connectionError(name, result.error);
+			return getToken(request);
+		}
+	};
+}
+//#endregion
+//#region src/eve/inbox.ts
+const INBOX_PREFIX = "inbox:";
+/**
+* Hands inbox conversations to eve through a `chatSdkChannel` built over
+* `inboxAdapter`. A message reaches eve only while the conversation's
+* `bot_mode` is `bot`, so an agent's handoff pauses the bot. The turn's
+* principal is the contact, never a user, so contacts get no user-scoped
+* connections.
+*/
+function routeInbox(bridge, options) {
+	const handle = async (thread, message) => {
+		if (!thread.id.startsWith(INBOX_PREFIX)) return;
+		const conversation = await options.inbox.conversations.get(thread.id.slice(6)).orThrow();
+		if (conversation?.botMode !== "bot") return;
+		const title = options.title ?? conversation.subject ?? void 0;
+		await bridge.send(message.text, {
+			thread,
+			auth: {
+				authenticator: "inbox",
+				principalType: "contact",
+				principalId: conversation.contactId,
+				attributes: {
+					tenantId: conversation.tenant,
+					conversationId: conversation.id
+				}
+			},
+			...title === void 0 ? {} : { title }
+		});
+	};
+	bridge.bot.onNewMention(async (thread, message) => {
+		await thread.subscribe();
+		await handle(thread, message);
+	});
+	bridge.bot.onSubscribedMessage(handle);
+}
+//#endregion
+//#region src/eve/sessions.ts
+/** The `ai_chats` id of an eve session: the same session always maps to the same chat. */
+function chatIdOf(sessionId) {
+	return stableUuid(`eve-session:${sessionId}`);
+}
+const streamOf = (sessionId, turnId) => `eve:${sessionId}:${turnId}`;
+/**
+* Hook handlers that copy an eve session into the canonical chat tables, so
+* the chat UI, search, memory recall and analytics read eve sessions like any
+* other chat. Every write is keyed by the event, so eve's at-least-once
+* delivery stores each message once. Sessions without a signed-in user and
+* tenant are skipped.
+*/
+function persistSessions(options) {
+	const { chats } = options;
+	const organizationOf = options.organizationOf ?? ((auth) => {
+		const tenant = auth.attributes["tenantId"];
+		return typeof tenant === "string" ? tenant : void 0;
+	});
+	const chatFor = async (ctx) => {
+		const auth = ctx.session.auth.initiator ?? ctx.session.auth.current;
+		if (auth?.principalType !== "user") return void 0;
+		const organizationId = organizationOf(auth);
+		if (organizationId === void 0) return void 0;
+		const id = await chatIdOf(ctx.session.id);
+		await chats.chats.create(organizationId, {
+			id,
+			ownerId: auth.principalId,
+			title: options.title ?? "eve session",
+			...options.agentId === void 0 ? {} : { agentId: options.agentId }
+		}).orThrow();
+		return id;
+	};
+	const knownChat = async (ctx) => {
+		const auth = ctx.session.auth.initiator ?? ctx.session.auth.current;
+		if (auth?.principalType !== "user" || organizationOf(auth) === void 0) return void 0;
+		return chatIdOf(ctx.session.id);
+	};
+	const release = async (ctx, turnId, status, error) => {
+		const chatId = await knownChat(ctx);
+		if (chatId === void 0) return;
+		await chats.runs.release(chatId, streamOf(ctx.session.id, turnId), {
+			status,
+			...error === void 0 ? {} : { error }
+		}).orThrow();
+	};
+	return {
+		"session.started": async (_event, ctx) => {
+			await chatFor(ctx);
+		},
+		"turn.started": async (event, ctx) => {
+			const chatId = await chatFor(ctx);
+			if (chatId === void 0) return;
+			await chats.runs.claim(chatId, streamOf(ctx.session.id, event.data.turnId), { engine: "eve" }).orThrow();
+		},
+		"message.received": async (event, ctx) => {
+			const chatId = await chatFor(ctx);
+			if (chatId === void 0 || event.data.message.length === 0) return;
+			const id = `${event.data.turnId}:${String(event.data.sequence)}`;
+			await chats.messages.appendUser(chatId, {
+				id,
+				role: "user",
+				parts: [{
+					type: "text",
+					text: event.data.message
+				}]
+			}).orThrow();
+		},
+		"message.completed": async (event, ctx) => {
+			const chatId = await knownChat(ctx);
+			if (chatId === void 0 || event.data.message.length === 0) return;
+			const chat = await chats.chats.get(chatId).orThrow();
+			if (chat.leafId === void 0) return;
+			const id = `${event.data.turnId}:${String(event.data.stepIndex)}:${String(event.data.sequence)}`;
+			await chats.messages.saveAssistant(chatId, {
+				id,
+				role: "assistant",
+				parts: [{
+					type: "text",
+					text: event.data.message
+				}],
+				...event.data.finishReason === "tool-calls" ? { metadata: { interim: true } } : {}
+			}, {
+				parentId: chat.leafId,
+				status: "complete",
+				format: "eve",
+				native: event.data,
+				runId: chat.activeRunId
+			}).orThrow();
+		},
+		"turn.completed": (event, ctx) => release(ctx, event.data.turnId, "completed"),
+		"turn.failed": (event, ctx) => release(ctx, event.data.turnId, "failed", `${event.data.code}: ${event.data.message}`),
+		"turn.cancelled": (event, ctx) => release(ctx, event.data.turnId, "cancelled")
+	};
+}
+//#endregion
+//#region src/eve/eve.ts
+/** eve's `MemoryDocumentConflictError`, matched by name. */
+var MemoryDocumentConflictError = class extends Error {
+	name = "MemoryDocumentConflictError";
+	key;
+	constructor(key) {
+		super(`Memory document "${key}" changed since it was read`);
+		this.key = key;
+	}
+};
+const isConflict = (error) => "hint" in error && error.hint === "MEMORY_DOCUMENT_CONFLICT";
+/**
+* A document backend for eve's `fileMemory()` over the memory module's
+* `memory_documents` table. A write with a stale version throws
+* `MemoryDocumentConflictError`, so eve retries with the current document.
+*/
+function supabaseDocumentBackend(options) {
+	const scope = options.scope ?? "eve";
+	return {
+		apiVersion: 1,
+		read: async ({ key }) => {
+			const result = await options.memory.documents.read(scope, key);
+			if (!result.ok) throw new DbException(result.error);
+			return result.data ?? null;
+		},
+		write: async ({ key, content, expectedVersion }) => {
+			const result = await options.memory.documents.write(scope, key, content, { expectedVersion });
+			if (result.ok) return result.data;
+			if (isConflict(result.error)) throw new MemoryDocumentConflictError(key);
+			throw new DbException(result.error);
+		}
+	};
+}
+const OPS_SCOPE = "eve-ops";
+const OP_TTL_SECONDS = 604800;
+function textOfMessage(message) {
+	if (typeof message.content === "string") return message.content;
+	return message.content.flatMap((part) => part.type === "text" && typeof part.text === "string" ? [part.text] : []).join("\n");
+}
+const isToolsModule = (value) => isRecord(value) && typeof value["defineTool"] === "function";
+/**
+* Loads `eve/tools` when the provider first builds its tools. The specifier
+* is a variable so bundlers leave the optional peer out.
+*/
+async function loadTools() {
+	const specifier = "eve/tools";
+	try {
+		return await import(specifier);
+	} catch {
+		return;
+	}
+}
+const isRecallResult = (value) => isRecord(value) && Array.isArray(value["messages"]) && value["messages"].every((message) => isRecord(message) && typeof message["content"] === "string");
+/**
+* An eve memory provider over the memory and knowledge blocks. Every read
+* and write is partitioned by the scope key and the signed-in user; recall
+* stores its answer under the operation id, so a replayed recall returns the
+* same messages.
+*/
+function supabaseMemory(options) {
+	const { memory } = options;
+	const k = options.k ?? 5;
+	const organizationOf = options.organizationOf ?? ((auth) => {
+		const tenant = auth.attributes["tenantId"];
+		return typeof tenant === "string" ? tenant : void 0;
+	});
+	const target = async (ctx) => {
+		const auth = ctx.session.auth.current;
+		if (auth?.principalType !== "user") return void 0;
+		const organizationId = organizationOf(auth);
+		if (organizationId === void 0) return void 0;
+		return {
+			organizationId,
+			namespace: {
+				scope: "agent",
+				agentId: await stableUuid(`eve-memory:${ctx.memory.scope.key}`),
+				ownerId: auth.principalId
+			}
+		};
+	};
+	const recall = async (ctx, where) => {
+		const query = (ctx.turn?.input ?? []).filter((message) => message.role === "user").map(textOfMessage).join("\n").trim();
+		const [core, archival, documents] = await Promise.all([
+			memory.render(where.organizationId, where.namespace).orThrow(),
+			query.length === 0 ? Promise.resolve([]) : memory.archival.search(where.organizationId, query, where.namespace, { k }).orThrow(),
+			query.length === 0 || !options.knowledge ? Promise.resolve([]) : options.knowledge.search(where.organizationId, query, {
+				k,
+				scopes: options.knowledgeScopes ?? [{ scope: "organization" }]
+			}).orThrow()
+		]);
+		const messages = [];
+		if (core.trim().length > 0) messages.push({
+			id: "core",
+			content: core
+		});
+		for (const hit of archival) messages.push({
+			id: `memory:${hit.id}`,
+			content: hit.content
+		});
+		for (const hit of documents) messages.push({
+			id: `knowledge:${hit.documentId}:${String(hit.index)}`,
+			content: hit.title ? `${hit.title}\n${hit.content}` : hit.content
+		});
+		return { messages };
+	};
+	let tools;
+	const loaded = () => tools ??= (options.load ?? loadTools)().then((value) => {
+		if (!isToolsModule(value)) {
+			tools = void 0;
+			throw new TypeError("supabaseMemory needs the eve package: pnpm add eve");
+		}
+		return value;
+	});
+	const provider = {
+		recall: { "turn.started": async (ctx) => {
+			const where = await target(ctx);
+			if (!where) return null;
+			const path = `recall/${ctx.operationId}`;
+			const scopeKey = ctx.memory.scope.key;
+			const stored = await memory.documents.read(OPS_SCOPE, `${scopeKey}/${path}`).orThrow();
+			if (stored) {
+				const value = JSON.parse(stored.content);
+				return isRecallResult(value) ? value : null;
+			}
+			const result = await recall(ctx, where);
+			const written = await memory.documents.write(OPS_SCOPE, `${scopeKey}/${path}`, JSON.stringify(result), {
+				expectedVersion: null,
+				expiresIn: OP_TTL_SECONDS
+			});
+			if (written.ok) return result;
+			if (!isConflict(written.error)) throw new DbException(written.error);
+			const raced = await memory.documents.read(OPS_SCOPE, `${scopeKey}/${path}`).orThrow();
+			const value = raced ? JSON.parse(raced.content) : null;
+			return isRecallResult(value) ? value : null;
+		} },
+		...options.extract ? { capture: { "turn.completed": async (ctx) => {
+			const extract = options.extract;
+			const where = await target(ctx);
+			if (!extract || !where) return;
+			const marker = `${ctx.memory.scope.key}/capture/${ctx.operationId}`;
+			if (await memory.documents.read(OPS_SCOPE, marker).orThrow()) return;
+			const facts = await extract(ctx.messages ?? [], ctx);
+			if (facts.length > 0) await memory.saveExtracted(where.organizationId, facts, where.namespace, { sourceMessageId: ctx.operationId }).orThrow();
+			const written = await memory.documents.write(OPS_SCOPE, marker, "{}", {
+				expectedVersion: null,
+				expiresIn: OP_TTL_SECONDS
+			});
+			if (!written.ok && !isConflict(written.error)) throw new DbException(written.error);
+		} } } : {}
+	};
+	if (options.tools === false) return provider;
+	return {
+		...provider,
+		tools: async (ctx) => {
+			const where = await target(ctx);
+			if (!where) return null;
+			const { defineTool } = await loaded();
+			return {
+				remember: defineTool({
+					description: "Save a fact about the user to recall in later conversations.",
+					inputSchema: {
+						type: "object",
+						properties: { fact: {
+							type: "string",
+							minLength: 1,
+							maxLength: 2e3
+						} },
+						required: ["fact"],
+						additionalProperties: false
+					},
+					execute: async (input) => {
+						const fact = typeof input["fact"] === "string" ? input["fact"] : "";
+						return { id: (await memory.archival.save(where.organizationId, fact, where.namespace).orThrow()).id };
+					}
+				}),
+				forget: defineTool({
+					description: "Delete a remembered fact by the id shown with it.",
+					inputSchema: {
+						type: "object",
+						properties: { id: {
+							type: "string",
+							minLength: 1
+						} },
+						required: ["id"],
+						additionalProperties: false
+					},
+					execute: async (input) => {
+						const id = typeof input["id"] === "string" ? input["id"].replace(/^memory:/, "") : "";
+						if (!(await memory.archival.list(where.organizationId, where.namespace, { limit: 1e3 }).orThrow()).some((record) => record.id === id)) return { deleted: false };
+						return { deleted: await memory.archival.forget(id).orThrow() };
+					}
+				})
+			};
+		}
+	};
+}
+//#endregion
+export { ConnectionAuthorizationFailedError, ConnectionAuthorizationRequiredError, EveAuthRejection, MemoryDocumentConflictError, chatIdOf, credentialAuth, persistSessions, principalOf, routeInbox, stableUuid, supabaseAuth, supabaseDocumentBackend, supabaseMemory };

package/dist/eve-gT2Fpjut.d.ts

@@ -0,0 +1,151 @@
+import { r as Knowledge, u as KnowledgeSearchOptions } from "./knowledge-BXBbT0Tr.js";
+import { t as Memory } from "./types-DGs5L0VN.js";
+//#region src/eve/types.d.ts
+/**
+ * eve's `SessionAuthContext`, typed structurally so this entry never imports
+ * eve. `attributes` carries `tenantId`, `roles` and `isAnonymous`.
+ */
+interface EveSessionAuth {
+  readonly authenticator: string;
+  readonly principalType: string;
+  readonly principalId: string;
+  readonly issuer?: string;
+  readonly subject?: string;
+  readonly attributes: Readonly<Record<string, string | readonly string[]>>;
+}
+/** The session part of the context eve passes to hooks, memory and connections. */
+interface EveSessionContext {
+  readonly session: {
+    readonly id: string;
+    readonly auth: {
+      readonly current: EveSessionAuth | null;
+      readonly initiator?: EveSessionAuth | null;
+    };
+  };
+}
+//#endregion
+//#region src/eve/eve.d.ts
+/** eve's `MemoryDocumentConflictError`, matched by name. */
+declare class MemoryDocumentConflictError extends Error {
+  override readonly name = "MemoryDocumentConflictError";
+  readonly key: string;
+  constructor(key: string);
+}
+/** The backend eve's `fileMemory({ backend })` reads and writes. */
+interface EveDocumentBackend {
+  /** The document backend contract version. Omitted means 1. */
+  readonly apiVersion?: 1;
+  read(input: {
+    readonly key: string;
+    readonly signal?: AbortSignal;
+  }): Promise<{
+    readonly content: string;
+    readonly version: string;
+  } | null>;
+  write(input: {
+    readonly key: string;
+    readonly content: string;
+    readonly expectedVersion: string | null;
+    readonly signal?: AbortSignal;
+  }): Promise<{
+    readonly content: string;
+    readonly version: string;
+  }>;
+}
+interface SupabaseDocumentBackendOptions {
+  /** `createMemory` on a service transport. */
+  readonly memory: Memory;
+  /** Prefixes every key, so apps can share the table. Defaults to `eve`. */
+  readonly scope?: string;
+}
+/**
+ * A document backend for eve's `fileMemory()` over the memory module's
+ * `memory_documents` table. A write with a stale version throws
+ * `MemoryDocumentConflictError`, so eve retries with the current document.
+ */
+declare function supabaseDocumentBackend(options: SupabaseDocumentBackendOptions): EveDocumentBackend;
+interface EveMessagePart {
+  readonly type: string;
+  readonly text?: unknown;
+}
+interface EveModelMessage {
+  readonly role: string;
+  readonly content: string | readonly EveMessagePart[];
+}
+/** The context eve passes to a memory provider's `tools`. */
+interface EveMemoryToolsContext extends EveSessionContext {
+  readonly memory: {
+    readonly scope: {
+      readonly key: string;
+    };
+    readonly slot?: string;
+  };
+}
+/** The context eve passes to a memory provider's recall and capture handlers. */
+interface EveMemoryContext extends EveMemoryToolsContext {
+  readonly operationId: string;
+  readonly messages?: readonly EveModelMessage[];
+  readonly turn?: {
+    readonly id: string;
+    readonly input: readonly EveModelMessage[];
+    readonly sequence?: number;
+  } | null;
+  readonly abortSignal?: AbortSignal;
+}
+interface EveRecallMessage {
+  readonly id?: string;
+  readonly content: string;
+}
+interface EveRecallResult {
+  readonly messages: readonly EveRecallMessage[];
+}
+/** A provider for eve's `defineMemory({ provider })`; pass it through `defineMemoryProvider`. */
+interface EveMemoryProvider {
+  readonly recall: {
+    "turn.started"(ctx: EveMemoryContext): Promise<EveRecallResult | null>;
+  };
+  readonly capture?: {
+    "turn.completed"?(ctx: EveMemoryContext): Promise<void>;
+  };
+  tools?(ctx: EveMemoryToolsContext): Promise<Readonly<Record<string, EveMemoryTool>> | null>;
+}
+/** A tool from eve's `defineTool`, as a memory provider returns it. */
+interface EveMemoryTool {
+  readonly description: string;
+  readonly inputSchema: unknown;
+  execute(input: never, context: never): unknown;
+}
+interface SupabaseMemoryOptions {
+  /** `createMemory` on a service transport: eve calls the provider outside a user request. */
+  readonly memory: Memory;
+  /** Tenant documents to search alongside the memories. */
+  readonly knowledge?: Knowledge;
+  /**
+   * The knowledge scopes to search. Defaults to the tenant's shared
+   * documents: the provider searches as the service role, so a wider scope
+   * can show one user's documents to another.
+   */
+  readonly knowledgeScopes?: KnowledgeSearchOptions["scopes"];
+  /** Archival memories and knowledge chunks to recall per turn. Defaults to 5. */
+  readonly k?: number;
+  /** The tenant of a principal. Defaults to `attributes.tenantId`. */
+  readonly organizationOf?: (auth: EveSessionAuth) => string | undefined;
+  /**
+   * Facts to keep from a finished turn (an LLM call of yours). Without it
+   * the provider stores only what the model saves with its `remember` tool.
+   */
+  readonly extract?: (messages: readonly EveModelMessage[], ctx: EveMemoryContext) => Promise<readonly string[]>;
+  /** Adds the `remember` and `forget` tools. Defaults to true. */
+  readonly tools?: boolean;
+  /** Returns `eve/tools`; defaults to importing it on first use. */
+  readonly load?: () => Promise<unknown>;
+}
+/**
+ * An eve memory provider over the memory and knowledge blocks. Every read
+ * and write is partitioned by the scope key and the signed-in user; recall
+ * stores its answer under the operation id, so a replayed recall returns the
+ * same messages.
+ */
+declare function supabaseMemory(options: SupabaseMemoryOptions): EveMemoryProvider;
+//#endregion
+export { EveMemoryToolsContext as a, MemoryDocumentConflictError as c, supabaseDocumentBackend as d, supabaseMemory as f, EveMemoryTool as i, SupabaseDocumentBackendOptions as l, EveSessionContext as m, EveMemoryContext as n, EveRecallMessage as o, EveSessionAuth as p, EveMemoryProvider as r, EveRecallResult as s, EveDocumentBackend as t, SupabaseMemoryOptions as u };

package/dist/events/index.d.ts

@@ -1,3 +1,4 @@
-import { C as kitEventAttributes, S as WebhookEventData, _ as KitEventType, b as OrgEventData, d as InvitationEventData, f as KIT_ATTRIBUTES, g as KitEventPattern, h as KitEventMeta, m as KitEventMap, p as KitEvent, v as KitEventsMatching, w as onKitEvent, x as SupportEventData, y as NotificationEventData } from "../events-aIO7vsIk.js";
-import { _ as toHttp, a as ForwardOptions, c as ROW_EVENT_TYPES, d as forwardMutations, f as fromHttp, g as toCloudEvents, h as kitCloudEvent, i as ForwardKitOptions, l as RowEventData, m as isCloudEvent, n as CloudEventOptions, o as HttpMode, p as httpSink, r as EventSink, s as HttpSinkOptions, t as CloudEvent, u as forwardKitEvents } from "../index-DOESKG27.js";
-export { CloudEvent, CloudEventOptions, EventSink, ForwardKitOptions, ForwardOptions, HttpMode, HttpSinkOptions, type InvitationEventData, KIT_ATTRIBUTES, type KitEvent, type KitEventMap, type KitEventMeta, type KitEventPattern, type KitEventType, type KitEventsMatching, type NotificationEventData, type OrgEventData, ROW_EVENT_TYPES, RowEventData, type SupportEventData, type WebhookEventData, forwardKitEvents, forwardMutations, fromHttp, httpSink, isCloudEvent, kitCloudEvent, kitEventAttributes, onKitEvent, toCloudEvents, toHttp };
+import { A as CredentialEventData, B as OrganizationEventData, C as BlockEventMap, D as BlockEventsMatching, E as BlockEventType, F as InvitationEventData, G as StorageObjectEventData, H as ScimEventData, I as InviteCodeEventData, J as WebhookEventData, K as SupportEventData, L as NotificationEventData, M as FlagEventData, N as InboxEventData, O as CommentEventData, P as IncomingWebhookEventData, Q as onBlockEvent, R as OrganizationDeletionEventData, S as BlockEvent, T as BlockEventPattern, U as SettingEventData, V as PushDeviceEventData, W as SsoProviderEventData, X as WorkflowRunEventData, Y as WorkflowEventData, Z as blockEventAttributes, _ as AttachmentEventData, b as BLOCK_EVENT_RENAMES, d as AgentEventData, f as AiChatEventData, g as ApiKeyEventData, h as AnnouncementEventData, j as DataExportEventData, k as ConnectorEventData, m as AiToolEventData, p as AiProviderKeyEventData, q as WaitlistEventData, v as AuditRevealEventData, w as BlockEventMeta, x as BillingEventData, y as BLOCK_ATTRIBUTES, z as OrganizationDomainEventData } from "../events-DWDhx77e.js";
+import { a as blockCloudEvent, i as ForwardBlockOptions, n as CloudEventOptions, o as forwardBlockEvents, r as EventSink, t as CloudEvent } from "../cloud-event-C1JCc1bH.js";
+import { a as RowEventData, c as httpSink, d as toHttp, i as ROW_EVENT_TYPES, l as isCloudEvent, n as HttpMode, o as forwardMutations, r as HttpSinkOptions, s as fromHttp, t as ForwardOptions, u as toCloudEvents } from "../index-ClmjK_o-.js";
+export { type AgentEventData, type AiChatEventData, type AiProviderKeyEventData, type AiToolEventData, type AnnouncementEventData, type ApiKeyEventData, type AttachmentEventData, type AuditRevealEventData, BLOCK_ATTRIBUTES, BLOCK_EVENT_RENAMES, type BillingEventData, type BlockEvent, type BlockEventMap, type BlockEventMeta, type BlockEventPattern, type BlockEventType, type BlockEventsMatching, type CloudEvent, type CloudEventOptions, type CommentEventData, type ConnectorEventData, type CredentialEventData, type DataExportEventData, type EventSink, type FlagEventData, type ForwardBlockOptions, ForwardOptions, HttpMode, HttpSinkOptions, type InboxEventData, type IncomingWebhookEventData, type InvitationEventData, type InviteCodeEventData, type NotificationEventData, type OrganizationDeletionEventData, type OrganizationDomainEventData, type OrganizationEventData, type PushDeviceEventData, ROW_EVENT_TYPES, RowEventData, type ScimEventData, type SettingEventData, type SsoProviderEventData, type StorageObjectEventData, type SupportEventData, type WaitlistEventData, type WebhookEventData, type WorkflowEventData, type WorkflowRunEventData, blockCloudEvent, blockEventAttributes, forwardBlockEvents, forwardMutations, fromHttp, httpSink, isCloudEvent, onBlockEvent, toCloudEvents, toHttp };