@agen-ai/agent-protocol 0.2.4 → 0.2.5

package/dist/zod/accountQuota.d.ts

@@ -0,0 +1,265 @@
+import { z } from 'zod/v4';
+import { type AgentAccountQuotaSnapshot, type AgentAccountQuotaWindow } from '../accountQuota/types.js';
+export declare const AgentAccountQuotaApplicabilitySchema: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"account">;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"product">;
+    productId: z.ZodString;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"models">;
+    modelIds: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"unknown">;
+}, z.core.$strict>>], "kind">;
+export declare const AgentAccountQuotaPeriodSchema: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"rolling">;
+    durationSeconds: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"fixed">;
+    durationSeconds: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"unknown">;
+    durationSeconds: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"calendar">;
+    unit: z.ZodEnum<{
+        day: "day";
+        week: "week";
+        month: "month";
+        year: "year";
+    }>;
+    timeZone: z.ZodString;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"billing_cycle">;
+    unit: z.ZodEnum<{
+        unknown: "unknown";
+        month: "month";
+        year: "year";
+    }>;
+}, z.core.$strict>>], "kind">;
+export declare const AgentAccountQuotaMeasurementSchema: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"unknown">;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"percentage">;
+    usedPercent: z.ZodNumber;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"quantity">;
+    unit: z.ZodString;
+    used: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    remaining: z.ZodOptional<z.ZodNumber>;
+    usedPercent: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"money">;
+    currency: z.ZodString;
+    scale: z.ZodNumber;
+    usedMinorUnits: z.ZodOptional<z.ZodNumber>;
+    limitMinorUnits: z.ZodOptional<z.ZodNumber>;
+    remainingMinorUnits: z.ZodOptional<z.ZodNumber>;
+    usedPercent: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>>], "kind">;
+export declare const AgentAccountQuotaWindowPortableSchema: z.ZodReadonly<z.ZodObject<{
+    poolId: z.ZodString;
+    windowId: z.ZodString;
+    label: z.ZodString;
+    allowanceKind: z.ZodEnum<{
+        unknown: "unknown";
+        included: "included";
+        extra: "extra";
+        reserve: "reserve";
+    }>;
+    applicability: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"account">;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"product">;
+        productId: z.ZodString;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"models">;
+        modelIds: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"unknown">;
+    }, z.core.$strict>>], "kind">;
+    period: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"rolling">;
+        durationSeconds: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"fixed">;
+        durationSeconds: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"unknown">;
+        durationSeconds: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"calendar">;
+        unit: z.ZodEnum<{
+            day: "day";
+            week: "week";
+            month: "month";
+            year: "year";
+        }>;
+        timeZone: z.ZodString;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"billing_cycle">;
+        unit: z.ZodEnum<{
+            unknown: "unknown";
+            month: "month";
+            year: "year";
+        }>;
+    }, z.core.$strict>>], "kind">;
+    measurement: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"unknown">;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"percentage">;
+        usedPercent: z.ZodNumber;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"quantity">;
+        unit: z.ZodString;
+        used: z.ZodOptional<z.ZodNumber>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        remaining: z.ZodOptional<z.ZodNumber>;
+        usedPercent: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"money">;
+        currency: z.ZodString;
+        scale: z.ZodNumber;
+        usedMinorUnits: z.ZodOptional<z.ZodNumber>;
+        limitMinorUnits: z.ZodOptional<z.ZodNumber>;
+        remainingMinorUnits: z.ZodOptional<z.ZodNumber>;
+        usedPercent: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>], "kind">;
+    observedAt: z.ZodType<import("../index.js").AgentIsoDateTime, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIsoDateTime, unknown>>;
+    startsAt: z.ZodOptional<z.ZodType<import("../index.js").AgentIsoDateTime, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIsoDateTime, unknown>>>;
+    reset: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+        at: z.ZodType<import("../index.js").AgentIsoDateTime, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIsoDateTime, unknown>>;
+        precision: z.ZodEnum<{
+            reported: "reported";
+            estimated: "estimated";
+        }>;
+        observedAt: z.ZodType<import("../index.js").AgentIsoDateTime, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIsoDateTime, unknown>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>>;
+export declare const AgentAccountQuotaWindowSchema: z.ZodType<AgentAccountQuotaWindow>;
+export declare const AgentAccountQuotaSnapshotPortableSchema: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+    state: z.ZodLiteral<"available">;
+    completeness: z.ZodEnum<{
+        complete: "complete";
+        partial: "partial";
+    }>;
+    accountLabel: z.ZodOptional<z.ZodString>;
+    planLabel: z.ZodOptional<z.ZodString>;
+    windows: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        poolId: z.ZodString;
+        windowId: z.ZodString;
+        label: z.ZodString;
+        allowanceKind: z.ZodEnum<{
+            unknown: "unknown";
+            included: "included";
+            extra: "extra";
+            reserve: "reserve";
+        }>;
+        applicability: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"account">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"product">;
+            productId: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"models">;
+            modelIds: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"unknown">;
+        }, z.core.$strict>>], "kind">;
+        period: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"rolling">;
+            durationSeconds: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"fixed">;
+            durationSeconds: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"unknown">;
+            durationSeconds: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"calendar">;
+            unit: z.ZodEnum<{
+                day: "day";
+                week: "week";
+                month: "month";
+                year: "year";
+            }>;
+            timeZone: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"billing_cycle">;
+            unit: z.ZodEnum<{
+                unknown: "unknown";
+                month: "month";
+                year: "year";
+            }>;
+        }, z.core.$strict>>], "kind">;
+        measurement: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"unknown">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"percentage">;
+            usedPercent: z.ZodNumber;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"quantity">;
+            unit: z.ZodString;
+            used: z.ZodOptional<z.ZodNumber>;
+            limit: z.ZodOptional<z.ZodNumber>;
+            remaining: z.ZodOptional<z.ZodNumber>;
+            usedPercent: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"money">;
+            currency: z.ZodString;
+            scale: z.ZodNumber;
+            usedMinorUnits: z.ZodOptional<z.ZodNumber>;
+            limitMinorUnits: z.ZodOptional<z.ZodNumber>;
+            remainingMinorUnits: z.ZodOptional<z.ZodNumber>;
+            usedPercent: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>], "kind">;
+        observedAt: z.ZodType<import("../index.js").AgentIsoDateTime, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIsoDateTime, unknown>>;
+        startsAt: z.ZodOptional<z.ZodType<import("../index.js").AgentIsoDateTime, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIsoDateTime, unknown>>>;
+        reset: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+            at: z.ZodType<import("../index.js").AgentIsoDateTime, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIsoDateTime, unknown>>;
+            precision: z.ZodEnum<{
+                reported: "reported";
+                estimated: "estimated";
+            }>;
+            observedAt: z.ZodType<import("../index.js").AgentIsoDateTime, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIsoDateTime, unknown>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>>>;
+    allowance: z.ZodReadonly<z.ZodObject<{
+        included: z.ZodEnum<{
+            unknown: "unknown";
+            allowed: "allowed";
+            exhausted: "exhausted";
+        }>;
+        extra: z.ZodEnum<{
+            unknown: "unknown";
+            allowed: "allowed";
+            unavailable: "unavailable";
+        }>;
+        reserve: z.ZodEnum<{
+            unknown: "unknown";
+            allowed: "allowed";
+            unavailable: "unavailable";
+        }>;
+    }, z.core.$strict>>;
+    schemaVersion: z.ZodLiteral<1>;
+    sourceId: z.ZodString;
+    observedAt: z.ZodType<import("../index.js").AgentIsoDateTime, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIsoDateTime, unknown>>;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    state: z.ZodLiteral<"authentication_required">;
+    schemaVersion: z.ZodLiteral<1>;
+    sourceId: z.ZodString;
+    observedAt: z.ZodType<import("../index.js").AgentIsoDateTime, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIsoDateTime, unknown>>;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    state: z.ZodLiteral<"inapplicable">;
+    schemaVersion: z.ZodLiteral<1>;
+    sourceId: z.ZodString;
+    observedAt: z.ZodType<import("../index.js").AgentIsoDateTime, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIsoDateTime, unknown>>;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    state: z.ZodLiteral<"temporarily_unavailable">;
+    schemaVersion: z.ZodLiteral<1>;
+    sourceId: z.ZodString;
+    observedAt: z.ZodType<import("../index.js").AgentIsoDateTime, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIsoDateTime, unknown>>;
+}, z.core.$strict>>], "state">;
+export declare const AgentAccountQuotaSnapshotSchema: z.ZodType<AgentAccountQuotaSnapshot>;
+//# sourceMappingURL=accountQuota.d.ts.map

package/dist/zod/accountQuota.js

@@ -0,0 +1,155 @@
+import { z } from "zod/v4";
+import {
+  AGENT_ACCOUNT_QUOTA_MAX_BYTES,
+  AGENT_ACCOUNT_QUOTA_MAX_LABEL_LENGTH,
+  AGENT_ACCOUNT_QUOTA_MAX_SCOPE_IDS,
+  AGENT_ACCOUNT_QUOTA_MAX_WINDOWS,
+  AGENT_ACCOUNT_QUOTA_SCHEMA_VERSION
+} from "../accountQuota/types.js";
+import { agentProtocolSerializedJsonBytes } from "../foundation/types.js";
+import {
+  AgentCanonicalIdValueSchema,
+  AgentIsoDateTimeSchema,
+  createAgentCanonicalOpaqueStringSchema,
+  withAcyclicProtocolInput
+} from "./foundation.js";
+const LabelSchema = createAgentCanonicalOpaqueStringSchema(
+  AGENT_ACCOUNT_QUOTA_MAX_LABEL_LENGTH,
+  "Quota labels must be canonical and contain no control characters."
+);
+const NonnegativeQuantitySchema = z.number().finite().min(0).max(Number.MAX_SAFE_INTEGER);
+const MinorUnitsSchema = z.number().int().min(0).max(Number.MAX_SAFE_INTEGER);
+const DurationSchema = z.number().int().positive().max(Number.MAX_SAFE_INTEGER);
+const AgentAccountQuotaApplicabilitySchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("account") }).strict().readonly(),
+  z.object({ kind: z.literal("product"), productId: AgentCanonicalIdValueSchema }).strict().readonly(),
+  z.object({
+    kind: z.literal("models"),
+    modelIds: z.array(AgentCanonicalIdValueSchema).min(1).max(AGENT_ACCOUNT_QUOTA_MAX_SCOPE_IDS).readonly()
+  }).strict().readonly(),
+  z.object({ kind: z.literal("unknown") }).strict().readonly()
+]);
+const AgentAccountQuotaPeriodSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("rolling"), durationSeconds: DurationSchema.optional() }).strict().readonly(),
+  z.object({ kind: z.literal("fixed"), durationSeconds: DurationSchema.optional() }).strict().readonly(),
+  z.object({ kind: z.literal("unknown"), durationSeconds: DurationSchema.optional() }).strict().readonly(),
+  z.object({
+    kind: z.literal("calendar"),
+    unit: z.enum(["day", "week", "month", "year"]),
+    timeZone: LabelSchema
+  }).strict().readonly(),
+  z.object({ kind: z.literal("billing_cycle"), unit: z.enum(["month", "year", "unknown"]) }).strict().readonly()
+]);
+const AgentAccountQuotaMeasurementSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("unknown") }).strict().readonly(),
+  z.object({ kind: z.literal("percentage"), usedPercent: NonnegativeQuantitySchema }).strict().readonly(),
+  z.object({
+    kind: z.literal("quantity"),
+    unit: LabelSchema,
+    used: NonnegativeQuantitySchema.optional(),
+    limit: NonnegativeQuantitySchema.optional(),
+    remaining: NonnegativeQuantitySchema.optional(),
+    usedPercent: NonnegativeQuantitySchema.optional()
+  }).strict().readonly(),
+  z.object({
+    kind: z.literal("money"),
+    currency: z.string().regex(/^[A-Z]{3}$/u),
+    scale: z.number().int().min(0).max(9),
+    usedMinorUnits: MinorUnitsSchema.optional(),
+    limitMinorUnits: MinorUnitsSchema.optional(),
+    remainingMinorUnits: MinorUnitsSchema.optional(),
+    usedPercent: NonnegativeQuantitySchema.optional()
+  }).strict().readonly()
+]);
+const AgentAccountQuotaWindowPortableSchema = z.object({
+  poolId: AgentCanonicalIdValueSchema,
+  windowId: AgentCanonicalIdValueSchema,
+  label: LabelSchema,
+  allowanceKind: z.enum(["included", "extra", "reserve", "unknown"]),
+  applicability: AgentAccountQuotaApplicabilitySchema,
+  period: AgentAccountQuotaPeriodSchema,
+  measurement: AgentAccountQuotaMeasurementSchema,
+  observedAt: AgentIsoDateTimeSchema,
+  startsAt: AgentIsoDateTimeSchema.optional(),
+  reset: z.object({
+    at: AgentIsoDateTimeSchema,
+    precision: z.enum(["reported", "estimated"]),
+    observedAt: AgentIsoDateTimeSchema
+  }).strict().readonly().optional()
+}).strict().readonly();
+function validateWindow(window, context, prefix = []) {
+  if (window.applicability.kind === "models" && new Set(window.applicability.modelIds).size !== window.applicability.modelIds.length) {
+    context.addIssue({ code: "custom", path: [...prefix, "applicability", "modelIds"], message: "Model applicability IDs must be unique." });
+  }
+  const measurement = window.measurement;
+  if (measurement.kind === "quantity" && measurement.used === void 0 && measurement.limit === void 0 && measurement.remaining === void 0) {
+    context.addIssue({ code: "custom", path: [...prefix, "measurement"], message: "A quantity measurement requires a reported quantity." });
+  }
+  if (measurement.kind === "money" && measurement.usedMinorUnits === void 0 && measurement.limitMinorUnits === void 0 && measurement.remainingMinorUnits === void 0) {
+    context.addIssue({ code: "custom", path: [...prefix, "measurement"], message: "A money measurement requires a reported exact amount." });
+  }
+  if (window.startsAt && window.reset && Date.parse(window.startsAt) >= Date.parse(window.reset.at)) {
+    context.addIssue({ code: "custom", path: [...prefix, "reset", "at"], message: "A period reset must follow its start." });
+  }
+  if (window.reset && Date.parse(window.reset.observedAt) > Date.parse(window.observedAt)) {
+    context.addIssue({ code: "custom", path: [...prefix, "reset", "observedAt"], message: "Reset evidence cannot be newer than the window observation." });
+  }
+}
+const AgentAccountQuotaWindowSchema = withAcyclicProtocolInput(AgentAccountQuotaWindowPortableSchema, {
+  maxDepth: 6,
+  maxCollectionLength: AGENT_ACCOUNT_QUOTA_MAX_SCOPE_IDS
+}).superRefine(validateWindow);
+const snapshotBase = {
+  schemaVersion: z.literal(AGENT_ACCOUNT_QUOTA_SCHEMA_VERSION),
+  sourceId: AgentCanonicalIdValueSchema,
+  observedAt: AgentIsoDateTimeSchema
+};
+const AgentAccountQuotaSnapshotPortableSchema = z.discriminatedUnion("state", [
+  z.object({
+    ...snapshotBase,
+    state: z.literal("available"),
+    completeness: z.enum(["complete", "partial"]),
+    accountLabel: LabelSchema.optional(),
+    planLabel: LabelSchema.optional(),
+    windows: z.array(AgentAccountQuotaWindowPortableSchema).max(AGENT_ACCOUNT_QUOTA_MAX_WINDOWS).readonly(),
+    allowance: z.object({
+      included: z.enum(["allowed", "exhausted", "unknown"]),
+      extra: z.enum(["allowed", "unavailable", "unknown"]),
+      reserve: z.enum(["allowed", "unavailable", "unknown"])
+    }).strict().readonly()
+  }).strict().readonly(),
+  z.object({ ...snapshotBase, state: z.literal("authentication_required") }).strict().readonly(),
+  z.object({ ...snapshotBase, state: z.literal("inapplicable") }).strict().readonly(),
+  z.object({ ...snapshotBase, state: z.literal("temporarily_unavailable") }).strict().readonly()
+]);
+const AgentAccountQuotaSnapshotSchema = withAcyclicProtocolInput(AgentAccountQuotaSnapshotPortableSchema, {
+  maxDepth: 8,
+  maxCollectionLength: AGENT_ACCOUNT_QUOTA_MAX_WINDOWS
+}).superRefine((snapshot, context) => {
+  if (agentProtocolSerializedJsonBytes(snapshot) > AGENT_ACCOUNT_QUOTA_MAX_BYTES) {
+    context.addIssue({ code: "custom", message: "Account quota snapshot exceeds its serialized byte limit." });
+  }
+  if (snapshot.state !== "available") return;
+  const identities = /* @__PURE__ */ new Map();
+  snapshot.windows.forEach((window, index) => {
+    const windows = identities.get(window.poolId) ?? /* @__PURE__ */ new Set();
+    if (windows.has(window.windowId)) {
+      context.addIssue({ code: "custom", path: ["windows", index, "windowId"], message: "Window IDs must be unique within each pool." });
+    }
+    windows.add(window.windowId);
+    identities.set(window.poolId, windows);
+    validateWindow(window, context, ["windows", index]);
+    if (Date.parse(window.observedAt) > Date.parse(snapshot.observedAt)) {
+      context.addIssue({ code: "custom", path: ["windows", index, "observedAt"], message: "Window evidence cannot be newer than its snapshot." });
+    }
+  });
+});
+export {
+  AgentAccountQuotaApplicabilitySchema,
+  AgentAccountQuotaMeasurementSchema,
+  AgentAccountQuotaPeriodSchema,
+  AgentAccountQuotaSnapshotPortableSchema,
+  AgentAccountQuotaSnapshotSchema,
+  AgentAccountQuotaWindowPortableSchema,
+  AgentAccountQuotaWindowSchema
+};

package/dist/zod/events.d.ts

@@ -531,10 +531,10 @@ export declare const AgentEventPortableSchema: z.ZodDiscriminatedUnion<[z.ZodRea
                 archive: "archive";
             }>;
             status: z.ZodEnum<{
+                unavailable: "unavailable";
+                available: "available";
                 pending: "pending";
                 expired: "expired";
-                available: "available";
-                unavailable: "unavailable";
             }>;
             displayName: z.ZodString;
             producer: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{

package/dist/zod/foundation.d.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod/v4';
 import { type AgentArtifactId, type AgentApprovalOptionId, type AgentCollaborationId, type AgentConfigurationRevisionId, type AgentError, type AgentInstanceId, type AgentIntegrationId, type AgentIntegrationResourceId, type AgentIntegrationServerId, type AgentIntegrationToolId, type AgentIsoDateTime, type AgentItemId, type AgentJsonValue, type AgentManagedContentId, type AgentOperationId, type AgentOperationInvocationId, type AgentProviderConversationId, type AgentProviderHistoryAnchor, type AgentProviderItemRef, type AgentProviderKey, type AgentProviderRefs, type AgentProviderRequestRef, type AgentProviderTurnRef, type AgentRequestFieldId, type AgentRequestId, type AgentSessionId, type AgentGeneratedResourceId, type AgentTurnId } from '../foundation/types.js';
+export declare function createAgentCanonicalOpaqueStringSchema(maxLength: number, message: string): z.ZodString;
 export declare const AgentCanonicalIdValueSchema: z.ZodString;
 export declare function createAgentCanonicalNonBlankStringSchema(maxLength: number): z.ZodString;
 export declare const AgentCanonicalNonBlankTextSchema: z.ZodString;

package/dist/zod/foundation.js

@@ -13,10 +13,10 @@ import {
 } from "../foundation/types.js";
 const CANONICAL_OPAQUE_STRING_PATTERN = /^(?![\s\S]*[\u0000-\u001F\u007F-\u009F])\S(?:[\s\S]*\S)?$/u;
 const CANONICAL_NON_BLANK_STRING_PATTERN = /^(?:\S|\S[\s\S]*\S)$/u;
-function canonicalOpaqueStringSchema(maxLength, message) {
+function createAgentCanonicalOpaqueStringSchema(maxLength, message) {
   return z.string().min(1).max(maxLength).regex(CANONICAL_OPAQUE_STRING_PATTERN, message);
 }
-const AgentCanonicalIdValueSchema = canonicalOpaqueStringSchema(
+const AgentCanonicalIdValueSchema = createAgentCanonicalOpaqueStringSchema(
   AGENT_PROTOCOL_ID_MAX_LENGTH,
   "Opaque IDs must be canonical and contain no control or surrounding whitespace."
 );
@@ -28,7 +28,7 @@ function createAgentCanonicalNonBlankStringSchema(maxLength) {
 }
 const AgentCanonicalNonBlankTextSchema = createAgentCanonicalNonBlankStringSchema(AGENT_PROTOCOL_TEXT_MAX_LENGTH);
 const AgentCanonicalCodeSchema = createAgentCanonicalNonBlankStringSchema(AGENT_PROTOCOL_CODE_MAX_LENGTH);
-const ProviderReferenceSchema = canonicalOpaqueStringSchema(
+const ProviderReferenceSchema = createAgentCanonicalOpaqueStringSchema(
   AGENT_PROTOCOL_PROVIDER_REFERENCE_MAX_LENGTH,
   "Provider references must be canonical and contain no control or surrounding whitespace."
 );
@@ -221,5 +221,6 @@ export {
   AgentSessionIdSchema,
   AgentTurnIdSchema,
   createAgentCanonicalNonBlankStringSchema,
+  createAgentCanonicalOpaqueStringSchema,
   withAcyclicProtocolInput
 };

package/dist/zod/index.d.ts

@@ -12,4 +12,5 @@ export { AgentApprovalCapabilitySchema, AgentCapabilitiesSchema, } from './capab
 export { AgentArtifactDescriptorSchema } from './artifacts.js';
 export { AgentContextUsageSchema, AgentEventSchema } from './events.js';
 export type { AgentProtocolSchemaTypeAssertions } from './typeEquality.generated.js';
+export * from './accountQuota.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/zod/index.js

@@ -103,6 +103,7 @@ import {
 } from "./capabilities.js";
 import { AgentArtifactDescriptorSchema } from "./artifacts.js";
 import { AgentContextUsageSchema, AgentEventSchema } from "./events.js";
+export * from "./accountQuota.js";
 export {
   AgentApprovalCapabilitySchema,
   AgentApprovalOptionIdSchema,

package/dist/zod/integrations.d.ts

@@ -6,19 +6,19 @@ declare const AgentIntegrationDescriptorPortableSchema: z.ZodReadonly<z.ZodObjec
     kind: z.ZodLiteral<"mcp">;
     name: z.ZodString;
     status: z.ZodEnum<{
+        unavailable: "unavailable";
         starting: "starting";
         ready: "ready";
         degraded: "degraded";
-        unavailable: "unavailable";
     }>;
     servers: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
         serverId: z.ZodType<import("../index.js").AgentIntegrationServerId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIntegrationServerId, unknown>>;
         name: z.ZodString;
         status: z.ZodEnum<{
+            unavailable: "unavailable";
             starting: "starting";
             ready: "ready";
             degraded: "degraded";
-            unavailable: "unavailable";
         }>;
         tools: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
             toolId: z.ZodType<import("../index.js").AgentIntegrationToolId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIntegrationToolId, unknown>>;
@@ -43,19 +43,19 @@ export declare const AgentIntegrationCatalogPortableSchema: z.ZodReadonly<z.ZodO
         kind: z.ZodLiteral<"mcp">;
         name: z.ZodString;
         status: z.ZodEnum<{
+            unavailable: "unavailable";
             starting: "starting";
             ready: "ready";
             degraded: "degraded";
-            unavailable: "unavailable";
         }>;
         servers: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
             serverId: z.ZodType<import("../index.js").AgentIntegrationServerId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIntegrationServerId, unknown>>;
             name: z.ZodString;
             status: z.ZodEnum<{
+                unavailable: "unavailable";
                 starting: "starting";
                 ready: "ready";
                 degraded: "degraded";
-                unavailable: "unavailable";
             }>;
             tools: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
                 toolId: z.ZodType<import("../index.js").AgentIntegrationToolId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIntegrationToolId, unknown>>;

package/dist/zod/resources.d.ts

@@ -8,10 +8,10 @@ export declare const AgentGeneratedResourceDescriptorPortableSchema: z.ZodReadon
         archive: "archive";
     }>;
     status: z.ZodEnum<{
+        unavailable: "unavailable";
+        available: "available";
         pending: "pending";
         expired: "expired";
-        available: "available";
-        unavailable: "unavailable";
     }>;
     displayName: z.ZodString;
     producer: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{

package/dist/zod/typeEquality.generated.d.ts

@@ -1,4 +1,5 @@
 import type { z } from 'zod/v4';
+import type { AgentAccountQuotaSnapshot, AgentAccountQuotaWindow } from '../accountQuota/types.js';
 import type { AgentArtifactDescriptor } from '../artifacts/types.js';
 import type { AgentCapabilities } from '../capabilities/types.js';
 import type { AgentCollaborationControlInput, AgentCollaborationNode, AgentCollaborationSpawnInput } from '../collaboration/types.js';
@@ -12,6 +13,7 @@ import type { AgentRequest, AgentRequestResolution } from '../requests/types.js'
 import type { AgentGeneratedResourceDescriptor } from '../resources/types.js';
 import type { AgentSessionBinding, AgentSessionConfiguration, AgentSessionOpenInput } from '../sessions/types.js';
 import type { AgentItemSnapshot, AgentTurnInputContent, AgentTurnInterruptionInput, AgentTurnRunInput } from '../turns/types.js';
+import { AgentAccountQuotaSnapshotSchema, AgentAccountQuotaWindowSchema } from './accountQuota.js';
 import { AgentArtifactDescriptorSchema } from './artifacts.js';
 import { AgentCapabilitiesSchema } from './capabilities.js';
 import { AgentCollaborationControlInputSchema, AgentCollaborationNodeSchema, AgentCollaborationSpawnInputSchema } from './collaboration.js';
@@ -28,6 +30,10 @@ import { AgentItemSnapshotSchema, AgentTurnInputContentSchema, AgentTurnInterrup
 type Extends<Left, Right> = [Left] extends [Right] ? true : false;
 type Assert<Value extends true> = Value;
 export type AgentProtocolSchemaTypeAssertions = readonly [
+    Assert<Extends<z.output<typeof AgentAccountQuotaSnapshotSchema>, AgentAccountQuotaSnapshot>>,
+    Assert<Extends<AgentAccountQuotaSnapshot, z.output<typeof AgentAccountQuotaSnapshotSchema>>>,
+    Assert<Extends<z.output<typeof AgentAccountQuotaWindowSchema>, AgentAccountQuotaWindow>>,
+    Assert<Extends<AgentAccountQuotaWindow, z.output<typeof AgentAccountQuotaWindowSchema>>>,
     Assert<Extends<z.output<typeof AgentJsonValueSchema>, AgentJsonValue>>,
     Assert<Extends<AgentJsonValue, z.output<typeof AgentJsonValueSchema>>>,
     Assert<Extends<z.output<typeof AgentProviderRefsSchema>, AgentProviderRefs>>,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agen-ai/agent-protocol",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "private": false,
   "description": "Provider-neutral sessions, turns, requests, capabilities, artifacts, and events for coding-agent runtimes.",
   "type": "module",
@@ -76,11 +76,15 @@
       "types": "./dist/jsonSchema/index.d.ts",
       "import": "./dist/jsonSchema/index.js"
     },
-    "./package.json": "./package.json"
+    "./package.json": "./package.json",
+    "./account-quota": {
+      "types": "./dist/public/accountQuota.d.ts",
+      "import": "./dist/public/accountQuota.js"
+    }
   },
   "dependencies": {
     "zod": "4.4.3",
-    "@agen-ai/validation": "^0.2.4"
+    "@agen-ai/validation": "^0.2.5"
   },
   "devDependencies": {
     "ajv": "8.17.1",