@astralbeam/sdk 0.0.6 → 0.2.0

package/dist/react.d.ts

@@ -1,12 +1,51 @@
+import { C as AstralBeamChatState, S as AstralBeamChatCoreOptions, x as AstralBeamChatCore } from "./index-DtIS-V14.js";
 import { ReactNode } from "react";
-import { AstralBeamChatAttachmentOptions, AstralBeamChatColorScheme, AstralBeamChatTheme, ToolDefinition, WidgetDefinition as WidgetDefinition$1 } from "@astralbeam/sdk/client";
+import { AstralBeamChatAttachmentOptions, AstralBeamChatColorScheme, AstralBeamChatTheme, InferParameters, JsonSchemaObject, ParametersSchema, ToolDefinition, WidgetDefinition as WidgetDefinition$1, defineTool } from "@astralbeam/sdk/client";
 
-//#region src/react.d.ts
+//#region src/react/index.d.ts
 interface WidgetDefinition extends Omit<WidgetDefinition$1, "render"> {
   /** Draws the widget with the agent-chosen props, in the host's own React tree. */
   render: (props: Record<string, unknown>) => ReactNode;
 }
+interface TypedReactWidgetDefinition<S extends ParametersSchema = JsonSchemaObject> {
+  description: string;
+  parameters?: S;
+  render: (props: InferParameters<S>) => ReactNode;
+}
+/** Declares a host widget; a Standard Schema `parameters` types (and validates) `render`'s props. */
+declare function defineWidget<const S extends ParametersSchema = JsonSchemaObject>(widget: TypedReactWidgetDefinition<S>): WidgetDefinition;
+/** Everything `useAstralBeamChat` returns: the live state plus the session's actions. */
+interface UseAstralBeamChatResult extends AstralBeamChatState {
+  sendMessage: AstralBeamChatCore["sendMessage"];
+  addToolResult: AstralBeamChatCore["addToolResult"];
+  stop: () => void;
+  reload: () => Promise<void>;
+  reset: () => void;
+  /** The underlying headless session, for anything the flattened surface does not carry. */
+  core: AstralBeamChatCore;
+}
+/**
+ * The headless chat session as a React hook: authentication, transport, tools, and transcript
+ * state with no markup, for hosts that own their whole chat UI. Transport identity (endpoints,
+ * agent) and the declared tool/widget set are fixed for the component's lifetime — remount with
+ * a React `key` to change them — but `execute` and `onRenderWidget` read the latest render, so
+ * ordinary closures over props and state stay live. Whether a widget renderer exists at all is
+ * part of the declared surface and is read at mount.
+ */
+declare function useAstralBeamChat(options: AstralBeamChatCoreOptions): UseAstralBeamChatResult;
+/** Imperative surface of a mounted `<AstralBeamChat>`, for hosts that draw their own controls. */
+interface AstralBeamChatRef {
+  /** Clears the conversation: transcript, drafts, attachments, and live widget renders. */
+  reset: () => void;
+  /** Stops the in-flight generation, if any; the transcript keeps what already streamed. */
+  stop: () => void;
+}
 interface AstralBeamChatProps {
+  /**
+   * Public ID of the organization-owned agent, fixed for this mounted chat. Omit it to use the
+   * organization's default agent, which the dashboard's agents page selects.
+   */
+  agentId?: string;
   /** Name shown in the widget's header; prop changes apply immediately. Default `"AstralBeam"`. */
   title?: string;
   /**
@@ -14,16 +53,20 @@ interface AstralBeamChatProps {
    * the transcript the full height. Prop changes apply immediately. Default `true`.
    */
   showHeader?: boolean;
+  /** Replaces the header's content with the host's own React content; `showHeader` still applies. */
+  header?: ReactNode;
+  /** Replaces the empty-transcript state with the host's own React content. */
+  empty?: ReactNode;
+  /** Extra host controls at the end of the composer's button row, next to send. */
+  composerActions?: ReactNode;
   /** Headline shown on the empty transcript; prop changes apply immediately. Default `"Ask the assistant"`. */
   emptyTitle?: string;
   /** Subtitle under the empty transcript's headline; prop changes apply immediately. */
   emptyDescription?: string;
-  /** URL of the AstralBeam chat endpoint the widget streams from. Default `"/api/chat"`. */
-  chatEndpoint?: string;
-  /** Application endpoint that mints a short-lived chat JWT; omit for guest chat. */
-  authEndpoint?: string;
-  /** Host-specific instructions the endpoint appends to the agent's system prompt. */
-  systemPrompt?: string;
+  /** Base URL of the AstralBeam API; the widget calls `/chat` under it. Default the hosted cloud. */
+  apiUrl?: string;
+  /** Application endpoint that mints a short-lived chat JWT. Default `"/api/astralbeam/token"`. */
+  authTokenUrl?: string;
   /** Host-defined tools the agent can call, executed in the host's React app, keyed by name. */
   tools?: Record<string, ToolDefinition>;
   /** Host-defined widgets the agent can render inline in the conversation, keyed by identifier. */
@@ -34,26 +77,14 @@ interface AstralBeamChatProps {
   theme?: AstralBeamChatTheme | undefined;
   /** File attachments in the composer, on by default; `false` turns them off. */
   attachments?: boolean | AstralBeamChatAttachmentOptions;
+  /** Shows the collected sandbox panel (files with downloads, command log) above the composer. Default `false`. */
+  sandboxPanel?: boolean;
   /**
    * Logs every SDK action to the browser console with UTC timestamps and full payloads,
    * and asks the endpoint to log its side of the run too; prop changes apply immediately.
    */
   debug?: boolean;
 }
-declare function AstralBeamChat({
-  title,
-  showHeader,
-  emptyTitle,
-  emptyDescription,
-  chatEndpoint,
-  authEndpoint,
-  systemPrompt,
-  tools,
-  widgets,
-  colorScheme,
-  theme,
-  attachments,
-  debug
-}: AstralBeamChatProps): import("react").JSX.Element;
+declare const AstralBeamChat: import("react").ForwardRefExoticComponent<AstralBeamChatProps & import("react").RefAttributes<AstralBeamChatRef>>;
 //#endregion
-export { AstralBeamChat, type AstralBeamChatAttachmentOptions, type AstralBeamChatColorScheme, AstralBeamChatProps, type AstralBeamChatTheme, type ToolDefinition, WidgetDefinition };
+export { AstralBeamChat, type AstralBeamChatAttachmentOptions, type AstralBeamChatColorScheme, type AstralBeamChatCore, type AstralBeamChatCoreOptions, AstralBeamChatProps, AstralBeamChatRef, type AstralBeamChatState, type AstralBeamChatTheme, type InferParameters, type ParametersSchema, type ToolDefinition, TypedReactWidgetDefinition, UseAstralBeamChatResult, WidgetDefinition, defineTool, defineWidget, useAstralBeamChat };

package/dist/react.js

@@ -1,16 +1,55 @@
-import { useEffect, useMemo, useRef, useState } from "react";
+import { C as DEFAULT_COLOR_SCHEME, r as createAstralBeamChat } from "./core-BVlttAaO.js";
+import { forwardRef, useEffect, useImperativeHandle, useMemo, useRef, useState, useSyncExternalStore } from "react";
 import { createPortal } from "react-dom";
-import { mountAstralBeamChat } from "@astralbeam/sdk/client";
-import { jsx } from "react/jsx-runtime";
-//#region src/lib/client-constants.ts
-/** Color scheme used when the mount options and the React prop give none. */
-const DEFAULT_COLOR_SCHEME = "system";
-//#endregion
-//#region src/react.tsx
-function AstralBeamChat({ title, showHeader, emptyTitle, emptyDescription, chatEndpoint, authEndpoint, systemPrompt, tools, widgets = {}, colorScheme = DEFAULT_COLOR_SCHEME, theme, attachments, debug }) {
+import { defineTool, mountAstralBeamChat } from "@astralbeam/sdk/client";
+import { jsxs } from "react/jsx-runtime";
+//#region src/react/index.tsx
+/** Declares a host widget; a Standard Schema `parameters` types (and validates) `render`'s props. */
+function defineWidget(widget) {
+	return widget;
+}
+/**
+* The headless chat session as a React hook: authentication, transport, tools, and transcript
+* state with no markup, for hosts that own their whole chat UI. Transport identity (endpoints,
+* agent) and the declared tool/widget set are fixed for the component's lifetime — remount with
+* a React `key` to change them — but `execute` and `onRenderWidget` read the latest render, so
+* ordinary closures over props and state stay live. Whether a widget renderer exists at all is
+* part of the declared surface and is read at mount.
+*/
+function useAstralBeamChat(options) {
+	const optionsRef = useRef(options);
+	optionsRef.current = options;
+	const [core] = useState(() => createAstralBeamChat({
+		...options,
+		tools: Object.fromEntries(Object.entries(options.tools ?? {}).map(([name, definition]) => [name, {
+			...definition,
+			execute: (input) => {
+				const current = optionsRef.current.tools?.[name];
+				if (!current) throw new Error(`Tool "${name}" is no longer registered`);
+				return current.execute(input);
+			}
+		}])),
+		onRenderWidget: options.onRenderWidget === void 0 ? void 0 : (request) => optionsRef.current.onRenderWidget?.(request)
+	}));
+	useEffect(() => () => core.dispose(), [core]);
+	return {
+		...useSyncExternalStore(core.subscribe, core.getState, core.getState),
+		sendMessage: core.sendMessage,
+		addToolResult: core.addToolResult,
+		stop: core.stop,
+		reload: core.reload,
+		reset: core.reset,
+		core
+	};
+}
+const AstralBeamChat = forwardRef(function AstralBeamChat({ agentId, title, showHeader, header, empty, composerActions, emptyTitle, emptyDescription, apiUrl, authTokenUrl, tools, widgets = {}, colorScheme = DEFAULT_COLOR_SCHEME, theme, attachments, sandboxPanel, debug }, ref) {
 	const targetRef = useRef(null);
 	const handleRef = useRef(null);
 	const [activeRenders, setActiveRenders] = useState(/* @__PURE__ */ new Map());
+	useImperativeHandle(ref, () => ({
+		reset: () => handleRef.current?.reset(),
+		stop: () => handleRef.current?.stop()
+	}), []);
 	const toolsRef = useRef(tools);
 	useEffect(() => {
 		toolsRef.current = tools;
@@ -42,30 +81,57 @@ function AstralBeamChat({ title, showHeader, emptyTitle, emptyDescription, chatE
 			};
 		}
 	}])), [widgets]);
+	const [chromeContainers, setChromeContainers] = useState(/* @__PURE__ */ new Map());
+	const hasHeader = header !== void 0;
+	const hasEmpty = empty !== void 0;
+	const hasComposerActions = composerActions !== void 0;
+	const chromeSlots = useMemo(() => {
+		const build = (name) => (container) => {
+			setChromeContainers((previous) => new Map(previous).set(name, container));
+			return () => {
+				setChromeContainers((previous) => {
+					const next = new Map(previous);
+					next.delete(name);
+					return next;
+				});
+			};
+		};
+		return {
+			...hasHeader ? { header: build("header") } : {},
+			...hasEmpty ? { empty: build("empty") } : {},
+			...hasComposerActions ? { composerActions: build("composerActions") } : {}
+		};
+	}, [
+		hasHeader,
+		hasEmpty,
+		hasComposerActions
+	]);
 	const live = useMemo(() => ({
 		title,
 		showHeader,
 		emptyTitle,
 		emptyDescription,
-		systemPrompt,
 		colorScheme,
 		theme,
 		attachments,
+		sandboxPanel,
 		debug,
 		tools: hostTools,
-		widgets: hostWidgets
+		widgets: hostWidgets,
+		slots: chromeSlots
 	}), [
 		title,
 		showHeader,
 		emptyTitle,
 		emptyDescription,
-		systemPrompt,
 		colorScheme,
 		theme,
 		attachments,
+		sandboxPanel,
 		debug,
 		hostTools,
-		hostWidgets
+		hostWidgets,
+		chromeSlots
 	]);
 	const liveRef = useRef(live);
 	liveRef.current = live;
@@ -73,8 +139,9 @@ function AstralBeamChat({ title, showHeader, emptyTitle, emptyDescription, chatE
 		if (!targetRef.current) return;
 		const handle = mountAstralBeamChat(targetRef.current, {
 			...liveRef.current,
-			chatEndpoint,
-			authEndpoint
+			agentId,
+			apiUrl,
+			authTokenUrl
 		});
 		handleRef.current = handle;
 		return () => {
@@ -85,14 +152,19 @@ function AstralBeamChat({ title, showHeader, emptyTitle, emptyDescription, chatE
 	useEffect(() => {
 		handleRef.current?.update(live);
 	}, [live]);
-	return /* @__PURE__ */ jsx("div", {
+	const chromeContent = {
+		header,
+		empty,
+		composerActions
+	};
+	return /* @__PURE__ */ jsxs("div", {
 		style: { height: "100%" },
 		ref: targetRef,
-		children: [...activeRenders].map(([key, { widget, container, props }]) => {
+		children: [[...activeRenders].map(([key, { widget, container, props }]) => {
 			const definition = widgets[widget];
 			return definition ? createPortal(definition.render(props), container, key) : null;
-		})
+		}), [...chromeContainers].map(([name, container]) => createPortal(chromeContent[name], container, `astralbeam-chrome-${name}`))]
 	});
-}
+});
 //#endregion
-export { AstralBeamChat };
+export { AstralBeamChat, defineTool, defineWidget, useAstralBeamChat };

package/dist/server.d.ts

@@ -1,33 +1,39 @@
-//#region src/server.d.ts
+//#region src/server/index.d.ts
 declare const ASTRALBEAM_CHAT_TOKEN_AUDIENCE = "astralbeam-chat";
-declare const ASTRALBEAM_CHAT_TOKEN_ISSUER = "astralbeam-global";
+declare const ASTRALBEAM_CHAT_TOKEN_ISSUER = "astralbeam-api-key";
 declare const ASTRALBEAM_CHAT_TOKEN_TYPE = "astralbeam-chat+jwt";
-declare const ASTRALBEAM_CHAT_TOKEN_KEY_ID = "global-v1";
+declare const ASTRALBEAM_CHAT_TOKEN_VERSION = 2;
 declare const ASTRALBEAM_CHAT_TOKEN_LIFETIME_SECONDS = 300;
 declare const ASTRALBEAM_CHAT_TOKEN_MAX_LIFETIME_SECONDS = 600;
-interface AstralBeamChatUser {
-  id: string;
-  name?: string | undefined;
-  email?: string | undefined;
-  avatarUrl?: string | undefined;
+interface TenantUser {
+  /** User of an Organization's Tenant who interacts with the embedded agent sidebar. */
+  readonly id: string;
 }
-interface AstralBeamChatTenant {
-  id: string;
-  name?: string | undefined;
-  logoUrl?: string | undefined;
+interface CreateAstralBeamChatTokenOptions<TTenantUser extends TenantUser = TenantUser> {
+  readonly apiKey: string;
+  readonly tenantUser: TTenantUser;
+  readonly expiresInSeconds?: number | undefined;
 }
-interface CreateAstralBeamChatTokenOptions {
-  secret: string | Uint8Array;
-  user: AstralBeamChatUser;
-  tenant: AstralBeamChatTenant;
-  expiresInSeconds?: number | undefined;
+interface CreateAstralBeamTokenRouteOptions<TTenantUser extends TenantUser = TenantUser> {
+  /** The full API key, or a thunk read per request; missing or empty answers 503. */
+  readonly apiKey: string | undefined | (() => string | undefined);
+  /**
+   * Authenticates the request against the application's own session and returns the tenant
+   * user minted into the token. Returning nothing, or throwing, answers 401.
+   */
+  readonly tenantUser: (request: Request) => TTenantUser | null | undefined | Promise<TTenantUser | null | undefined>;
+  readonly expiresInSeconds?: number | undefined;
 }
-/** Creates the short-lived bearer token returned by an application's auth endpoint. */
-declare function createAstralBeamChatToken({
-  secret,
-  user,
-  tenant,
+/**
+ * Builds the fetch-standard `POST` handler for an application's token endpoint, owning the
+ * method check, the unconfigured-key 503, the unauthenticated 401, and the `no-store` header.
+ */
+declare function createAstralBeamTokenRoute<TTenantUser extends TenantUser = TenantUser>(options: CreateAstralBeamTokenRouteOptions<TTenantUser>): (request: Request) => Promise<Response>;
+/** Creates the short-lived bearer token returned by an application's server auth endpoint. */
+declare function createAstralBeamChatToken<TTenantUser extends TenantUser = TenantUser>({
+  apiKey,
+  tenantUser,
   expiresInSeconds
-}: CreateAstralBeamChatTokenOptions): Promise<string>;
+}: CreateAstralBeamChatTokenOptions<TTenantUser>): Promise<string>;
 //#endregion
-export { ASTRALBEAM_CHAT_TOKEN_AUDIENCE, ASTRALBEAM_CHAT_TOKEN_ISSUER, ASTRALBEAM_CHAT_TOKEN_KEY_ID, ASTRALBEAM_CHAT_TOKEN_LIFETIME_SECONDS, ASTRALBEAM_CHAT_TOKEN_MAX_LIFETIME_SECONDS, ASTRALBEAM_CHAT_TOKEN_TYPE, AstralBeamChatTenant, AstralBeamChatUser, CreateAstralBeamChatTokenOptions, createAstralBeamChatToken };
+export { ASTRALBEAM_CHAT_TOKEN_AUDIENCE, ASTRALBEAM_CHAT_TOKEN_ISSUER, ASTRALBEAM_CHAT_TOKEN_LIFETIME_SECONDS, ASTRALBEAM_CHAT_TOKEN_MAX_LIFETIME_SECONDS, ASTRALBEAM_CHAT_TOKEN_TYPE, ASTRALBEAM_CHAT_TOKEN_VERSION, CreateAstralBeamChatTokenOptions, CreateAstralBeamTokenRouteOptions, TenantUser, createAstralBeamChatToken, createAstralBeamTokenRoute };

package/dist/server.js

@@ -1,3 +1,4 @@
+import * as Schema from "effect/Schema";
 //#region node_modules/.deno/jose@6.2.9/node_modules/jose/dist/webapi/lib/buffer_utils.js
 const encoder = new TextEncoder();
 const decoder = new TextDecoder();
@@ -636,59 +637,109 @@ var SignJWT = class {
 	}
 };
 //#endregion
-//#region src/server.ts
+//#region src/server/index.ts
 const ASTRALBEAM_CHAT_TOKEN_AUDIENCE = "astralbeam-chat";
-const ASTRALBEAM_CHAT_TOKEN_ISSUER = "astralbeam-global";
+const ASTRALBEAM_CHAT_TOKEN_ISSUER = "astralbeam-api-key";
 const ASTRALBEAM_CHAT_TOKEN_TYPE = "astralbeam-chat+jwt";
-const ASTRALBEAM_CHAT_TOKEN_KEY_ID = "global-v1";
+const ASTRALBEAM_CHAT_TOKEN_VERSION = 2;
 const ASTRALBEAM_CHAT_TOKEN_LIFETIME_SECONDS = 300;
 const ASTRALBEAM_CHAT_TOKEN_MAX_LIFETIME_SECONDS = 600;
+const API_KEY_ID_PATTERN = /^key_[0-9a-z]{1,63}_([0-9a-z]{1,63})$/;
+const API_KEY_SECRET_PATTERN = /^abo_[A-Za-z]{64}$/;
+const CHAT_TOKEN_MAX_BYTES = 16384;
+const TENANT_USER_MAX_BYTES = 8192;
+const TENANT_USER_MAX_DEPTH = 10;
 const textEncoder = new TextEncoder();
-function signingKey(secret) {
-	const key = typeof secret === "string" ? textEncoder.encode(secret) : secret;
-	if (key.byteLength < 32) throw new Error("AstralBeam chat signing secrets need at least 32 bytes");
-	return key;
-}
-function requiredText(value, label, maxLength) {
-	const text = value.trim();
-	if (!text || text.length > maxLength) throw new Error(`${label} must be 1-${maxLength} characters`);
-	return text;
+const TenantUserJsonSchema = Schema.Json.annotate({ message: "tenantUser must contain only JSON values" });
+const TenantUserSchema = Schema.StructWithRest(Schema.Struct({ id: Schema.String.pipe(Schema.check(Schema.makeFilter((value) => value.length >= 1 && value.length <= 255, { message: "tenantUser.id must be a 1-255 character string" }))) }), [Schema.Record(Schema.String, TenantUserJsonSchema)]).pipe(Schema.check(Schema.makeFilter((value) => !exceedsJsonDepth(value, TENANT_USER_MAX_DEPTH), { message: `tenantUser must not exceed ${TENANT_USER_MAX_DEPTH} levels` })), Schema.check(Schema.makeFilter((value) => textEncoder.encode(JSON.stringify(value)).byteLength <= TENANT_USER_MAX_BYTES, { message: `tenantUser must not exceed ${TENANT_USER_MAX_BYTES} bytes` })));
+const decodeTenantUser = Schema.decodeUnknownSync(TenantUserSchema, {
+	errors: "all",
+	onExcessProperty: "error",
+	reportInput: false
+});
+function parseApiKey(apiKey) {
+	const separator = apiKey.lastIndexOf("_abo_");
+	const id = apiKey.slice(0, separator);
+	const secret = apiKey.slice(separator + 1);
+	if (!API_KEY_ID_PATTERN.test(id) || !API_KEY_SECRET_PATTERN.test(secret)) throw new Error("apiKey must match key_<organization>_<key>_abo_<secret>");
+	return {
+		id,
+		secret
+	};
 }
-function optionalText(value, label, maxLength) {
-	if (value === void 0) return void 0;
-	return requiredText(value, label, maxLength);
+function exceedsJsonDepth(value, maximumDepth) {
+	const stack = [{
+		value,
+		depth: 1
+	}];
+	while (stack.length > 0) {
+		const current = stack.pop();
+		if (current.depth > maximumDepth) return true;
+		if (typeof current.value !== "object" || current.value === null) continue;
+		const children = Array.isArray(current.value) ? current.value : Object.values(current.value);
+		for (const child of children) stack.push({
+			value: child,
+			depth: current.depth + 1
+		});
+	}
+	return false;
+}
+function validatedTenantUser(value) {
+	return JSON.parse(JSON.stringify(decodeTenantUser(value)));
+}
+async function signingKey(secret) {
+	const digest = await crypto.subtle.digest("SHA-256", textEncoder.encode(secret));
+	return textEncoder.encode(encode(new Uint8Array(digest)));
+}
+function tokenRouteResponse(body, status) {
+	return Response.json(body, {
+		status,
+		headers: { "cache-control": "no-store" }
+	});
 }
-function optionalUrl(value, label) {
-	const text = optionalText(value, label, 2048);
-	if (text === void 0) return void 0;
-	const url = new URL(text);
-	if (url.protocol !== "https:" && url.protocol !== "http:") throw new Error(`${label} must use http or https`);
-	return url.href;
+/**
+* Builds the fetch-standard `POST` handler for an application's token endpoint, owning the
+* method check, the unconfigured-key 503, the unauthenticated 401, and the `no-store` header.
+*/
+function createAstralBeamTokenRoute(options) {
+	return async (request) => {
+		if (request.method !== "POST") return tokenRouteResponse({ error: "Use POST" }, 405);
+		const apiKey = typeof options.apiKey === "function" ? options.apiKey() : options.apiKey;
+		if (!apiKey) return tokenRouteResponse({ error: "The AstralBeam API key is not configured" }, 503);
+		let tenantUser;
+		try {
+			tenantUser = await options.tenantUser(request);
+		} catch {
+			tenantUser = void 0;
+		}
+		if (!tenantUser) return tokenRouteResponse({ error: "The session could not be verified" }, 401);
+		try {
+			return tokenRouteResponse({ token: await createAstralBeamChatToken({
+				apiKey,
+				tenantUser,
+				...options.expiresInSeconds === void 0 ? {} : { expiresInSeconds: options.expiresInSeconds }
+			}) }, 200);
+		} catch {
+			return tokenRouteResponse({ error: "The chat token could not be created" }, 500);
+		}
+	};
 }
-/** Creates the short-lived bearer token returned by an application's auth endpoint. */
-async function createAstralBeamChatToken({ secret, user, tenant, expiresInSeconds = 300 }) {
+/** Creates the short-lived bearer token returned by an application's server auth endpoint. */
+async function createAstralBeamChatToken({ apiKey, tenantUser, expiresInSeconds = 300 }) {
 	if (!Number.isInteger(expiresInSeconds) || expiresInSeconds < 60 || expiresInSeconds > 600) throw new Error("AstralBeam chat tokens must live for 60-600 seconds");
-	const userId = requiredText(user.id, "user.id", 255);
-	const tenantId = requiredText(tenant.id, "tenant.id", 255);
+	const { id: apiKeyId, secret } = parseApiKey(apiKey);
+	const identity = validatedTenantUser(tenantUser);
 	const now = Math.floor(Date.now() / 1e3);
-	return await new SignJWT({
-		ver: 1,
-		user: {
-			id: userId,
-			name: optionalText(user.name, "user.name", 200),
-			email: optionalText(user.email, "user.email", 320),
-			avatarUrl: optionalUrl(user.avatarUrl, "user.avatarUrl")
-		},
-		tenant: {
-			id: tenantId,
-			name: optionalText(tenant.name, "tenant.name", 200),
-			logoUrl: optionalUrl(tenant.logoUrl, "tenant.logoUrl")
-		}
+	const token = await new SignJWT({
+		ver: 2,
+		tenantUser: identity
 	}).setProtectedHeader({
 		alg: "HS256",
 		typ: ASTRALBEAM_CHAT_TOKEN_TYPE,
-		kid: ASTRALBEAM_CHAT_TOKEN_KEY_ID
-	}).setIssuer(ASTRALBEAM_CHAT_TOKEN_ISSUER).setAudience(ASTRALBEAM_CHAT_TOKEN_AUDIENCE).setSubject(userId).setIssuedAt(now).setExpirationTime(now + expiresInSeconds).sign(signingKey(secret));
+		kid: apiKeyId
+	}).setIssuer(ASTRALBEAM_CHAT_TOKEN_ISSUER).setAudience(ASTRALBEAM_CHAT_TOKEN_AUDIENCE).setSubject(tenantUser.id).setIssuedAt(now).setExpirationTime(now + expiresInSeconds).sign(await signingKey(secret));
+	if (textEncoder.encode(token).byteLength > CHAT_TOKEN_MAX_BYTES) throw new Error(`AstralBeam chat tokens must not exceed ${CHAT_TOKEN_MAX_BYTES} bytes`);
+	return token;
 }
 //#endregion
-export { ASTRALBEAM_CHAT_TOKEN_AUDIENCE, ASTRALBEAM_CHAT_TOKEN_ISSUER, ASTRALBEAM_CHAT_TOKEN_KEY_ID, ASTRALBEAM_CHAT_TOKEN_LIFETIME_SECONDS, ASTRALBEAM_CHAT_TOKEN_MAX_LIFETIME_SECONDS, ASTRALBEAM_CHAT_TOKEN_TYPE, createAstralBeamChatToken };
+export { ASTRALBEAM_CHAT_TOKEN_AUDIENCE, ASTRALBEAM_CHAT_TOKEN_ISSUER, ASTRALBEAM_CHAT_TOKEN_LIFETIME_SECONDS, ASTRALBEAM_CHAT_TOKEN_MAX_LIFETIME_SECONDS, ASTRALBEAM_CHAT_TOKEN_TYPE, ASTRALBEAM_CHAT_TOKEN_VERSION, createAstralBeamChatToken, createAstralBeamTokenRoute };

package/dist/vue.d.ts

@@ -1,4 +1,4 @@
-//#region src/vue.d.ts
+//#region src/vue/index.d.ts
 declare const entrypoint = "vue";
 //#endregion
 export { entrypoint };

package/dist/vue.js

@@ -1,4 +1,4 @@
-//#region src/vue.ts
+//#region src/vue/index.ts
 const entrypoint = "vue";
 //#endregion
 export { entrypoint };