@agen-ai/agent-protocol 0.2.4 → 0.3.0

package/dist/public/accountQuota.d.ts

@@ -0,0 +1,2 @@
+export * from '../accountQuota/index.js';
+//# sourceMappingURL=accountQuota.d.ts.map

package/dist/public/accountQuota.js

@@ -0,0 +1 @@
+export * from "../accountQuota/index.js";

package/dist/public/commands.d.ts

@@ -0,0 +1,2 @@
+export * from '../commands/index.js';
+//# sourceMappingURL=commands.d.ts.map

package/dist/public/commands.js

@@ -0,0 +1 @@
+export * from "../commands/index.js";

package/dist/public/effectiveContent.d.ts

@@ -0,0 +1,2 @@
+export * from '../effectiveContent/index.js';
+//# sourceMappingURL=effectiveContent.d.ts.map

package/dist/public/effectiveContent.js

@@ -0,0 +1 @@
+export * from "../effectiveContent/index.js";

package/dist/public/environment.d.ts

@@ -0,0 +1,2 @@
+export * from '../environment/index.js';
+//# sourceMappingURL=environment.d.ts.map

package/dist/public/environment.js

@@ -0,0 +1 @@
+export * from "../environment/index.js";

package/dist/public/extensions.d.ts

@@ -0,0 +1,2 @@
+export * from '../extensions/index.js';
+//# sourceMappingURL=extensions.d.ts.map

package/dist/public/extensions.js

@@ -0,0 +1 @@
+export * from "../extensions/index.js";

package/dist/public/index.d.ts

@@ -1,9 +1,14 @@
 export * from '../foundation/index.js';
+export * from '../accountQuota/index.js';
 export * from '../sessions/index.js';
 export * from '../turns/index.js';
 export * from '../requests/index.js';
 export * from '../operations/index.js';
 export * from '../managedContent/index.js';
+export * from '../effectiveContent/index.js';
+export * from '../commands/index.js';
+export * from '../extensions/index.js';
+export * from '../environment/index.js';
 export * from '../configuration/index.js';
 export * from '../integrations/index.js';
 export * from '../collaboration/index.js';

package/dist/public/index.js

@@ -1,9 +1,14 @@
 export * from "../foundation/index.js";
+export * from "../accountQuota/index.js";
 export * from "../sessions/index.js";
 export * from "../turns/index.js";
 export * from "../requests/index.js";
 export * from "../operations/index.js";
 export * from "../managedContent/index.js";
+export * from "../effectiveContent/index.js";
+export * from "../commands/index.js";
+export * from "../extensions/index.js";
+export * from "../environment/index.js";
 export * from "../configuration/index.js";
 export * from "../integrations/index.js";
 export * from "../collaboration/index.js";

package/dist/turns/parsers.d.ts

@@ -1,5 +1,5 @@
 import type { AgentProtocolParseResult } from '../foundation/index.js';
-import type { AgentItemSnapshot, AgentTurnInputContent, AgentTurnInterruptionInput, AgentTurnRunInput } from './types.js';
+import type { AgentItemSnapshot, AgentContentReferenceInputPart, AgentTurnInputContent, AgentTurnInterruptionInput, AgentTurnRunInput } from './types.js';
 export declare function parseAgentTurnInputContent(input: unknown): AgentTurnInputContent;
 export declare function safeParseAgentTurnInputContent(input: unknown): AgentProtocolParseResult<AgentTurnInputContent>;
 export declare function parseAgentTurnRunInput(input: unknown): AgentTurnRunInput;
@@ -8,4 +8,6 @@ export declare function parseAgentTurnInterruptionInput(input: unknown): AgentTu
 export declare function safeParseAgentTurnInterruptionInput(input: unknown): AgentProtocolParseResult<AgentTurnInterruptionInput>;
 export declare function parseAgentItemSnapshot(input: unknown): AgentItemSnapshot;
 export declare function safeParseAgentItemSnapshot(input: unknown): AgentProtocolParseResult<AgentItemSnapshot>;
+export declare function parseAgentContentReferenceInputPart(input: unknown): AgentContentReferenceInputPart;
+export declare function safeParseAgentContentReferenceInputPart(input: unknown): AgentProtocolParseResult<AgentContentReferenceInputPart>;
 //# sourceMappingURL=parsers.d.ts.map

package/dist/turns/parsers.js

@@ -1,6 +1,7 @@
 import { parseWithSchema, safeParseWithSchema } from "../internal/parsers.js";
 import {
   AgentItemSnapshotSchema,
+  AgentContentReferenceInputPartSchema,
   AgentTurnInputContentSchema,
   AgentTurnInterruptionInputSchema,
   AgentTurnRunInputSchema
@@ -29,11 +30,19 @@ function parseAgentItemSnapshot(input) {
 function safeParseAgentItemSnapshot(input) {
   return safeParseWithSchema(AgentItemSnapshotSchema, input);
 }
+function parseAgentContentReferenceInputPart(input) {
+  return parseWithSchema(AgentContentReferenceInputPartSchema, input);
+}
+function safeParseAgentContentReferenceInputPart(input) {
+  return safeParseWithSchema(AgentContentReferenceInputPartSchema, input);
+}
 export {
+  parseAgentContentReferenceInputPart,
   parseAgentItemSnapshot,
   parseAgentTurnInputContent,
   parseAgentTurnInterruptionInput,
   parseAgentTurnRunInput,
+  safeParseAgentContentReferenceInputPart,
   safeParseAgentItemSnapshot,
   safeParseAgentTurnInputContent,
   safeParseAgentTurnInterruptionInput,

package/dist/turns/types.d.ts

@@ -1,4 +1,4 @@
-import type { AgentError, AgentIsoDateTime, AgentItemId, AgentTurnId } from '../foundation/index.js';
+import type { AgentError, AgentEnvironmentId, AgentEffectiveContentId, AgentIsoDateTime, AgentItemId, AgentTurnId } from '../foundation/index.js';
 export interface AgentTextInputPart {
     readonly type: 'text';
     readonly text: string;
@@ -28,7 +28,18 @@ export interface AgentImageInputPart {
     readonly type: 'image';
     readonly source: AgentImageInputSource;
 }
-export type AgentTurnInputPart = AgentTextInputPart | AgentImageInputPart;
+export declare const AGENT_CONTENT_REFERENCES_MAX_LENGTH = 16;
+export declare const AGENT_CONTENT_REFERENCE_ARGUMENT_BYTES_LIMIT = 4096;
+export interface AgentContentReferenceInputPart {
+    readonly type: 'content_reference';
+    readonly environmentId: AgentEnvironmentId;
+    readonly environmentRevision: number;
+    readonly contentCatalogRevision: number;
+    readonly contentId: AgentEffectiveContentId;
+    readonly contentRevision: number;
+    readonly arguments?: string | undefined;
+}
+export type AgentTurnInputPart = AgentTextInputPart | AgentImageInputPart | AgentContentReferenceInputPart;
 export declare const AGENT_TURN_INTERACTION_MODES: readonly ["default", "plan"];
 export type AgentTurnInteractionMode = (typeof AGENT_TURN_INTERACTION_MODES)[number];
 export interface AgentTurnInputContent {

package/dist/turns/types.js

@@ -8,6 +8,8 @@ const AGENT_IMAGE_INPUT_SOURCE_KINDS = [
   "base64",
   "local_file"
 ];
+const AGENT_CONTENT_REFERENCES_MAX_LENGTH = 16;
+const AGENT_CONTENT_REFERENCE_ARGUMENT_BYTES_LIMIT = 4096;
 const AGENT_TURN_INTERACTION_MODES = ["default", "plan"];
 const AGENT_ITEM_KINDS = [
   "user_message",
@@ -79,6 +81,8 @@ const AGENT_FILE_CHANGE_KINDS = [
   "unknown"
 ];
 export {
+  AGENT_CONTENT_REFERENCES_MAX_LENGTH,
+  AGENT_CONTENT_REFERENCE_ARGUMENT_BYTES_LIMIT,
   AGENT_CONTENT_STREAM_KINDS,
   AGENT_CONTEXT_COMPACTION_DURATION_MAX_MILLISECONDS,
   AGENT_CONTEXT_COMPACTION_STATES,

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
+};