@tangle-network/agent-app 0.44.31 → 0.44.33

package/dist/assistant/index.d.ts

@@ -12,6 +12,8 @@ import '../agent-activity-C8ZG0F0M.js';
 import '../flow-types-CJxEmaRy.js';
 import '../queue-VTBA5ONX.js';
 import '../sandbox-terminal-ChNEdHF8.js';
+import '../billing-BibxgALe.js';
+import '../billing/index.js';
 import '../catalog/index.js';
 import '../harness/index.js';
 import '../attachment-validation-CNkH91Gs.js';

package/dist/assistant/index.js

@@ -3,7 +3,7 @@ import {
   ChatMessages,
   ModelPicker,
   ProviderLogo
-} from "../chunk-GCH3BUAZ.js";
+} from "../chunk-NDVTYHLN.js";
 import "../chunk-FBVLEGEG.js";
 import "../chunk-YTMKRL3L.js";
 import "../chunk-GEYACSFW.js";

package/dist/billing-BibxgALe.d.ts

@@ -0,0 +1,193 @@
+import { PlatformIdentity, PlatformBillingClient } from './billing/index.js';
+
+/**
+ * Platform billing HTTP transport + tier state for apps on the shared
+ * Tangle balance model (id.tangle.tools). Reads authenticate as the user via
+ * their per-user platform key (the platform resolves the caller from the
+ * key; service or impersonation headers on read routes are rejected). The
+ * deduct write authenticates as the product service (`Bearer <serviceToken>`
+ * + `X-Service-Name`) and names the target user in the body. Also provides a
+ * fetch-backed implementation of the `/billing` module's
+ * `PlatformBillingClient` seam (type-only import — no runtime coupling).
+ */
+
+/** Define available subscription tiers for the TanglePlan service */
+type TanglePlanTier = 'free' | 'pro' | 'enterprise';
+/** 'pro' | 'enterprise' pass through; anything else (null, unknown) → 'free'. */
+declare function normalizeTanglePlanTier(plan: string | null | undefined): TanglePlanTier;
+/** Represent platform billing HTTP errors with status code and detailed message */
+declare class PlatformBillingHttpError extends Error {
+    readonly status: number;
+    constructor(status: number, detail: string);
+}
+/** Structural guard (name + numeric status) — robust across module instances. */
+declare function isPlatformBillingHttpError(error: unknown): error is PlatformBillingHttpError;
+/** Define HTTP options for platform billing including base URL, service token, product slug, fetch implementation, and timeout */
+interface PlatformBillingHttpOptions {
+    /** Platform root, e.g. https://id.tangle.tools (trailing slashes stripped). */
+    baseUrl: string;
+    /** Used only by `deduct()`; resolved lazily so reads never require it.
+     *  Throws at call time when empty. */
+    serviceToken: string | (() => string);
+    /** Product slug — the `X-Service-Name` header and the deduct `product` field. */
+    productSlug: string;
+    fetchImpl?: typeof fetch;
+    /** Default 10 000. */
+    timeoutMs?: number;
+}
+/** Describe subscription tier and status information for a platform user */
+interface PlatformSubscriptionInfo {
+    tier: TanglePlanTier;
+    status: string | null;
+}
+/** Describe the platform balance and lifetime spending with an optional update timestamp */
+interface PlatformBalanceSnapshot {
+    balance: number;
+    lifetimeSpent: number;
+    updatedAt?: string;
+}
+/** Describe a product's usage and spending metrics on the platform */
+interface PlatformUsageProductRow {
+    product: string | null;
+    totalSpent: number;
+    count: number;
+}
+/** Lifecycle of a per-product seat subscription, mirroring the Stripe states
+ *  the platform persists. 'none' = the user has never held this seat. */
+type SeatStatus = 'none' | 'active' | 'trialing' | 'past_due' | 'canceled';
+/** Price and included shared-wallet credit for one seat billing period. */
+interface ProductSeatOfferPeriod {
+    priceCents: number;
+    includedCreditsCents: number;
+}
+/** Commercial terms returned by the platform's product catalog. Products use
+ * this exact object for display instead of duplicating prices in UI copy. */
+interface ProductSeatOffer {
+    currency: 'usd';
+    interval: 'month';
+    recurring: ProductSeatOfferPeriod;
+    introductory: ProductSeatOfferPeriod | null;
+}
+/**
+ * Per-product entitlement snapshot from the platform — the single read that
+ * tells a product whether to show its workspace or the seat paywall. Shape
+ * matches `GET /v1/billing/product-entitlement?product=<id>`.
+ *
+ * `hasSeat` and `onFreeTier` are computed platform-side from the raw seat row
+ * + cumulative spend so the access rule is identical across products:
+ * - `hasSeat`     — an active/trialing seat whose period has not lapsed.
+ * - `onFreeTier`  — no active seat AND cumulative spend below the free cap
+ *                   ($2 / 200¢ lifetime). Keys off lifetime spend, not wallet
+ *                   balance, so a router top-up never re-opens free access.
+ */
+interface ProductEntitlement {
+    seatStatus: SeatStatus;
+    /** ISO timestamp the active seat's paid period runs until; null when none. */
+    currentPeriodEnd: string | null;
+    /** Cumulative inference spend across the whole suite, in dollars. */
+    lifetimeSpentUsd: number;
+    hasSeat: boolean;
+    onFreeTier: boolean;
+    /** Present when the platform exposes catalog-backed commercial terms. */
+    offer?: ProductSeatOffer;
+}
+/** Define methods to interact with platform billing endpoints using user or service authentication */
+interface PlatformBillingHttp {
+    /** GET /v1/plans/current (user bearer). */
+    getSubscription(userApiKey: string): Promise<PlatformSubscriptionInfo>;
+    /** GET /v1/billing/balance (user bearer). */
+    getBalance(userApiKey: string): Promise<PlatformBalanceSnapshot>;
+    /** GET /v1/billing/usage (user bearer). */
+    getUsageByProduct(userApiKey: string): Promise<PlatformUsageProductRow[]>;
+    /** GET /v1/billing/product-entitlement?product=<id> (user bearer). */
+    getProductEntitlement(userApiKey: string, productId: string): Promise<ProductEntitlement>;
+    /** POST /v1/billing/deduct (service token). */
+    deduct(input: {
+        platformUserId: string;
+        amountUsd: number;
+        type: string;
+        description: string;
+        referenceId: string;
+    }): Promise<void>;
+    /** Absolute URL of the platform's billing-management surface. */
+    billingUrl(): string;
+    /** Absolute URL of the catalog-backed seat checkout for `productId`. */
+    seatCheckoutUrl(productId: string): string;
+}
+/** Create a PlatformBillingHttp instance configured with given options and default behaviors */
+declare function createPlatformBillingHttp(opts: PlatformBillingHttpOptions): PlatformBillingHttp;
+/**
+ * Platform Stripe checkout URL for a product's catalog-backed seat. The
+ * platform resolves the product-specific price and introductory offer from the
+ * `product` query param. Mirrors the `billingUrl()` shape — a deterministic
+ * platform-rooted URL with no client-side pricing decisions.
+ */
+declare function seatCheckoutUrl(baseUrl: string, productId: string): string;
+/** Define policy settings for concurrency and overage allowance in a tangle tier */
+interface TangleTierPolicy {
+    concurrency: number;
+    overageAllowed: boolean;
+}
+/** Define default concurrency and overage policies for each TanglePlanTier level */
+declare const DEFAULT_TANGLE_TIER_POLICY: Record<TanglePlanTier, TangleTierPolicy>;
+/** Describe the state of a Tangle plan tier including subscription, balance, spending, and concurrency details */
+interface TangleTierState {
+    tier: TanglePlanTier;
+    subscriptionStatus: string | null;
+    remainingBalanceUsd: number;
+    lifetimeSpentUsd: number;
+    concurrency: number;
+    overageAllowed: boolean;
+}
+/**
+ * Read subscription + balance and project them onto the tier policy. A
+ * null/absent key fails CLOSED (free tier, zero balance) — a billable run is
+ * never started against an unknown balance. Platform errors throw; callers
+ * on the billable path choose their posture explicitly.
+ */
+declare function readTangleTierState(http: PlatformBillingHttp, userApiKey: string | null | undefined, policy?: Record<TanglePlanTier, TangleTierPolicy>): Promise<TangleTierState>;
+/** Lifetime free-tier cap: $2 (200¢) cumulative inference spend, expressed in
+ *  dollars. Free product access ends once cumulative spend crosses this. */
+declare const FREE_TIER_SPEND_CAP_USD = 2;
+/**
+ * Default name of the per-app feature flag gating seat billing. While OFF the
+ * entitlement read is skipped and access fails OPEN (entitled) so nothing
+ * changes live until a product flips the flag.
+ */
+declare const DEFAULT_SEAT_BILLING_ENABLED_ENV_VAR = "SEAT_BILLING_ENABLED";
+/** Define options to configure seat billing flag environment variables and override flag name */
+interface SeatBillingFlagOptions {
+    env?: Record<string, string | undefined>;
+    /** Override the flag name; default {@link DEFAULT_SEAT_BILLING_ENABLED_ENV_VAR}. */
+    flagEnvVar?: string;
+}
+/**
+ * Seat billing is OFF unless the flag is explicitly truthy ('true'/'1'/'on'/
+ * 'enabled'). Default OFF — pre-rollout, the paywall never engages. Returns
+ * false when no env is available (browser bundles) so the client stays
+ * fail-open there too.
+ */
+declare function isSeatBillingEnabled(opts?: SeatBillingFlagOptions): boolean;
+/**
+ * Read a user's entitlement for one product. Fails OPEN: an absent key,
+ * disabled flag, or unreachable seat endpoint all return a permissive snapshot
+ * (`hasSeat: true`) so consumers never break pre-rollout. The platform owns the
+ * `hasSeat`/`onFreeTier` computation; this client only transports + degrades
+ * safely.
+ *
+ * @param flag — pass {@link isSeatBillingEnabled} (or your own boolean) so the
+ *   product owns when the gate engages. When false, no network call is made.
+ */
+declare function getProductEntitlement(http: Pick<PlatformBillingHttp, 'getProductEntitlement'>, userApiKey: string | null | undefined, productId: string, flag?: boolean): Promise<ProductEntitlement>;
+/** Entitled = holds an active seat OR is still inside the free tier. The one
+ *  predicate every product uses. */
+declare function isProductEntitled(ent: ProductEntitlement): boolean;
+/** Define a contract for resolving platform identities based on user identifiers */
+interface PlatformIdentityStore {
+    resolveIdentity(userId: string): Promise<PlatformIdentity | null>;
+}
+/** Concrete fetch-backed `PlatformBillingClient<TanglePlanTier>` for
+ *  `createPlatformBalanceManager` (from `/billing`). */
+declare function createTanglePlatformBillingClient(http: PlatformBillingHttp, identity: PlatformIdentityStore): PlatformBillingClient<TanglePlanTier>;
+
+export { DEFAULT_SEAT_BILLING_ENABLED_ENV_VAR as D, FREE_TIER_SPEND_CAP_USD as F, type PlatformBalanceSnapshot as P, type SeatBillingFlagOptions as S, type TanglePlanTier as T, DEFAULT_TANGLE_TIER_POLICY as a, type PlatformBillingHttp as b, PlatformBillingHttpError as c, type PlatformBillingHttpOptions as d, type PlatformIdentityStore as e, type PlatformSubscriptionInfo as f, type PlatformUsageProductRow as g, type ProductEntitlement as h, type ProductSeatOffer as i, type ProductSeatOfferPeriod as j, type SeatStatus as k, type TangleTierPolicy as l, type TangleTierState as m, createPlatformBillingHttp as n, createTanglePlatformBillingClient as o, getProductEntitlement as p, isPlatformBillingHttpError as q, isProductEntitled as r, isSeatBillingEnabled as s, normalizeTanglePlanTier as t, readTangleTierState as u, seatCheckoutUrl as v };

package/dist/chat-routes/index.js

@@ -97,7 +97,7 @@ import {
   flattenHistory,
   readSandboxBinaryBytes,
   statSandboxFileSize
-} from "../chunk-BAC2B2KI.js";
+} from "../chunk-7WXG4ZFP.js";
 import "../chunk-LWSJK546.js";
 import "../chunk-CQZSAR77.js";
 import "../chunk-ICOHEZK6.js";

package/dist/{chunk-BAC2B2KI.js → chunk-7WXG4ZFP.js}

@@ -643,6 +643,40 @@ function createSandboxPrewarmer(shell, options) {
   };
 }
 
+// src/sandbox/prewarm-claim-d1.ts
+var DEFAULT_PREWARM_CLAIM_TABLE = "sandbox_prewarm_claims";
+var PREWARM_CLAIM_TABLE_DDL = `CREATE TABLE IF NOT EXISTS ${DEFAULT_PREWARM_CLAIM_TABLE} (
+  key TEXT PRIMARY KEY,
+  expires_at INTEGER NOT NULL
+)`;
+var SAFE_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function createD1PrewarmClaimStore(db, options = {}) {
+  const table = options.table ?? DEFAULT_PREWARM_CLAIM_TABLE;
+  if (!SAFE_IDENTIFIER.test(table)) {
+    throw new Error(`Invalid prewarm claim table name: ${JSON.stringify(table)}`);
+  }
+  const now = options.now ?? (() => Date.now());
+  const acquireSql = `INSERT INTO ${table} (key, expires_at) VALUES (?1, ?2)
+ON CONFLICT(key) DO UPDATE SET expires_at = ?2 WHERE ${table}.expires_at <= ?3
+RETURNING key`;
+  const releaseSql = `DELETE FROM ${table} WHERE key = ?1`;
+  const isHeldSql = `SELECT 1 AS held FROM ${table} WHERE key = ?1 AND expires_at > ?2`;
+  return {
+    async acquire(key, ttlSeconds) {
+      const at = now();
+      const row = await db.prepare(acquireSql).bind(key, at + ttlSeconds * 1e3, at).first();
+      return row != null;
+    },
+    async release(key) {
+      await db.prepare(releaseSql).bind(key).run();
+    },
+    async isHeld(key) {
+      const row = await db.prepare(isHeldSql).bind(key, now()).first();
+      return row != null;
+    }
+  };
+}
+
 // src/sandbox/index.ts
 var DEFAULT_SANDBOX_DIRECT_KEY_NAMES = [
   "TCLOUD_SANDBOX_API_KEY",
@@ -1898,6 +1932,9 @@ export {
   bearerSubprotocolToken,
   terminalTokenFromRequest,
   createSandboxPrewarmer,
+  DEFAULT_PREWARM_CLAIM_TABLE,
+  PREWARM_CLAIM_TABLE_DDL,
+  createD1PrewarmClaimStore,
   resolveSandboxClientCredentials,
   DEFAULT_SANDBOX_RESOURCES,
   getClient,
@@ -1941,4 +1978,4 @@ export {
   isTerminalPromptEvent,
   detectInteractiveQuestion
 };
-//# sourceMappingURL=chunk-BAC2B2KI.js.map
+//# sourceMappingURL=chunk-7WXG4ZFP.js.map