@tangle-network/agent-app 0.43.24 → 0.43.26

package/dist/parts-BcbitSNp.d.ts

@@ -0,0 +1,176 @@
+import { Part } from '@tangle-network/agent-interface';
+import { a as ChatInteractionField, b as ChatInteractionStatus, N as NoticeKind } from './contract-DYbTzEDf.js';
+
+/**
+ * The stored shape of `message.parts` — one typed vocabulary for every part a
+ * product persists into a chat transcript. NOT an ad-hoc union reverse-
+ * engineered from product schemas; each member is matched field-for-field to
+ * its canonical source:
+ *
+ * - `text` / `reasoning` / `tool`: the persisted projection `/stream`'s
+ *   `normalizePersistedPart` produces from the harness lane's
+ *   `message.part.updated` events (ADC sidecar
+ *   `apps/sidecar/src/events/session-events.ts:56` wraps the canonical part in
+ *   an `{id, sessionID, messageID}` envelope; the projection strips the
+ *   session/message ids and keeps the per-segment part id).
+ * - `file` / `image` / `step-start` / `step-finish`: the sidecar's canonical
+ *   `MessagePartSchema` members (ADC
+ *   `apps/sidecar/src/schemas/agent-schemas.ts:50-154`); `step-finish` carries
+ *   the harness's per-step usage receipt — tokens
+ *   `{total, input, output, reasoning, cache{write, read}}` + `cost` — which is
+ *   also the shape the message-level token/cost columns mirror.
+ * - `subtask`: `@tangle-network/agent-interface`'s `SubtaskPart` (a spawned
+ *   sub-agent task).
+ * - `interaction` / `notice`: the persisted-part codecs in
+ *   `/web-react`'s chat-interactions contract (`interactionToPersistedPart`,
+ *   `noticePart`) — type-only imports, one source of truth for their statuses
+ *   and field shapes.
+ *
+ * `@tangle-network/agent-interface` exports the canonical wire `Part` union,
+ * but its `PartBase` requires the `sessionID`/`messageID` stream envelope that
+ * is deliberately NOT persisted, so the stored union is defined here as the
+ * envelope-free projection (a type-level coverage check against the peer's
+ * `Part['type']` lives in the tests). Contribute-down candidate: if
+ * agent-interface grows envelope-free persisted-part types, re-export them
+ * here and delete these definitions.
+ *
+ * Two transport lanes serialize into this SAME stored shape:
+ * - harness lane: canonical `message.part.updated` parts, merged/normalized by
+ *   `/stream` (`mergePersistedPart`, `finalizeAssistantParts`);
+ * - router/openai-compat lane: `text_delta`/`tool_call` stream events are
+ *   mapped INTO canonical part events first (`/runtime`'s `toLoopEvents` +
+ *   `/stream`'s `normalizeToolEvent`) and then persisted identically — the
+ *   store never sees a router-specific shape.
+ */
+
+/** Start/end wall-clock millis, as normalized by `/stream`'s `normalizeTime`. */
+interface ChatPartTime {
+    start?: number;
+    end?: number;
+}
+/** `id` is the harness's per-segment identity; absent on legacy/router parts,
+ *  which collapse to a single logical text stream. Never invented client-side. */
+interface ChatTextPart {
+    type: 'text';
+    text: string;
+    id?: string;
+}
+interface ChatReasoningPart {
+    type: 'reasoning';
+    text: string;
+    id?: string;
+    time?: ChatPartTime;
+}
+/** Superset of the sidecar's status enum (`pending|running|completed|failed`)
+ *  and agent-interface's `ToolState` statuses; `error` is the persisted
+ *  terminal form `/stream`'s `normalizePersistedPart` settles on. */
+type ChatToolStatus = 'pending' | 'running' | 'completed' | 'error' | 'failed';
+interface ChatToolState {
+    status: ChatToolStatus;
+    input?: unknown;
+    output?: unknown;
+    error?: string;
+    title?: string;
+    metadata?: Record<string, unknown>;
+    time?: ChatPartTime;
+}
+interface ChatToolPart {
+    type: 'tool';
+    id: string;
+    tool: string;
+    callID?: string;
+    state: ChatToolState;
+}
+/** Union of the sidecar's legacy (path-based) and AI-SDK (url-based) file
+ *  shapes; response-side every field besides `type` is optional. */
+interface ChatFilePart {
+    type: 'file';
+    id?: string;
+    filename?: string;
+    mediaType?: string;
+    url?: string;
+    path?: string;
+    content?: string;
+}
+interface ChatImagePart {
+    type: 'image';
+    filename?: string;
+    mediaType?: string;
+    url?: string;
+    path?: string;
+}
+interface ChatSubtaskPart {
+    type: 'subtask';
+    prompt: string;
+    description: string;
+    agent: string;
+    id?: string;
+}
+/** OpenCode step-boundary marker — no renderable text; preserved so mappers
+ *  never coerce it into a "[object Object]" text part. */
+interface ChatStepStartPart {
+    type: 'step-start';
+}
+/** Per-step usage receipt as the harness reports it (sidecar
+ *  `StepFinishPartSchema`). The message-level token/cost columns are this
+ *  shape flattened. */
+interface ChatUsageTokens {
+    total?: number;
+    input?: number;
+    output?: number;
+    reasoning?: number;
+    cache?: {
+        write?: number;
+        read?: number;
+    };
+}
+interface ChatStepFinishPart {
+    type: 'step-finish';
+    reason?: string;
+    tokens?: ChatUsageTokens;
+    cost?: number;
+}
+/** Persisted human-in-the-loop ask — byte-matches
+ *  `interactionToPersistedPart` in `/web-react`'s chat-interactions contract. */
+interface ChatInteractionPart {
+    type: 'interaction';
+    id: string;
+    kind: string;
+    title: string;
+    body?: string;
+    answerSpec: {
+        fields: ChatInteractionField[];
+    };
+    status: ChatInteractionStatus;
+    cancelReason?: string;
+}
+/** Persisted one-line transcript notice — byte-matches `noticePart` in
+ *  `/web-react`'s chat-interactions contract. */
+interface ChatNoticePart {
+    type: 'notice';
+    id: string;
+    noticeKind: NoticeKind;
+    text: string;
+}
+type ChatMessagePart = ChatTextPart | ChatReasoningPart | ChatToolPart | ChatFilePart | ChatImagePart | ChatSubtaskPart | ChatStepStartPart | ChatStepFinishPart | ChatInteractionPart | ChatNoticePart;
+/** Every canonical harness wire-part kind must be storable — compile-time
+ *  guarantee that a new agent-interface part kind cannot silently fall out of
+ *  the persisted vocabulary. */
+type StorableHarnessPartKind = Part['type'] & ChatMessagePart['type'];
+/**
+ * The typed projection at the `/stream` → `/chat-store` boundary. The stream
+ * normalizers (`normalizePersistedPart`/`mergePersistedPart`/
+ * `finalizeAssistantParts`) deliberately produce untyped `JsonRecord`s — they
+ * normalize wire shapes and do not own the stored vocabulary. THIS module
+ * owns it, so this is where rows gain the `ChatMessagePart` type: each entry
+ * is validated against its kind's required fields and narrowed, junk is
+ * dropped, and — enforced by the exhaustiveness check below — no storable
+ * kind can silently fall out (the step-finish/interaction trap).
+ */
+declare function toChatMessageParts(parts: Array<Record<string, unknown>>): ChatMessagePart[];
+declare function isChatToolPart(part: ChatMessagePart): part is ChatToolPart;
+declare function isChatTextPart(part: ChatMessagePart): part is ChatTextPart;
+declare function isChatInteractionPart(part: ChatMessagePart): part is ChatInteractionPart;
+declare function isChatStepFinishPart(part: ChatMessagePart): part is ChatStepFinishPart;
+
+export { type ChatFilePart as C, type StorableHarnessPartKind as S, type ChatImagePart as a, type ChatInteractionPart as b, type ChatMessagePart as c, type ChatNoticePart as d, type ChatPartTime as e, type ChatReasoningPart as f, type ChatStepFinishPart as g, type ChatStepStartPart as h, type ChatSubtaskPart as i, type ChatTextPart as j, type ChatToolPart as k, type ChatToolState as l, type ChatToolStatus as m, type ChatUsageTokens as n, isChatInteractionPart as o, isChatStepFinishPart as p, isChatTextPart as q, isChatToolPart as r, toChatMessageParts as t };

package/dist/platform/index.d.ts

@@ -1,217 +1,7 @@
+export { c as AdminGuardOptions, d as AssertBillableBalanceOptions, A as AuthGuard, e as AuthGuardOptions, B as BetterAuthSessionCookieMinterOptions, f as BetterAuthSessionCookieSource, g as BillableBalanceState, G as GuardResolution, S as SsoStateConfig, b as TangleSsoAccountStore, a as TangleSsoAuthClient, h as TangleSsoExchangeResult, i as TangleSsoHandlerOptions, T as TangleSsoHandlers, j as TangleSsoSessionCookieArgs, k as TangleSsoUserCreateError, l as assertBillableBalance, m as createAdminGuard, n as createAuthGuard, o as createBetterAuthSessionCookieMinter, p as createSignedSsoState, q as createTangleSsoHandlers, r as guardResolution, s as parseAdminEmails, t as signSessionCookieValue, v as verifySignedSsoState } from '../sso-CNOsARMJ.js';
 import { f as TangleExecutionEnvironment, j as TangleExecutionKeySource } from '../model-dF2h4xT9.js';
 import { PlatformIdentity, PlatformBillingClient } from '../billing/index.js';
 
-/**
- * Cross-site Tangle SSO for agent apps: signed-state CSRF cookies plus the
- * full start/callback orchestration against the platform's /cross-site
- * bridge. The platform wire client and account persistence are structural
- * seams (`TangleSsoAuthClient` / `TangleSsoAccountStore`), so this module
- * never imports agent-runtime, an auth framework, or a database driver.
- * WebCrypto only — runs in workerd without node compatibility flags.
- */
-interface SsoStateConfig {
-    /** HMAC-SHA256 secret (e.g. the app's auth secret). */
-    secret: string;
-    /** State lifetime in ms. Default 600 000. */
-    ttlMs?: number;
-    /** Injectable clock (ms since epoch). Default Date.now. */
-    now?: () => number;
-}
-/** Mint a `<randomHex32>.<timestamp36>.<hmacHex>` state value. The timestamp
- *  is inside the signed payload, so expiry survives cookie-attribute tampering. */
-declare function createSignedSsoState(config: SsoStateConfig): Promise<string>;
-/** Verify the MAC (constant-time) and the signed TTL. */
-declare function verifySignedSsoState(state: string, config: SsoStateConfig): Promise<boolean>;
-interface TangleSsoExchangeResult {
-    apiKey: string;
-    user: {
-        id: string;
-        email: string;
-        name?: string | null;
-    };
-    plan?: {
-        tier: string;
-    } | null;
-}
-/** Structural mirror of the platform auth wire client — any object with these
- *  two methods satisfies it without this module importing the concrete class. */
-interface TangleSsoAuthClient {
-    authorizeUrl(options: {
-        state: string;
-        redirectUri?: string;
-    }): string;
-    exchange(code: string): Promise<TangleSsoExchangeResult>;
-}
-/** Thrown by `upsertUserByEmail` when the app-local user row cannot be
- *  created; the callback handler maps it to `?error=tangle_user_create_failed`.
- *  Any other store error propagates. */
-declare class TangleSsoUserCreateError extends Error {
-    constructor(message?: string);
-}
-/**
- * Account persistence seam. Covers both storage styles in use: link-table
- * apps (a per-user platform-link row) and session-column apps (the key on the
- * session row) — `saveTangleLink` receives both `userId` and `sessionToken`,
- * and each app persists with the key it needs. `createSession` runs first so
- * the token is always available to `saveTangleLink`.
- */
-interface TangleSsoAccountStore {
-    /** Find-or-create the app-local user. `tangleUserId` is the platform's
-     *  stable user id — match on it first when the app stores it (emails are
-     *  mutable on the platform; the id is not), falling back to email for
-     *  first-time logins. */
-    upsertUserByEmail(input: {
-        email: string;
-        name: string | null;
-        tangleUserId: string;
-    }): Promise<{
-        userId: string;
-    }>;
-    /** Create an app session row; returns the session-cookie token value. */
-    createSession(input: {
-        userId: string;
-        expiresAt: Date;
-        ipAddress: string | null;
-        userAgent: string | null;
-    }): Promise<{
-        token: string;
-    }>;
-    /** Persist the platform link (API key + platform identity). */
-    saveTangleLink(input: {
-        userId: string;
-        sessionToken: string;
-        tangleUserId: string;
-        email: string;
-        name: string | null;
-        apiKey: string;
-        planTier: string | null;
-    }): Promise<void>;
-}
-/** Successful-login context handed to the `setSessionCookie` seam. */
-interface TangleSsoSessionCookieArgs {
-    /** Session token returned by `store.createSession`. */
-    token: string;
-    /** Session expiry (now + `sessionTtlSeconds`). */
-    expiresAt: Date;
-    /** Mirrors `sessionTtlSeconds` after defaulting. */
-    ttlSeconds: number;
-    /** Mirrors `TangleSsoHandlerOptions.secureCookies`. */
-    secure: boolean;
-}
-/**
- * Sign a session token to better-call's signed-cookie contract — the value
- * better-auth's `getSignedCookie` verifies: `<token>.<signature>` where the
- * signature is the raw HMAC-SHA256 of the token under `secret`, encoded as
- * STANDARD base64 WITH padding (32 bytes → 44 chars ending `=`; better-call
- * rejects any other length or suffix, so url-safe/unpadded variants read back
- * as a null session). The joined value is percent-encoded once at cookie
- * serialization, matching better-call's `serializeSignedCookie` byte-exactly.
- */
-declare function signSessionCookieValue(token: string, secret: string): Promise<string>;
-/** Structural slice of a `betterAuth()` instance — only what cookie minting
- *  reads. No better-auth import: the signing contract is implemented by
- *  `signSessionCookieValue`, byte-compatible with better-auth's own
- *  `makeSignature`. */
-interface BetterAuthSessionCookieSource {
-    $context: PromiseLike<{
-        secret: string;
-        authCookies: {
-            sessionToken: {
-                /** Final cookie name — better-auth decides the `__Secure-` prefix
-                 *  (and any `advanced.cookiePrefix`) once at `betterAuth()` init. */
-                name: string;
-                attributes: {
-                    secure?: boolean;
-                    sameSite?: string;
-                    path?: string;
-                    httpOnly?: boolean;
-                    domain?: string;
-                };
-            };
-        };
-    }>;
-}
-interface BetterAuthSessionCookieMinterOptions {
-    /** Receives the shadowed-cookie-name warning (see below). Default
-     *  console.warn. */
-    warn?: (message: string) => void;
-}
-/**
- * Canonical `setSessionCookie` wiring for better-auth apps: mint the session
- * Set-Cookie exactly as better-auth's own login flows do — name + attributes
- * from `auth.$context.authCookies.sessionToken` (better-auth stays
- * authoritative over prefix/name/attributes) and the value signed to
- * better-call's `getSignedCookie` contract. A raw unprefixed
- * `better-auth.session_token` left by an earlier login is explicitly expired
- * so it cannot shadow the real cookie.
- *
- * Warns when the app's session cookie still has better-auth's DEFAULT name:
- * the Tangle platform (id.tangle.tools) sets a `Domain=.tangle.tools` cookie
- * under that exact name, and equal-path cookies are sent oldest-first — the
- * platform's cookie is always older (the user signs in there before the app's
- * callback runs), so the app reads the platform's token, fails its own
- * signature check, and every fresh login lands logged-out. Per-app
- * `advanced.cookiePrefix` is the fix.
- *
- * Throws on a domain-scoped session cookie for the same reason: a
- * `Domain=`-wide session cookie is exactly the shadowing footgun.
- */
-declare function createBetterAuthSessionCookieMinter(auth: BetterAuthSessionCookieSource, options?: BetterAuthSessionCookieMinterOptions): (args: TangleSsoSessionCookieArgs) => Promise<string[]>;
-interface TangleSsoHandlerOptions {
-    auth: TangleSsoAuthClient;
-    store: TangleSsoAccountStore;
-    /** HMAC secret for the state cookie. */
-    stateSecret: string;
-    /** Absolute callback URL registered with the platform. */
-    callbackUrl: string;
-    stateCookieName: string;
-    /** Default 'better-auth.session_token'. Ignored when `setSessionCookie` is
-     *  provided. The default path prepends `__Secure-` iff `secureCookies`. */
-    sessionCookieName?: string;
-    /** Mint the host auth framework's own session cookie(s); return complete
-     *  Set-Cookie header values (the handler appends them verbatim and sets no
-     *  session cookie itself). Supply this when the framework should stay
-     *  authoritative over name/prefix/signing/attributes — e.g. better-auth:
-     *  `auth.$context.authCookies.sessionToken` + `makeSignature`. */
-    setSessionCookie?: (args: TangleSsoSessionCookieArgs) => readonly string[] | Promise<readonly string[]>;
-    /** HMAC-SHA256 secret the host auth framework verifies session cookies with
-     *  (better-auth: its `secret`). Required when `setSessionCookie` is absent —
-     *  the default cookie is minted to better-call's signed contract via
-     *  `signSessionCookieValue`; an unsigned or mis-signed value reads back as a
-     *  null session, so there is deliberately no fallback to `stateSecret`
-     *  (which is not guaranteed to be the auth secret). */
-    sessionCookieSecret?: string;
-    /** Adds `Secure` to every cookie this module sets, and (default session
-     *  cookie only) the `__Secure-` name prefix. Must match the auth
-     *  framework's own secure-cookie decision (better-auth: https `baseURL` /
-     *  `advanced.useSecureCookies`), or it will look up a different cookie name
-     *  than the one set here. */
-    secureCookies: boolean;
-    /** Default 604 800 (7 days). */
-    sessionTtlSeconds?: number;
-    /** Default 600. Applies to both the cookie Max-Age and the signed TTL. */
-    stateTtlSeconds?: number;
-    /** Default '/app'. */
-    defaultRedirectPath?: string;
-    /** Default '/login'. */
-    loginPath?: string;
-    /** Failure log hook (e.g. console.error). Default no-op. */
-    log?: (message: string, error?: unknown) => void;
-    now?: () => number;
-}
-interface TangleSsoHandlers {
-    /** GET start route: mint + sign state, set the state cookie, 302 to the
-     *  platform authorize URL. `?redirect=` carries the post-login path. */
-    start(request: Request): Promise<Response>;
-    /** GET callback route: verify state, exchange the code, upsert the user,
-     *  create the session, save the platform link, set the session cookie
-     *  (via the `setSessionCookie` seam, else signed to better-call's contract
-     *  with `sessionCookieSecret`), 302 to the saved redirect. Every failure
-     *  302s to `loginPath?error=…` with the state cookie cleared. */
-    callback(request: Request): Promise<Response>;
-}
-declare function createTangleSsoHandlers(opts: TangleSsoHandlerOptions): TangleSsoHandlers;
-
 /**
  * Integrations-hub proxy routes: the app-side surface that forwards an
  * authenticated user's requests to the platform's `/v1/integrations/*` API
@@ -473,62 +263,4 @@ interface PlatformIdentityStore {
  *  `createPlatformBalanceManager` (from `/billing`). */
 declare function createTanglePlatformBillingClient(http: PlatformBillingHttp, identity: PlatformIdentityStore): PlatformBillingClient<TanglePlanTier>;
 
-/**
- * Request guards for agent-app routes: session auth (302 redirect for pages,
- * JSON 401 for APIs), admin allowlisting (404 — the route stays invisible to
- * non-admins), and the billable-balance gate (402 with a stable code).
- * Session resolution is a seam; thrown Responses follow the router convention
- * of surfacing a thrown Response as the route result.
- */
-interface AuthGuardOptions<Session> {
-    /** e.g. a better-auth `auth.api.getSession` wrapped by the app. */
-    getSession(request: Request): Promise<Session | null | undefined>;
-    /** Default '/login'. */
-    loginPath?: string;
-}
-interface AuthGuard<Session> {
-    /** Page guard — throws a 302 redirect Response to `loginPath`. */
-    requireUser(request: Request): Promise<Session>;
-    /** API guard — throws JSON 401 `{ error: 'Unauthorized', code: 'auth.unauthenticated' }`. */
-    requireApiUser(request: Request): Promise<Session>;
-    /** `apiResponse` selects the 401 JSON path over the redirect. */
-    requireSession(request: Request, opts?: {
-        apiResponse?: boolean;
-    }): Promise<Session>;
-    getOptionalSession(request: Request): Promise<Session | null>;
-}
-declare function createAuthGuard<Session>(opts: AuthGuardOptions<Session>): AuthGuard<Session>;
-/** Comma/whitespace separated → trimmed, lowercased, empties dropped. */
-declare function parseAdminEmails(raw: string | null | undefined): string[];
-interface AdminGuardOptions<Session> {
-    requireUser(request: Request): Promise<Session>;
-    emailOf(session: Session): string | null | undefined;
-    /** Resolved per request; an EMPTY allowlist refuses everyone. */
-    allowedEmails(): string[];
-}
-/** Non-admins (and empty allowlists) get 404, keeping the route invisible —
- *  better than a "forbidden" footprint that advertises its existence. */
-declare function createAdminGuard<Session>(opts: AdminGuardOptions<Session>): (request: Request) => Promise<Session>;
-interface BillableBalanceState {
-    overageAllowed: boolean;
-    remainingBalanceUsd: number;
-}
-interface AssertBillableBalanceOptions {
-    env?: Record<string, string | undefined>;
-    /** App-specific enforcement override flag (e.g. 'GTM_BILLING_ENFORCEMENT'),
-     *  fed to `isTangleBillingEnforcementDisabled`. */
-    enforcementEnvVar?: string;
-    /** Default 'Add balance or upgrade your plan to invoke this agent.'. */
-    errorMessage?: string;
-    /** Merged into the 402 JSON body (e.g. `{ organizationId }`). */
-    errorBody?: Record<string, unknown>;
-}
-/**
- * Gate a billable turn: passes when enforcement is disabled (dev default),
- * the tier allows overage, or remaining balance is positive. Otherwise throws
- * a 402 Response with the stable `billing.balance_required` code so clients
- * can route to the billing screen.
- */
-declare function assertBillableBalance(state: BillableBalanceState, opts?: AssertBillableBalanceOptions): void;
-
-export { type AdminGuardOptions, type AssertBillableBalanceOptions, type AuthGuard, type AuthGuardOptions, type BetterAuthSessionCookieMinterOptions, type BetterAuthSessionCookieSource, type BillableBalanceState, DEFAULT_SEAT_BILLING_ENABLED_ENV_VAR, DEFAULT_TANGLE_TIER_POLICY, FREE_TIER_SPEND_CAP_USD, type HubClientLike, type HubProxyContext, type HubProxyRouteArgs, type HubProxyRoutes, type PlatformBalanceSnapshot, type PlatformBillingHttp, PlatformBillingHttpError, type PlatformBillingHttpOptions, type PlatformIdentityStore, type PlatformSubscriptionInfo, type PlatformUsageProductRow, type ProductEntitlement, type ResolveUserTangleHubBearerForUserOptions, type ResolveUserTangleHubBearerOptions, type ResolvedTangleHubBearer, type SeatBillingFlagOptions, type SeatStatus, type SsoStateConfig, TangleBearerMissingError, type TangleHubBearerSource, type TanglePlanTier, type TangleSsoAccountStore, type TangleSsoAuthClient, type TangleSsoExchangeResult, type TangleSsoHandlerOptions, type TangleSsoHandlers, type TangleSsoSessionCookieArgs, TangleSsoUserCreateError, type TangleTierPolicy, type TangleTierState, assertBillableBalance, createAdminGuard, createAuthGuard, createBetterAuthSessionCookieMinter, createHubProxyRoutes, createPlatformBillingHttp, createSignedSsoState, createTanglePlatformBillingClient, createTangleSsoHandlers, getProductEntitlement, isPlatformBillingHttpError, isPlatformHubErrorLike, isProductEntitled, isSeatBillingEnabled, isTangleBearerMissingError, normalizeTanglePlanTier, parseAdminEmails, readTangleTierState, resolveUserTangleHubBearer, resolveUserTangleHubBearerForUser, seatCheckoutUrl, signSessionCookieValue, verifySignedSsoState };
+export { DEFAULT_SEAT_BILLING_ENABLED_ENV_VAR, DEFAULT_TANGLE_TIER_POLICY, FREE_TIER_SPEND_CAP_USD, type HubClientLike, type HubProxyContext, type HubProxyRouteArgs, type HubProxyRoutes, type PlatformBalanceSnapshot, type PlatformBillingHttp, PlatformBillingHttpError, type PlatformBillingHttpOptions, type PlatformIdentityStore, type PlatformSubscriptionInfo, type PlatformUsageProductRow, type ProductEntitlement, type ResolveUserTangleHubBearerForUserOptions, type ResolveUserTangleHubBearerOptions, type ResolvedTangleHubBearer, type SeatBillingFlagOptions, type SeatStatus, TangleBearerMissingError, type TangleHubBearerSource, type TanglePlanTier, type TangleTierPolicy, type TangleTierState, createHubProxyRoutes, createPlatformBillingHttp, createTanglePlatformBillingClient, getProductEntitlement, isPlatformBillingHttpError, isPlatformHubErrorLike, isProductEntitled, isSeatBillingEnabled, isTangleBearerMissingError, normalizeTanglePlanTier, readTangleTierState, resolveUserTangleHubBearer, resolveUserTangleHubBearerForUser, seatCheckoutUrl };