@teaflask/assistant 0.0.0 → 0.6.0

package/dist/transport/token-session.d.ts

@@ -0,0 +1,33 @@
+import type { MintVisitorTokenResponse } from "../contract/identity.js";
+import { ServingApiError } from "./serving-error.js";
+export declare const END_USER_ID_MISMATCH = "END_USER_ID_MISMATCH";
+export interface TokenSessionConfig {
+    publishableKey: string;
+    baseUrl: string;
+    getEndUserToken?: () => string | null | Promise<string | null>;
+    expectedEndUserId?: string;
+    claimThreadId?: () => string | null;
+    onMinted?: (response: MintVisitorTokenResponse) => void;
+    onMintFailed?: (error: ServingApiError) => void;
+}
+export declare class TokenSession {
+    readonly baseUrl: string;
+    private readonly config;
+    private visitorToken;
+    private mintInFlight;
+    private remintTimer;
+    private transientFailureReported;
+    private _generation;
+    constructor(config: TokenSessionConfig);
+    readonly authorizedFetch: (url: string, requestInit?: RequestInit) => Promise<Response>;
+    dispose(): void;
+    private _currentToken;
+    private _remintAfterRejection;
+    private _mintSingleFlight;
+    private _mint;
+    private _reportMintFailure;
+    private _buildMintRequest;
+    private _scheduleProactiveRemint;
+    private _armRemint;
+    private _clearRemintTimer;
+}

package/dist/transport/token-session.js

@@ -0,0 +1,203 @@
+import { getMintVisitorTokenUrl } from "../generated/serving.js";
+import { parseServingError, ServingApiError } from "./serving-error.js";
+const PROACTIVE_REMINT_FRACTION = 0.8;
+const EXPIRY_MARGIN_SECONDS = 30;
+const REMINT_RETRY_BASE_MS = 15_000;
+const REMINT_RETRY_CAP_MS = 300_000;
+export const END_USER_ID_MISMATCH = "END_USER_ID_MISMATCH";
+export class TokenSession {
+    baseUrl;
+    config;
+    visitorToken = null;
+    mintInFlight = null;
+    remintTimer = null;
+    transientFailureReported = false;
+    _generation = 0;
+    constructor(config) {
+        this.config = config;
+        this.baseUrl = config.baseUrl;
+    }
+    authorizedFetch = async (url, requestInit = {}) => {
+        const token = await this._currentToken();
+        const response = await fetch(url, _withBearer(requestInit, token));
+        if (response.status === 401) {
+            const minted = await this._remintAfterRejection();
+            return fetch(url, _withBearer(requestInit, minted.visitor_token));
+        }
+        if (response.status === 403 && (await _saysSignInRequired(response))) {
+            let vouch;
+            try {
+                vouch = (await this.config.getEndUserToken?.()) ?? null;
+            }
+            catch {
+                vouch = null;
+            }
+            if (vouch === null) {
+                return response;
+            }
+            let minted;
+            try {
+                minted = await this._remintAfterRejection(vouch);
+            }
+            catch {
+                return response;
+            }
+            if (minted.tier !== "identified") {
+                return response;
+            }
+            return fetch(url, _withBearer(requestInit, minted.visitor_token));
+        }
+        return response;
+    };
+    dispose() {
+        this._generation += 1;
+        this._clearRemintTimer();
+        this.visitorToken = null;
+        this.mintInFlight = null;
+        this.transientFailureReported = false;
+    }
+    async _currentToken() {
+        if (this.visitorToken !== null &&
+            Date.now() < this.visitorToken.expiresAtMs) {
+            return this.visitorToken.value;
+        }
+        const minted = await this._mintSingleFlight();
+        return minted.visitor_token;
+    }
+    async _remintAfterRejection(vouch) {
+        this.visitorToken = null;
+        return this._mintSingleFlight(vouch);
+    }
+    _mintSingleFlight(vouch) {
+        if (this.mintInFlight === null) {
+            const flight = this._mint(vouch).finally(() => {
+                if (this.mintInFlight === flight) {
+                    this.mintInFlight = null;
+                }
+            });
+            this.mintInFlight = flight;
+        }
+        return this.mintInFlight;
+    }
+    async _mint(vouch, retriedForUser = false) {
+        const generation = this._generation;
+        const disposed = () => generation !== this._generation;
+        const response = await fetch(`${this.config.baseUrl}${getMintVisitorTokenUrl()}`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(await this._buildMintRequest(vouch)),
+        });
+        if (!response.ok) {
+            const error = await parseServingError(response);
+            if (!disposed()) {
+                this._reportMintFailure(error);
+            }
+            throw error;
+        }
+        const minted = (await response.json());
+        if (disposed()) {
+            return minted;
+        }
+        if (_namesAnotherUser(minted, this.config.expectedEndUserId)) {
+            if (!retriedForUser) {
+                return this._mint(undefined, true);
+            }
+            this.visitorToken = null;
+            const error = new ServingApiError({
+                code: END_USER_ID_MISMATCH,
+                status: response.status,
+                message: "The signed-in user this page names is not the user the server verified. Keep userId in step with the user your backend signs the end-user token for.",
+                retryAfterSeconds: null,
+            });
+            this.config.onMintFailed?.(error);
+            throw error;
+        }
+        this.visitorToken = {
+            value: minted.visitor_token,
+            expiresAtMs: Date.now() + (minted.expires_in - EXPIRY_MARGIN_SECONDS) * 1000,
+        };
+        this.transientFailureReported = false;
+        this._scheduleProactiveRemint(minted.expires_in);
+        this.config.onMinted?.(minted);
+        return minted;
+    }
+    _reportMintFailure(error) {
+        if (_mayClearOnItsOwn(error)) {
+            if (this.transientFailureReported) {
+                return;
+            }
+            this.transientFailureReported = true;
+        }
+        this.config.onMintFailed?.(error);
+    }
+    async _buildMintRequest(vouch) {
+        const endUserToken = vouch ?? (await this.config.getEndUserToken?.()) ?? null;
+        const request = {
+            publishable_key: this.config.publishableKey,
+        };
+        if (endUserToken !== null) {
+            request.end_user_token = endUserToken;
+            const claimThreadId = this.config.claimThreadId?.() ?? null;
+            if (claimThreadId !== null) {
+                request.claim_thread_id = claimThreadId;
+            }
+        }
+        return request;
+    }
+    _scheduleProactiveRemint(expiresInSeconds) {
+        this._armRemint(expiresInSeconds * PROACTIVE_REMINT_FRACTION * 1000, 0);
+    }
+    _armRemint(delayMs, failedAttempts) {
+        if (typeof window === "undefined") {
+            return;
+        }
+        this._clearRemintTimer();
+        const generation = this._generation;
+        this.remintTimer = setTimeout(() => {
+            this._mintSingleFlight().catch((error) => {
+                if (generation === this._generation && _mayClearOnItsOwn(error)) {
+                    this._armRemint(_remintRetryDelayMs(failedAttempts, error), failedAttempts + 1);
+                }
+            });
+        }, delayMs);
+    }
+    _clearRemintTimer() {
+        if (this.remintTimer !== null) {
+            clearTimeout(this.remintTimer);
+            this.remintTimer = null;
+        }
+    }
+}
+function _mayClearOnItsOwn(error) {
+    if (!(error instanceof ServingApiError)) {
+        return true;
+    }
+    return error.status >= 500 || error.status === 429;
+}
+function _remintRetryDelayMs(failedAttempts, error) {
+    const backoffMs = Math.min(REMINT_RETRY_BASE_MS * 2 ** failedAttempts, REMINT_RETRY_CAP_MS);
+    const retryAfterMs = error instanceof ServingApiError && error.retryAfterSeconds !== null
+        ? error.retryAfterSeconds * 1000
+        : 0;
+    return Math.max(backoffMs, retryAfterMs) * (1 + Math.random() * 0.4);
+}
+function _namesAnotherUser(minted, expectedEndUserId) {
+    return (minted.tier === "identified" &&
+        expectedEndUserId !== undefined &&
+        typeof minted.end_user_id === "string" &&
+        minted.end_user_id !== expectedEndUserId);
+}
+function _withBearer(requestInit, token) {
+    const headers = new Headers(requestInit.headers);
+    headers.set("Authorization", `Bearer ${token}`);
+    return { ...requestInit, headers };
+}
+async function _saysSignInRequired(response) {
+    try {
+        const body = (await response.clone().json());
+        return body.error?.code === "ASSISTANT_SIGN_IN_REQUIRED";
+    }
+    catch {
+        return false;
+    }
+}

package/package.json

@@ -1,6 +1,91 @@
 {
   "name": "@teaflask/assistant",
-  "version": "0.0.0",
-  "description": "Placeholder reserving the package name. The teaflask embedded assistant ships here.",
-  "license": "UNLICENSED"
+  "version": "0.6.0",
+  "description": "The AI assistant for your product: drop it into your React app or any page with a script tag.",
+  "license": "FSL-1.1-ALv2",
+  "author": "Teaflask",
+  "homepage": "https://docs.teaflask.com/assistant-ui",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/teaflask/assistant.git"
+  },
+  "bugs": {
+    "url": "https://github.com/teaflask/assistant/issues"
+  },
+  "keywords": [
+    "ai",
+    "assistant",
+    "chat",
+    "ai-assistant",
+    "agent",
+    "react",
+    "web-component",
+    "embeddable"
+  ],
+  "type": "module",
+  "engines": {
+    "node": ">=20"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./activity": {
+      "types": "./dist/activity.d.ts",
+      "import": "./dist/activity.js",
+      "default": "./dist/activity.js"
+    },
+    "./headless": {
+      "types": "./dist/headless.d.ts",
+      "import": "./dist/headless.js",
+      "default": "./dist/headless.js"
+    },
+    "./markdown": {
+      "types": "./dist/markdown.d.ts",
+      "import": "./dist/markdown.js",
+      "default": "./dist/markdown.js"
+    },
+    "./scroll": {
+      "types": "./dist/scroll.d.ts",
+      "import": "./dist/scroll.js",
+      "default": "./dist/scroll.js"
+    },
+    "./transcript": {
+      "types": "./dist/transcript.d.ts",
+      "import": "./dist/transcript.js",
+      "default": "./dist/transcript.js"
+    },
+    "./transcript-ui": {
+      "types": "./dist/transcript-ui.d.ts",
+      "import": "./dist/transcript-ui.js",
+      "default": "./dist/transcript-ui.js"
+    },
+    "./styles.css": "./dist/styles.css",
+    "./package.json": "./package.json"
+  },
+  "sideEffects": [
+    "**/*.css"
+  ],
+  "dependencies": {
+    "@ag-ui/client": "1.0.0",
+    "@ag-ui/core": "1.0.0",
+    "@shikijs/langs": "^4.4.3",
+    "lucide-react": "^1.47.0",
+    "marked": "^18.0.13",
+    "react-markdown": "^10.1.0",
+    "remark-breaks": "^4.0.0",
+    "remark-gfm": "^4.0.1",
+    "rxjs": "^7.8.0",
+    "shiki": "^4.4.3"
+  },
+  "peerDependencies": {
+    "react": "^18.3.0 || ^19.0.0",
+    "react-dom": "^18.3.0 || ^19.0.0",
+    "use-stick-to-bottom": "^1.1.6"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
 }