terse-types 0.0.23 → 0.0.25

package/dist/ApiRouteBuilder.d.ts

@@ -130,6 +130,8 @@ export declare const ApiRoutes: {
         DEPLOYS: string;
         SOURCE_FILES: string;
         SOURCE_FILE_CONTENT: string;
+        ROTATE_SIGNING_SECRET: string;
+        ROTATE_API_KEY: string;
     };
     SDK: {
         ME: string;
@@ -142,6 +144,7 @@ export declare const ApiRoutes: {
         AGENT_RUN: string;
         APPROVAL_DECISION: string;
         SESSION_EVENTS: string;
+        LISTEN: string;
         CREATE_PROJECT: string;
         DEPLOY: string;
         DEVICE_TOKEN_EXCHANGE: string;

package/dist/ApiRoutes.json

@@ -129,7 +129,9 @@
         "BY_ID": "/projects/:id",
         "DEPLOYS": "/projects/:id/deploys",
         "SOURCE_FILES": "/projects/:id/source/files",
-        "SOURCE_FILE_CONTENT": "/projects/:id/source/files/:fileId"
+        "SOURCE_FILE_CONTENT": "/projects/:id/source/files/:fileId",
+        "ROTATE_SIGNING_SECRET": "/projects/:id/rotate-signing-secret",
+        "ROTATE_API_KEY": "/projects/:id/rotate-api-key"
     },
     "SDK": {
         "ME": "/sdk/me",
@@ -142,6 +144,7 @@
         "AGENT_RUN": "/sdk/agent-run",
         "APPROVAL_DECISION": "/sdk/approval-decision",
         "SESSION_EVENTS": "/sdk/session-events",
+        "LISTEN": "/sdk/listen",
         "CREATE_PROJECT": "/sdk/projects",
         "DEPLOY": "/sdk/deploy",
         "DEVICE_TOKEN_EXCHANGE": "/sdk/auth/device-token-exchange",

package/dist/Billing.d.ts

@@ -0,0 +1,403 @@
+import { z } from "zod";
+export declare enum PlanKey {
+    FREE = "free",
+    PRO = "pro"
+}
+export declare const planKeySchema: z.ZodEnum<typeof PlanKey>;
+export declare enum TimePeriods {
+    MONTHLY = "monthly",
+    YEARLY = "yearly"
+}
+export declare const billingPeriodSchema: z.ZodEnum<typeof TimePeriods>;
+export type BillingPeriod = z.infer<typeof billingPeriodSchema>;
+export declare enum SupportedTopUps {
+    TOPUP_10K = 10000
+}
+export declare const supportedTopUpsSchema: z.ZodEnum<typeof SupportedTopUps>;
+export declare const envIdSchema: z.ZodObject<{
+    live: z.ZodString;
+    test: z.ZodString;
+}, z.core.$strip>;
+export type EnvId = z.infer<typeof envIdSchema>;
+export declare const overageModeSchema: z.ZodEnum<{
+    soft: "soft";
+    strict: "strict";
+}>;
+export type OverageMode = z.infer<typeof overageModeSchema>;
+export declare const DEFAULT_OVERAGE_CAP_MULTIPLIER = 2;
+export declare const DEFAULT_OVERAGE_MODE: OverageMode;
+export declare const billingScheduledChangeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"cancel_to_free">;
+    effectiveAt: z.ZodCoercedDate<unknown>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"change_period">;
+    effectiveAt: z.ZodCoercedDate<unknown>;
+    period: z.ZodEnum<typeof TimePeriods>;
+}, z.core.$strip>], "kind">;
+export type BillingScheduledChange = z.infer<typeof billingScheduledChangeSchema>;
+export declare const balanceSummarySchema: z.ZodObject<{
+    planKey: z.ZodEnum<typeof PlanKey>;
+    billingPeriod: z.ZodNullable<z.ZodEnum<typeof TimePeriods>>;
+    planCredits: z.ZodNumber;
+    consumedCredits: z.ZodNumber;
+    remainingCredits: z.ZodNumber;
+    totalCreditCapacity: z.ZodNumber;
+    periodStart: z.ZodCoercedDate<unknown>;
+    periodEnd: z.ZodCoercedDate<unknown>;
+    overageMode: z.ZodEnum<{
+        soft: "soft";
+        strict: "strict";
+    }>;
+    hardCap: z.ZodNumber;
+    canBuyTopups: z.ZodBoolean;
+    scheduledChange: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"cancel_to_free">;
+        effectiveAt: z.ZodCoercedDate<unknown>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"change_period">;
+        effectiveAt: z.ZodCoercedDate<unknown>;
+        period: z.ZodEnum<typeof TimePeriods>;
+    }, z.core.$strip>], "kind">>;
+}, z.core.$strip>;
+export type BalanceSummary = z.infer<typeof balanceSummarySchema>;
+export declare const usageBucketSchema: z.ZodObject<{
+    startTimestamp: z.ZodNumber;
+    endTimestamp: z.ZodNumber;
+    credits: z.ZodNumber;
+}, z.core.$strip>;
+export type UsageBucket = z.infer<typeof usageBucketSchema>;
+export declare const usageResponseSchema: z.ZodObject<{
+    buckets: z.ZodArray<z.ZodObject<{
+        startTimestamp: z.ZodNumber;
+        endTimestamp: z.ZodNumber;
+        credits: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type UsageResponse = z.infer<typeof usageResponseSchema>;
+export declare const billingContextResponseSchema: z.ZodObject<{
+    billingEnabled: z.ZodBoolean;
+    balance: z.ZodObject<{
+        planKey: z.ZodEnum<typeof PlanKey>;
+        billingPeriod: z.ZodNullable<z.ZodEnum<typeof TimePeriods>>;
+        planCredits: z.ZodNumber;
+        consumedCredits: z.ZodNumber;
+        remainingCredits: z.ZodNumber;
+        totalCreditCapacity: z.ZodNumber;
+        periodStart: z.ZodCoercedDate<unknown>;
+        periodEnd: z.ZodCoercedDate<unknown>;
+        overageMode: z.ZodEnum<{
+            soft: "soft";
+            strict: "strict";
+        }>;
+        hardCap: z.ZodNumber;
+        canBuyTopups: z.ZodBoolean;
+        scheduledChange: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"cancel_to_free">;
+            effectiveAt: z.ZodCoercedDate<unknown>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"change_period">;
+            effectiveAt: z.ZodCoercedDate<unknown>;
+            period: z.ZodEnum<typeof TimePeriods>;
+        }, z.core.$strip>], "kind">>;
+    }, z.core.$strip>;
+    usage: z.ZodObject<{
+        buckets: z.ZodArray<z.ZodObject<{
+            startTimestamp: z.ZodNumber;
+            endTimestamp: z.ZodNumber;
+            credits: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type BillingContextResponse = z.infer<typeof billingContextResponseSchema>;
+export declare const completedEventUsageSchema: z.ZodObject<{
+    inputTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+    totalTokens: z.ZodNumber;
+    inputTokensDetails: z.ZodObject<{
+        cached_tokens: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type CompletedEventUsage = z.infer<typeof completedEventUsageSchema>;
+export declare const billingRunGateRequestBodySchema: z.ZodObject<{
+    organizationId: z.ZodString;
+}, z.core.$strip>;
+export type BillingRunGateRequestBody = z.infer<typeof billingRunGateRequestBodySchema>;
+export declare const billingChargeRunBaseBodySchema: z.ZodObject<{
+    organizationId: z.ZodString;
+    runId: z.ZodString;
+}, z.core.$strip>;
+export type BillingChargeRunBaseBody = z.infer<typeof billingChargeRunBaseBodySchema>;
+/** Acknowledgement from POST /billing/charge-run-base (credits debited for starting a run). */
+export declare const billingChargeRunBaseResponseSchema: z.ZodObject<{
+    runId: z.ZodString;
+    creditsCharged: z.ZodNumber;
+}, z.core.$strip>;
+export type BillingChargeRunBaseResponse = z.infer<typeof billingChargeRunBaseResponseSchema>;
+export declare const billingRecordLlmBodySchema: z.ZodObject<{
+    organizationId: z.ZodString;
+    runId: z.ZodString;
+    responseId: z.ZodString;
+    model: z.ZodObject<{
+        providerId: z.ZodEnum<{
+            anthropic: "anthropic";
+            openai: "openai";
+        }>;
+        modelId: z.ZodString;
+        value: z.ZodString;
+    }, z.core.$strip>;
+    usage: z.ZodObject<{
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        totalTokens: z.ZodNumber;
+        inputTokensDetails: z.ZodObject<{
+            cached_tokens: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type BillingRecordLlmBody = z.infer<typeof billingRecordLlmBodySchema>;
+/** Acknowledgement from POST /billing/record-llm (credits debited for model usage). */
+export declare const billingRecordLlmResponseSchema: z.ZodObject<{
+    responseId: z.ZodString;
+    creditsCharged: z.ZodNumber;
+}, z.core.$strip>;
+export type BillingRecordLlmResponse = z.infer<typeof billingRecordLlmResponseSchema>;
+export declare const billingRecordLlmPayloadSchema: z.ZodObject<{
+    usage: z.ZodObject<{
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        totalTokens: z.ZodNumber;
+        inputTokensDetails: z.ZodObject<{
+            cached_tokens: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    model: z.ZodObject<{
+        providerId: z.ZodEnum<{
+            anthropic: "anthropic";
+            openai: "openai";
+        }>;
+        modelId: z.ZodString;
+        value: z.ZodString;
+    }, z.core.$strip>;
+    responseId: z.ZodString;
+}, z.core.$strip>;
+export type BillingRecordLlmPayload = z.infer<typeof billingRecordLlmPayloadSchema>;
+export declare const billingCacheInvalidationBodySchema: z.ZodObject<{
+    organizationId: z.ZodString;
+}, z.core.$strip>;
+export type BillingCacheInvalidationBody = z.infer<typeof billingCacheInvalidationBodySchema>;
+export declare const billingCheckoutPlanBodySchema: z.ZodObject<{
+    kind: z.ZodLiteral<"plan">;
+    planKey: z.ZodEnum<typeof PlanKey>;
+    period: z.ZodEnum<typeof TimePeriods>;
+}, z.core.$strip>;
+export type BillingCheckoutPlanBody = z.infer<typeof billingCheckoutPlanBodySchema>;
+export declare const billingCheckoutTopupBodySchema: z.ZodObject<{
+    kind: z.ZodLiteral<"topup">;
+    packCredits: z.ZodEnum<typeof SupportedTopUps>;
+}, z.core.$strip>;
+export type BillingCheckoutTopupBody = z.infer<typeof billingCheckoutTopupBodySchema>;
+export declare const billingCheckoutRequestBodySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"plan">;
+    planKey: z.ZodEnum<typeof PlanKey>;
+    period: z.ZodEnum<typeof TimePeriods>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"topup">;
+    packCredits: z.ZodEnum<typeof SupportedTopUps>;
+}, z.core.$strip>], "kind">;
+export type BillingCheckoutRequestBody = z.infer<typeof billingCheckoutRequestBodySchema>;
+export declare const billingChangeCancelBodySchema: z.ZodObject<{
+    kind: z.ZodLiteral<"cancel_to_free">;
+}, z.core.$strip>;
+export declare const billingChangePeriodBodySchema: z.ZodObject<{
+    kind: z.ZodLiteral<"change_period">;
+    planKey: z.ZodEnum<typeof PlanKey>;
+    period: z.ZodEnum<typeof TimePeriods>;
+}, z.core.$strip>;
+export declare const billingChangeRequestBodySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"cancel_to_free">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"change_period">;
+    planKey: z.ZodEnum<typeof PlanKey>;
+    period: z.ZodEnum<typeof TimePeriods>;
+}, z.core.$strip>], "kind">;
+export type BillingChangeRequestBody = z.infer<typeof billingChangeRequestBodySchema>;
+export declare const billingOverageModePatchBodySchema: z.ZodObject<{
+    mode: z.ZodEnum<{
+        soft: "soft";
+        strict: "strict";
+    }>;
+}, z.core.$strip>;
+export type BillingOverageModePatchBody = z.infer<typeof billingOverageModePatchBodySchema>;
+export declare const billingPortalSessionRequestBodySchema: z.ZodObject<{}, z.core.$strict>;
+export type BillingPortalSessionRequestBody = z.infer<typeof billingPortalSessionRequestBodySchema>;
+export declare const billingContextQuerySchema: z.ZodObject<{
+    start: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+    end: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+}, z.core.$strip>;
+export type BillingContextQuery = z.infer<typeof billingContextQuerySchema>;
+export declare const getOrCreateCustomerRequestBodySchema: z.ZodObject<{}, z.core.$strict>;
+export type GetOrCreateCustomerRequestBody = z.infer<typeof getOrCreateCustomerRequestBodySchema>;
+export declare const billingStripeRedirectResponseSchema: z.ZodObject<{
+    url: z.ZodString;
+}, z.core.$strip>;
+export type BillingStripeRedirectResponse = z.infer<typeof billingStripeRedirectResponseSchema>;
+export declare const setOverageModeResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+}, z.core.$strip>;
+export type SetOverageModeResponse = z.infer<typeof setOverageModeResponseSchema>;
+export declare const billingChangeResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    scheduledChange: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"cancel_to_free">;
+        effectiveAt: z.ZodCoercedDate<unknown>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"change_period">;
+        effectiveAt: z.ZodCoercedDate<unknown>;
+        period: z.ZodEnum<typeof TimePeriods>;
+    }, z.core.$strip>], "kind">>;
+}, z.core.$strip>;
+export type BillingChangeResponse = z.infer<typeof billingChangeResponseSchema>;
+export declare const runGateDenyReasonSchema: z.ZodEnum<{
+    credits_exhausted: "credits_exhausted";
+    subscription_past_due: "subscription_past_due";
+    no_subscription: "no_subscription";
+}>;
+export type RunGateDenyReason = z.infer<typeof runGateDenyReasonSchema>;
+export declare const runGateAllowSchema: z.ZodObject<{
+    allow: z.ZodLiteral<true>;
+}, z.core.$strip>;
+export declare const runGateDenySchema: z.ZodObject<{
+    allow: z.ZodLiteral<false>;
+    reason: z.ZodEnum<{
+        credits_exhausted: "credits_exhausted";
+        subscription_past_due: "subscription_past_due";
+        no_subscription: "no_subscription";
+    }>;
+}, z.core.$strip>;
+export declare const runGateDecisionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    allow: z.ZodLiteral<true>;
+}, z.core.$strip>, z.ZodObject<{
+    allow: z.ZodLiteral<false>;
+    reason: z.ZodEnum<{
+        credits_exhausted: "credits_exhausted";
+        subscription_past_due: "subscription_past_due";
+        no_subscription: "no_subscription";
+    }>;
+}, z.core.$strip>], "allow">;
+export type RunGateDecision = z.infer<typeof runGateDecisionSchema>;
+export declare function parseRunGateDenyReason(raw: unknown): RunGateDenyReason;
+export declare const getOrCreateCustomerResponseSchema: z.ZodObject<{
+    customerId: z.ZodString;
+}, z.core.$strip>;
+export type GetOrCreateCustomerResponse = z.infer<typeof getOrCreateCustomerResponseSchema>;
+export declare const planSchema: z.ZodObject<{
+    key: z.ZodEnum<typeof PlanKey>;
+    name: z.ZodString;
+    monthlyBasePriceId: z.ZodNullable<z.ZodObject<{
+        live: z.ZodString;
+        test: z.ZodString;
+    }, z.core.$strip>>;
+    annualBasePriceId: z.ZodNullable<z.ZodObject<{
+        live: z.ZodString;
+        test: z.ZodString;
+    }, z.core.$strip>>;
+    overagePriceId: z.ZodNullable<z.ZodObject<{
+        live: z.ZodString;
+        test: z.ZodString;
+    }, z.core.$strip>>;
+    priceInUsdMonthly: z.ZodNullable<z.ZodNumber>;
+    priceInUsdMonthlyAnnual: z.ZodNullable<z.ZodNumber>;
+    includedCreditsPerMonth: z.ZodNumber;
+    markupPct: z.ZodNumber;
+    overageCentsPerCredit: z.ZodNumber;
+    hardCapMultiplier: z.ZodNumber;
+    defaultOverageMode: z.ZodEnum<{
+        soft: "soft";
+        strict: "strict";
+    }>;
+}, z.core.$strip>;
+export type Plan = z.infer<typeof planSchema>;
+export declare function isPurchasablePlan(plan: Plan): boolean;
+export declare const topUpSchema: z.ZodObject<{
+    credits: z.ZodEnum<typeof SupportedTopUps>;
+    priceInUsd: z.ZodNumber;
+    priceId: z.ZodObject<{
+        live: z.ZodString;
+        test: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type TopUp = z.infer<typeof topUpSchema>;
+export declare const billingCatalogResponseSchema: z.ZodObject<{
+    plans: z.ZodArray<z.ZodObject<{
+        key: z.ZodEnum<typeof PlanKey>;
+        name: z.ZodString;
+        monthlyBasePriceId: z.ZodNullable<z.ZodObject<{
+            live: z.ZodString;
+            test: z.ZodString;
+        }, z.core.$strip>>;
+        annualBasePriceId: z.ZodNullable<z.ZodObject<{
+            live: z.ZodString;
+            test: z.ZodString;
+        }, z.core.$strip>>;
+        overagePriceId: z.ZodNullable<z.ZodObject<{
+            live: z.ZodString;
+            test: z.ZodString;
+        }, z.core.$strip>>;
+        priceInUsdMonthly: z.ZodNullable<z.ZodNumber>;
+        priceInUsdMonthlyAnnual: z.ZodNullable<z.ZodNumber>;
+        includedCreditsPerMonth: z.ZodNumber;
+        markupPct: z.ZodNumber;
+        overageCentsPerCredit: z.ZodNumber;
+        hardCapMultiplier: z.ZodNumber;
+        defaultOverageMode: z.ZodEnum<{
+            soft: "soft";
+            strict: "strict";
+        }>;
+    }, z.core.$strip>>;
+    topUps: z.ZodArray<z.ZodObject<{
+        credits: z.ZodEnum<typeof SupportedTopUps>;
+        priceInUsd: z.ZodNumber;
+        priceId: z.ZodObject<{
+            live: z.ZodString;
+            test: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type BillingCatalogResponse = z.infer<typeof billingCatalogResponseSchema>;
+export declare const BILLING_SERVICE_JWT_ISSUER: "terse-api";
+export declare const BILLING_SERVICE_JWT_AUDIENCE: "terse-billing";
+export declare const BILLING_SERVICE_CALLBACK_JWT_ISSUER: "terse-billing";
+export declare const BILLING_SERVICE_CALLBACK_JWT_AUDIENCE: "terse-api";
+export declare const terseBillingJwtClaimsSchema: z.ZodObject<{
+    organizationId: z.ZodString;
+}, z.core.$strip>;
+export type TerseBillingJwtClaims = z.infer<typeof terseBillingJwtClaimsSchema>;
+export declare const BillingRoutes: {
+    CATALOG: string;
+    CONTEXT: string;
+    CHECKOUT_SESSION: string;
+    CHANGE: string;
+    PORTAL_SESSION: string;
+    OVERAGE_MODE: string;
+    CUSTOMER: string;
+    RUN_GATE: string;
+    CHARGE_RUN_BASE: string;
+    RECORD_LLM: string;
+    CACHE_INVALIDATION: string;
+};
+export type BillingForbiddenErrorType = "CreditGateDeniedError" | "StripeError";
+export type BillingForbiddenErrorBody = {
+    type: BillingForbiddenErrorType;
+    reason?: string;
+};
+export declare class CreditGateDeniedError extends Error {
+    readonly reason: RunGateDenyReason;
+    constructor(reason: RunGateDenyReason);
+}
+export declare class StripeError extends Error {
+    readonly reason?: string;
+    constructor(message?: string, reason?: string);
+}
+export declare function billingErrorFromForbiddenBody(body: unknown): CreditGateDeniedError | StripeError | null;
+/** Parse JSON body from a billing HTTP 403 response */
+export declare function parseBillingForbiddenJson(raw: string): CreditGateDeniedError | StripeError | null;

package/dist/Billing.js

@@ -0,0 +1,227 @@
+import { z } from "zod";
+import billingRoutes from "./BillingRoutes.json" with { type: "json" };
+import { modelReferenceSchema } from "./ModelRegistry.js";
+export var PlanKey;
+(function (PlanKey) {
+    PlanKey["FREE"] = "free";
+    PlanKey["PRO"] = "pro";
+})(PlanKey || (PlanKey = {}));
+export const planKeySchema = z.enum(PlanKey);
+export var TimePeriods;
+(function (TimePeriods) {
+    TimePeriods["MONTHLY"] = "monthly";
+    TimePeriods["YEARLY"] = "yearly";
+})(TimePeriods || (TimePeriods = {}));
+export const billingPeriodSchema = z.enum(TimePeriods);
+export var SupportedTopUps;
+(function (SupportedTopUps) {
+    SupportedTopUps[SupportedTopUps["TOPUP_10K"] = 10000] = "TOPUP_10K";
+})(SupportedTopUps || (SupportedTopUps = {}));
+export const supportedTopUpsSchema = z.enum(SupportedTopUps);
+export const envIdSchema = z.object({
+    live: z.string(),
+    test: z.string()
+});
+export const overageModeSchema = z.enum(["soft", "strict"]);
+export const DEFAULT_OVERAGE_CAP_MULTIPLIER = 2;
+export const DEFAULT_OVERAGE_MODE = "strict";
+export const billingScheduledChangeSchema = z.discriminatedUnion("kind", [
+    z.object({
+        kind: z.literal("cancel_to_free"),
+        effectiveAt: z.coerce.date()
+    }),
+    z.object({
+        kind: z.literal("change_period"),
+        effectiveAt: z.coerce.date(),
+        period: billingPeriodSchema
+    })
+]);
+export const balanceSummarySchema = z.object({
+    planKey: planKeySchema,
+    billingPeriod: billingPeriodSchema.nullable(),
+    planCredits: z.number(),
+    consumedCredits: z.number(),
+    remainingCredits: z.number(),
+    totalCreditCapacity: z.number(),
+    periodStart: z.coerce.date(),
+    periodEnd: z.coerce.date(),
+    overageMode: overageModeSchema,
+    hardCap: z.number(),
+    canBuyTopups: z.boolean(),
+    scheduledChange: billingScheduledChangeSchema.nullable()
+});
+export const usageBucketSchema = z.object({
+    startTimestamp: z.number(),
+    endTimestamp: z.number(),
+    credits: z.number()
+});
+export const usageResponseSchema = z.object({
+    buckets: z.array(usageBucketSchema)
+});
+export const billingContextResponseSchema = z.object({
+    billingEnabled: z.boolean(),
+    balance: balanceSummarySchema,
+    usage: usageResponseSchema
+});
+export const completedEventUsageSchema = z.object({
+    inputTokens: z.number().nonnegative(),
+    outputTokens: z.number().nonnegative(),
+    totalTokens: z.number().nonnegative(),
+    inputTokensDetails: z.object({
+        cached_tokens: z.number().nonnegative()
+    })
+});
+export const billingRunGateRequestBodySchema = z.object({
+    organizationId: z.string().min(1)
+});
+export const billingChargeRunBaseBodySchema = billingRunGateRequestBodySchema.extend({
+    runId: z.string().min(1)
+});
+/** Acknowledgement from POST /billing/charge-run-base (credits debited for starting a run). */
+export const billingChargeRunBaseResponseSchema = z.object({
+    runId: z.string().min(1),
+    creditsCharged: z.number().nonnegative()
+});
+export const billingRecordLlmBodySchema = z.object({
+    organizationId: z.string().min(1),
+    runId: z.string().min(1),
+    responseId: z.string().min(1),
+    model: modelReferenceSchema,
+    usage: completedEventUsageSchema
+});
+/** Acknowledgement from POST /billing/record-llm (credits debited for model usage). */
+export const billingRecordLlmResponseSchema = z.object({
+    responseId: z.string().min(1),
+    creditsCharged: z.number().nonnegative()
+});
+export const billingRecordLlmPayloadSchema = billingRecordLlmBodySchema.pick({
+    responseId: true,
+    model: true,
+    usage: true
+});
+export const billingCacheInvalidationBodySchema = z.object({
+    organizationId: z.string().min(1)
+});
+export const billingCheckoutPlanBodySchema = z.object({
+    kind: z.literal("plan"),
+    planKey: planKeySchema,
+    period: billingPeriodSchema
+});
+export const billingCheckoutTopupBodySchema = z.object({
+    kind: z.literal("topup"),
+    packCredits: supportedTopUpsSchema
+});
+export const billingCheckoutRequestBodySchema = z.discriminatedUnion("kind", [billingCheckoutPlanBodySchema, billingCheckoutTopupBodySchema]);
+export const billingChangeCancelBodySchema = z.object({ kind: z.literal("cancel_to_free") });
+export const billingChangePeriodBodySchema = z.object({
+    kind: z.literal("change_period"),
+    planKey: planKeySchema,
+    period: billingPeriodSchema
+});
+export const billingChangeRequestBodySchema = z.discriminatedUnion("kind", [billingChangeCancelBodySchema, billingChangePeriodBodySchema]);
+export const billingOverageModePatchBodySchema = z.object({
+    mode: overageModeSchema
+});
+export const billingPortalSessionRequestBodySchema = z.object({}).strict();
+export const billingContextQuerySchema = z.object({
+    start: z.coerce.date().optional(),
+    end: z.coerce.date().optional()
+});
+export const getOrCreateCustomerRequestBodySchema = z.object({}).strict();
+export const billingStripeRedirectResponseSchema = z.object({
+    url: z.string()
+});
+export const setOverageModeResponseSchema = z.object({
+    ok: z.literal(true)
+});
+export const billingChangeResponseSchema = z.object({
+    ok: z.literal(true),
+    scheduledChange: billingScheduledChangeSchema.nullable()
+});
+export const runGateDenyReasonSchema = z.enum(["credits_exhausted", "subscription_past_due", "no_subscription"]);
+export const runGateAllowSchema = z.object({ allow: z.literal(true) });
+export const runGateDenySchema = z.object({
+    allow: z.literal(false),
+    reason: runGateDenyReasonSchema
+});
+export const runGateDecisionSchema = z.discriminatedUnion("allow", [runGateAllowSchema, runGateDenySchema]);
+export function parseRunGateDenyReason(raw) {
+    const parsed = runGateDenyReasonSchema.safeParse(raw);
+    return parsed.success ? parsed.data : "credits_exhausted";
+}
+export const getOrCreateCustomerResponseSchema = z.object({
+    customerId: z.string()
+});
+export const planSchema = z.object({
+    key: planKeySchema,
+    name: z.string(),
+    monthlyBasePriceId: envIdSchema.nullable(),
+    annualBasePriceId: envIdSchema.nullable(),
+    overagePriceId: envIdSchema.nullable(),
+    priceInUsdMonthly: z.number().nullable(),
+    priceInUsdMonthlyAnnual: z.number().nullable(),
+    includedCreditsPerMonth: z.number(),
+    markupPct: z.number(),
+    overageCentsPerCredit: z.number(),
+    hardCapMultiplier: z.number(),
+    defaultOverageMode: overageModeSchema
+});
+export function isPurchasablePlan(plan) {
+    return !!(plan.monthlyBasePriceId || plan.annualBasePriceId);
+}
+export const topUpSchema = z.object({
+    credits: supportedTopUpsSchema,
+    priceInUsd: z.number(),
+    priceId: envIdSchema
+});
+export const billingCatalogResponseSchema = z.object({
+    plans: z.array(planSchema),
+    topUps: z.array(topUpSchema)
+});
+export const BILLING_SERVICE_JWT_ISSUER = "terse-api";
+export const BILLING_SERVICE_JWT_AUDIENCE = "terse-billing";
+export const BILLING_SERVICE_CALLBACK_JWT_ISSUER = "terse-billing";
+export const BILLING_SERVICE_CALLBACK_JWT_AUDIENCE = "terse-api";
+export const terseBillingJwtClaimsSchema = z.object({
+    organizationId: z.string().min(1)
+});
+export const BillingRoutes = billingRoutes;
+export class CreditGateDeniedError extends Error {
+    reason;
+    constructor(reason) {
+        super(`Credit gate denied: ${reason}`);
+        this.name = "CreditGateDeniedError";
+        this.reason = reason;
+    }
+}
+export class StripeError extends Error {
+    reason;
+    constructor(message, reason) {
+        super(message ?? reason ?? "Billing provider error");
+        this.name = "StripeError";
+        this.reason = reason;
+    }
+}
+export function billingErrorFromForbiddenBody(body) {
+    if (!body || typeof body !== "object")
+        return null;
+    const o = body;
+    const t = o.type ?? o.errorType;
+    if (t === "CreditGateDeniedError") {
+        return new CreditGateDeniedError(parseRunGateDenyReason(o.reason));
+    }
+    if (t === "StripeError") {
+        const reason = typeof o.reason === "string" ? o.reason : undefined;
+        return new StripeError(reason, reason);
+    }
+    return null;
+}
+/** Parse JSON body from a billing HTTP 403 response */
+export function parseBillingForbiddenJson(raw) {
+    try {
+        return billingErrorFromForbiddenBody(JSON.parse(raw));
+    }
+    catch {
+        return null;
+    }
+}

package/dist/BillingRoutes.json

@@ -0,0 +1,13 @@
+{
+    "CATALOG": "/billing/catalog",
+    "CONTEXT": "/billing/context",
+    "CHECKOUT_SESSION": "/billing/checkout-session",
+    "CHANGE": "/billing/change",
+    "PORTAL_SESSION": "/billing/portal-session",
+    "OVERAGE_MODE": "/billing/overage-mode",
+    "CUSTOMER": "/billing/customer",
+    "RUN_GATE": "/billing/run-gate",
+    "CHARGE_RUN_BASE": "/billing/charge-run-base",
+    "RECORD_LLM": "/billing/record-llm",
+    "CACHE_INVALIDATION": "/billing/cache-invalidation"
+}

package/dist/FrontendRoutes.json

@@ -17,7 +17,8 @@
         "RUN_HISTORY": "/app/agents/:id?tab=history&runId=:runId"
     },
     "PROJECTS": {
-        "BY_ID": "/app/projects/:id"
+        "BY_ID": "/app/projects/:id",
+        "DEPLOYS": "/app/projects/:id/deploys"
     },
     "HOME": "/app/home",
     "INTEGRATIONS": "/app/integrations",