@agen-ai/agent-protocol 0.1.0 → 0.2.0

package/dist/requests/parsers.d.ts

@@ -1,9 +1,13 @@
 import { type AgentProtocolParseResult } from '../foundation/index.js';
-import type { AgentRequest, AgentRequestResolution } from './types.js';
+import type { AgentApprovalRequest, AgentApprovalResolution, AgentRequest, AgentRequestResolution } from './types.js';
 export declare function parseAgentRequest(input: unknown): AgentRequest;
+export declare function parseAgentApprovalRequest(input: unknown): AgentApprovalRequest;
+export declare function safeParseAgentApprovalRequest(input: unknown): AgentProtocolParseResult<AgentApprovalRequest>;
 export declare function safeParseAgentRequest(input: unknown): AgentProtocolParseResult<AgentRequest>;
 export declare function parseAgentRequestResolution(input: unknown): AgentRequestResolution;
 export declare function safeParseAgentRequestResolution(input: unknown): AgentProtocolParseResult<AgentRequestResolution>;
+export declare function parseAgentApprovalResolution(input: unknown): AgentApprovalResolution;
+export declare function safeParseAgentApprovalResolution(input: unknown): AgentProtocolParseResult<AgentApprovalResolution>;
 export declare function safeParseAgentRequestResolutionFor(requestInput: unknown, resolutionInput: unknown): AgentProtocolParseResult<AgentRequestResolution>;
 export declare function parseAgentRequestResolutionFor(requestInput: unknown, resolutionInput: unknown): AgentRequestResolution;
 //# sourceMappingURL=parsers.d.ts.map

package/dist/requests/parsers.js

@@ -3,12 +3,20 @@ import {
 } from "../foundation/index.js";
 import { parseWithSchema, safeParseWithSchema } from "../internal/parsers.js";
 import {
+  AgentApprovalRequestSchema,
+  AgentApprovalResolutionSchema,
   AgentRequestResolutionSchema,
   AgentRequestSchema
 } from "../zod/requests.js";
 function parseAgentRequest(input) {
   return parseWithSchema(AgentRequestSchema, input);
 }
+function parseAgentApprovalRequest(input) {
+  return parseWithSchema(AgentApprovalRequestSchema, input);
+}
+function safeParseAgentApprovalRequest(input) {
+  return safeParseWithSchema(AgentApprovalRequestSchema, input);
+}
 function safeParseAgentRequest(input) {
   return safeParseWithSchema(AgentRequestSchema, input);
 }
@@ -18,6 +26,12 @@ function parseAgentRequestResolution(input) {
 function safeParseAgentRequestResolution(input) {
   return safeParseWithSchema(AgentRequestResolutionSchema, input);
 }
+function parseAgentApprovalResolution(input) {
+  return parseWithSchema(AgentApprovalResolutionSchema, input);
+}
+function safeParseAgentApprovalResolution(input) {
+  return safeParseWithSchema(AgentApprovalResolutionSchema, input);
+}
 function issue(path, message) {
   return { code: "custom", path, message };
 }
@@ -77,6 +91,14 @@ function resolutionIssues(request, resolution) {
       "Resolution requestId must match the opened request."
     ));
   }
+  if (request.requestKind === "approval" && resolution.requestKind === "approval" && resolution.disposition === "selected" && !request.options.some(
+    (option) => option.optionId === resolution.optionId
+  )) {
+    issues.push(issue(
+      ["optionId"],
+      "Approval resolution must select an option declared by the request."
+    ));
+  }
   if (request.requestKind !== "elicitation" || resolution.requestKind !== "elicitation" || resolution.disposition !== "answered") {
     return issues;
   }
@@ -125,9 +147,13 @@ function parseAgentRequestResolutionFor(requestInput, resolutionInput) {
   throw new AgentProtocolValidationError(parsed.issues);
 }
 export {
+  parseAgentApprovalRequest,
+  parseAgentApprovalResolution,
   parseAgentRequest,
   parseAgentRequestResolution,
   parseAgentRequestResolutionFor,
+  safeParseAgentApprovalRequest,
+  safeParseAgentApprovalResolution,
   safeParseAgentRequest,
   safeParseAgentRequestResolution,
   safeParseAgentRequestResolutionFor

package/dist/requests/types.d.ts

@@ -1,4 +1,11 @@
-import type { AgentArtifactId, AgentIsoDateTime, AgentRequestFieldId, AgentRequestId } from '../foundation/index.js';
+import type { AgentApprovalOptionId, AgentArtifactId, AgentIsoDateTime, AgentItemId, AgentRequestFieldId, AgentRequestId } from '../foundation/index.js';
+export declare const AGENT_APPROVAL_PERSISTENCES: readonly ["once", "session", "workspace"];
+export declare const AGENT_APPROVAL_SCOPE_KINDS: readonly ["exact_action", "command_pattern", "domain", "tool", "server", "all_edits"];
+export declare const AGENT_APPROVAL_OPTIONS_MAX_LENGTH = 16;
+export declare const AGENT_APPROVAL_LABEL_MAX_LENGTH = 120;
+export declare const AGENT_APPROVAL_DESCRIPTION_MAX_LENGTH = 1000;
+export type AgentApprovalPersistence = (typeof AGENT_APPROVAL_PERSISTENCES)[number];
+export type AgentApprovalScopeKind = (typeof AGENT_APPROVAL_SCOPE_KINDS)[number];
 interface AgentApprovalSubjectBase {
     readonly title: string;
     readonly description?: string;
@@ -8,13 +15,24 @@ export type AgentApprovalSubject = (AgentApprovalSubjectBase & Readonly<{
     artifactId: AgentArtifactId;
 }>) | (AgentApprovalSubjectBase & Readonly<{
     kind: 'command' | 'file_change' | 'tool' | 'other';
-    artifactId?: never;
+    itemId: AgentItemId;
 }>);
+export interface AgentApprovalOption {
+    readonly optionId: AgentApprovalOptionId;
+    readonly label: string;
+    readonly description?: string;
+    readonly decision: 'approved' | 'denied';
+    readonly persistence: AgentApprovalPersistence;
+    readonly scope: Readonly<{
+        kind: AgentApprovalScopeKind;
+    }>;
+}
 export interface AgentApprovalRequest {
     readonly requestKind: 'approval';
     readonly requestId: AgentRequestId;
     readonly prompt: string;
     readonly subject: AgentApprovalSubject;
+    readonly options: readonly AgentApprovalOption[];
     readonly expiresAt?: AgentIsoDateTime;
 }
 export interface AgentRequestChoice {
@@ -50,11 +68,16 @@ export interface AgentElicitationRequest {
     readonly expiresAt?: AgentIsoDateTime;
 }
 export type AgentRequest = AgentApprovalRequest | AgentElicitationRequest;
-export interface AgentApprovalResolution {
-    readonly requestKind: 'approval';
-    readonly requestId: AgentRequestId;
-    readonly decision: 'approved' | 'denied' | 'canceled';
-}
+export type AgentApprovalResolution = Readonly<{
+    requestKind: 'approval';
+    requestId: AgentRequestId;
+    disposition: 'selected';
+    optionId: AgentApprovalOptionId;
+}> | Readonly<{
+    requestKind: 'approval';
+    requestId: AgentRequestId;
+    disposition: 'canceled';
+}>;
 export interface AgentTextElicitationAnswer {
     readonly fieldId: AgentRequestFieldId;
     readonly kind: 'text';

package/dist/requests/types.js

@@ -0,0 +1,23 @@
+const AGENT_APPROVAL_PERSISTENCES = [
+  "once",
+  "session",
+  "workspace"
+];
+const AGENT_APPROVAL_SCOPE_KINDS = [
+  "exact_action",
+  "command_pattern",
+  "domain",
+  "tool",
+  "server",
+  "all_edits"
+];
+const AGENT_APPROVAL_OPTIONS_MAX_LENGTH = 16;
+const AGENT_APPROVAL_LABEL_MAX_LENGTH = 120;
+const AGENT_APPROVAL_DESCRIPTION_MAX_LENGTH = 1e3;
+export {
+  AGENT_APPROVAL_DESCRIPTION_MAX_LENGTH,
+  AGENT_APPROVAL_LABEL_MAX_LENGTH,
+  AGENT_APPROVAL_OPTIONS_MAX_LENGTH,
+  AGENT_APPROVAL_PERSISTENCES,
+  AGENT_APPROVAL_SCOPE_KINDS
+};

package/dist/turns/types.d.ts

@@ -54,6 +54,36 @@ export declare const AGENT_CONTENT_STREAM_KINDS: readonly ["assistant_text", "re
 export type AgentContentStreamKind = (typeof AGENT_CONTENT_STREAM_KINDS)[number];
 export type AgentTurnState = 'running' | 'waiting_for_request';
 export type AgentTurnOutcome = 'completed' | 'failed' | 'canceled' | 'expired';
+export declare const AGENT_CONTEXT_MEASUREMENT_SCOPES: readonly ["session", "materialization"];
+export declare const AGENT_CONTEXT_CUMULATIVE_USAGE_FIELDS: readonly ["inputTokens", "outputTokens", "cachedReadTokens", "cacheCreationTokens", "reasoningTokens", "modelCalls", "turns"];
+export declare const AGENT_CONTEXT_COMPACTION_STATES: readonly ["idle", "approaching", "in_progress"];
+export declare const AGENT_CONTEXT_COMPACTION_TRIGGERS: readonly ["automatic", "manual", "context_limit", "recovery", "unknown"];
+export declare const AGENT_CONTEXT_COMPACTION_SUMMARY_PREVIEW_MAX_LENGTH = 500;
+export declare const AGENT_CONTEXT_COMPACTION_DURATION_MAX_MILLISECONDS = 3600000;
+export type AgentContextMeasurementScope = (typeof AGENT_CONTEXT_MEASUREMENT_SCOPES)[number];
+export type AgentContextCumulativeUsageField = (typeof AGENT_CONTEXT_CUMULATIVE_USAGE_FIELDS)[number];
+export type AgentContextCompactionState = (typeof AGENT_CONTEXT_COMPACTION_STATES)[number];
+export type AgentContextCompactionTrigger = (typeof AGENT_CONTEXT_COMPACTION_TRIGGERS)[number];
+export interface AgentContextCumulativeUsage {
+    readonly inputTokens?: number;
+    readonly outputTokens?: number;
+    readonly cachedReadTokens?: number;
+    readonly cacheCreationTokens?: number;
+    readonly reasoningTokens?: number;
+    readonly modelCalls?: number;
+    readonly turns?: number;
+}
+export interface AgentContextCompactionPressure {
+    readonly state: AgentContextCompactionState;
+    readonly thresholdTokens?: number;
+}
+export interface AgentContextUsage {
+    readonly measurementScope: AgentContextMeasurementScope;
+    readonly usedTokens: number;
+    readonly maxTokens: number;
+    readonly cumulative?: AgentContextCumulativeUsage;
+    readonly compaction?: AgentContextCompactionPressure;
+}
 export interface AgentItemSnapshotBase {
     readonly itemId: AgentItemId;
     readonly status: AgentItemStatus;
@@ -74,6 +104,14 @@ export interface AgentPlanItemSnapshot extends AgentItemSnapshotBase {
 }
 export interface AgentContextCompactionItemSnapshot extends AgentItemSnapshotBase {
     readonly itemKind: 'context_compaction';
+    readonly details: AgentContextCompactionDetails;
+}
+export interface AgentContextCompactionDetails {
+    readonly trigger: AgentContextCompactionTrigger;
+    readonly beforeTokens?: number;
+    readonly afterTokens?: number;
+    readonly durationMs?: number;
+    readonly summaryPreview?: string;
 }
 export interface AgentUnknownItemSnapshot extends AgentItemSnapshotBase {
     readonly itemKind: 'unknown';

package/dist/turns/types.js

@@ -44,6 +44,33 @@ const AGENT_CONTENT_STREAM_KINDS = [
   "file_change_output",
   "unknown"
 ];
+const AGENT_CONTEXT_MEASUREMENT_SCOPES = [
+  "session",
+  "materialization"
+];
+const AGENT_CONTEXT_CUMULATIVE_USAGE_FIELDS = [
+  "inputTokens",
+  "outputTokens",
+  "cachedReadTokens",
+  "cacheCreationTokens",
+  "reasoningTokens",
+  "modelCalls",
+  "turns"
+];
+const AGENT_CONTEXT_COMPACTION_STATES = [
+  "idle",
+  "approaching",
+  "in_progress"
+];
+const AGENT_CONTEXT_COMPACTION_TRIGGERS = [
+  "automatic",
+  "manual",
+  "context_limit",
+  "recovery",
+  "unknown"
+];
+const AGENT_CONTEXT_COMPACTION_SUMMARY_PREVIEW_MAX_LENGTH = 500;
+const AGENT_CONTEXT_COMPACTION_DURATION_MAX_MILLISECONDS = 36e5;
 const AGENT_FILE_CHANGE_KINDS = [
   "created",
   "modified",
@@ -53,6 +80,12 @@ const AGENT_FILE_CHANGE_KINDS = [
 ];
 export {
   AGENT_CONTENT_STREAM_KINDS,
+  AGENT_CONTEXT_COMPACTION_DURATION_MAX_MILLISECONDS,
+  AGENT_CONTEXT_COMPACTION_STATES,
+  AGENT_CONTEXT_COMPACTION_SUMMARY_PREVIEW_MAX_LENGTH,
+  AGENT_CONTEXT_COMPACTION_TRIGGERS,
+  AGENT_CONTEXT_CUMULATIVE_USAGE_FIELDS,
+  AGENT_CONTEXT_MEASUREMENT_SCOPES,
   AGENT_FILE_CHANGE_KINDS,
   AGENT_IMAGE_INPUT_MEDIA_TYPES,
   AGENT_IMAGE_INPUT_SOURCE_KINDS,

package/dist/zod/capabilities.d.ts

@@ -1,5 +1,25 @@
 import { z } from 'zod/v4';
 import { type AgentCapabilities } from '../capabilities/types.js';
+export declare const AgentApprovalCapabilitySchema: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"unsupported">;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"supported">;
+    modes: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        persistence: z.ZodEnum<{
+            session: "session";
+            once: "once";
+            workspace: "workspace";
+        }>;
+        scopeKinds: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+            exact_action: "exact_action";
+            command_pattern: "command_pattern";
+            domain: "domain";
+            tool: "tool";
+            server: "server";
+            all_edits: "all_edits";
+        }>>>;
+    }, z.core.$strict>>>>;
+}, z.core.$strict>>], "kind">;
 export declare const AgentImageInputCapabilitySchema: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
     kind: z.ZodLiteral<"unsupported">;
 }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
@@ -48,7 +68,7 @@ export declare const AgentOperationInputCapabilitySchema: z.ZodReadonly<z.ZodObj
     }, z.core.$strict>>], "kind">;
 }, z.core.$strict>>;
 export declare const AgentCapabilitiesPortableSchema: z.ZodReadonly<z.ZodObject<{
-    protocolVersion: z.ZodLiteral<6>;
+    protocolVersion: z.ZodLiteral<7>;
     providerKey: z.ZodType<import("../index.js").AgentProviderKey, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentProviderKey, unknown>>;
     sessions: z.ZodReadonly<z.ZodObject<{
         create: z.ZodLiteral<true>;
@@ -97,7 +117,26 @@ export declare const AgentCapabilitiesPortableSchema: z.ZodReadonly<z.ZodObject<
         }, z.core.$strict>>], "kind">;
     }, z.core.$strict>>;
     requests: z.ZodReadonly<z.ZodObject<{
-        approval: z.ZodBoolean;
+        approval: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"unsupported">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"supported">;
+            modes: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                persistence: z.ZodEnum<{
+                    session: "session";
+                    once: "once";
+                    workspace: "workspace";
+                }>;
+                scopeKinds: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                    exact_action: "exact_action";
+                    command_pattern: "command_pattern";
+                    domain: "domain";
+                    tool: "tool";
+                    server: "server";
+                    all_edits: "all_edits";
+                }>>>;
+            }, z.core.$strict>>>>;
+        }, z.core.$strict>>], "kind">;
         elicitation: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
             kind: z.ZodLiteral<"unsupported">;
         }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
@@ -106,6 +145,39 @@ export declare const AgentCapabilitiesPortableSchema: z.ZodReadonly<z.ZodObject<
             kind: z.ZodLiteral<"structured">;
         }, z.core.$strict>>], "kind">;
     }, z.core.$strict>>;
+    context: z.ZodReadonly<z.ZodObject<{
+        usage: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"unsupported">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"supported">;
+            measurementScopes: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                session: "session";
+                materialization: "materialization";
+            }>>>;
+            cumulativeFields: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                inputTokens: "inputTokens";
+                outputTokens: "outputTokens";
+                cachedReadTokens: "cachedReadTokens";
+                cacheCreationTokens: "cacheCreationTokens";
+                reasoningTokens: "reasoningTokens";
+                modelCalls: "modelCalls";
+                turns: "turns";
+            }>>>;
+        }, z.core.$strict>>], "kind">;
+        compaction: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"unsupported">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"supported">;
+            triggers: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                unknown: "unknown";
+                automatic: "automatic";
+                manual: "manual";
+                context_limit: "context_limit";
+                recovery: "recovery";
+            }>>>;
+            sameSessionContinuation: z.ZodBoolean;
+        }, z.core.$strict>>], "kind">;
+    }, z.core.$strict>>;
     input: z.ZodReadonly<z.ZodObject<{
         text: z.ZodLiteral<true>;
         images: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{

package/dist/zod/capabilities.js

@@ -9,6 +9,13 @@ import {
   AGENT_FILE_CHANGE_MODES
 } from "../capabilities/types.js";
 import {
+  AGENT_APPROVAL_PERSISTENCES,
+  AGENT_APPROVAL_SCOPE_KINDS
+} from "../requests/types.js";
+import {
+  AGENT_CONTEXT_COMPACTION_TRIGGERS,
+  AGENT_CONTEXT_CUMULATIVE_USAGE_FIELDS,
+  AGENT_CONTEXT_MEASUREMENT_SCOPES,
   AGENT_IMAGE_INPUT_MEDIA_TYPES,
   AGENT_IMAGE_INPUT_SOURCE_KINDS,
   AGENT_TURN_INTERACTION_MODES
@@ -39,6 +46,34 @@ function addCanonicalListIssues(input, context) {
   });
 }
 const PositiveSafeIntegerSchema = z.number().int().positive().max(Number.MAX_SAFE_INTEGER);
+const AgentApprovalCapabilitySchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("unsupported") }).strict().readonly(),
+  z.object({
+    kind: z.literal("supported"),
+    modes: z.array(
+      z.object({
+        persistence: z.enum(AGENT_APPROVAL_PERSISTENCES),
+        scopeKinds: z.array(z.enum(AGENT_APPROVAL_SCOPE_KINDS)).min(1).max(AGENT_APPROVAL_SCOPE_KINDS.length).meta({ uniqueItems: true }).readonly()
+      }).strict().readonly()
+    ).min(1).max(AGENT_APPROVAL_PERSISTENCES.length).readonly()
+  }).strict().readonly()
+]);
+const AgentContextUsageCapabilitySchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("unsupported") }).strict().readonly(),
+  z.object({
+    kind: z.literal("supported"),
+    measurementScopes: z.array(z.enum(AGENT_CONTEXT_MEASUREMENT_SCOPES)).min(1).max(AGENT_CONTEXT_MEASUREMENT_SCOPES.length).meta({ uniqueItems: true }).readonly(),
+    cumulativeFields: z.array(z.enum(AGENT_CONTEXT_CUMULATIVE_USAGE_FIELDS)).max(AGENT_CONTEXT_CUMULATIVE_USAGE_FIELDS.length).meta({ uniqueItems: true }).readonly()
+  }).strict().readonly()
+]);
+const AgentContextCompactionCapabilitySchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("unsupported") }).strict().readonly(),
+  z.object({
+    kind: z.literal("supported"),
+    triggers: z.array(z.enum(AGENT_CONTEXT_COMPACTION_TRIGGERS)).min(1).max(AGENT_CONTEXT_COMPACTION_TRIGGERS.length).meta({ uniqueItems: true }).readonly(),
+    sameSessionContinuation: z.boolean()
+  }).strict().readonly()
+]);
 const AgentImageInputCapabilitySchema = z.discriminatedUnion("kind", [
   z.object({ kind: z.literal("unsupported") }).strict().readonly(),
   z.object({
@@ -121,13 +156,17 @@ const AgentCapabilitiesPortableSchema = z.object({
     ])
   }).strict().readonly(),
   requests: z.object({
-    approval: z.boolean(),
+    approval: AgentApprovalCapabilitySchema,
     elicitation: z.discriminatedUnion("kind", [
       z.object({ kind: z.literal("unsupported") }).strict().readonly(),
       z.object({ kind: z.literal("text") }).strict().readonly(),
       z.object({ kind: z.literal("structured") }).strict().readonly()
     ])
   }).strict().readonly(),
+  context: z.object({
+    usage: AgentContextUsageCapabilitySchema,
+    compaction: AgentContextCompactionCapabilitySchema
+  }).strict().readonly(),
   input: AgentOperationInputCapabilitySchema,
   output: z.object({
     streaming: z.boolean(),
@@ -172,6 +211,61 @@ const AgentCapabilitiesSchema = AgentCapabilitiesPortableSchema.superRefine((cap
     },
     context
   );
+  if (capabilities.requests.approval.kind === "supported") {
+    addCanonicalListIssues(
+      {
+        values: capabilities.requests.approval.modes.map(
+          (mode) => mode.persistence
+        ),
+        canonicalOrder: AGENT_APPROVAL_PERSISTENCES,
+        path: ["requests", "approval", "modes"],
+        label: "Approval persistence modes"
+      },
+      context
+    );
+    capabilities.requests.approval.modes.forEach((mode, index) => {
+      addCanonicalListIssues(
+        {
+          values: mode.scopeKinds,
+          canonicalOrder: AGENT_APPROVAL_SCOPE_KINDS,
+          path: ["requests", "approval", "modes", index, "scopeKinds"],
+          label: "Approval scope kinds"
+        },
+        context
+      );
+    });
+  }
+  if (capabilities.context.usage.kind === "supported") {
+    addCanonicalListIssues(
+      {
+        values: capabilities.context.usage.measurementScopes,
+        canonicalOrder: AGENT_CONTEXT_MEASUREMENT_SCOPES,
+        path: ["context", "usage", "measurementScopes"],
+        label: "Context measurement scopes"
+      },
+      context
+    );
+    addCanonicalListIssues(
+      {
+        values: capabilities.context.usage.cumulativeFields,
+        canonicalOrder: AGENT_CONTEXT_CUMULATIVE_USAGE_FIELDS,
+        path: ["context", "usage", "cumulativeFields"],
+        label: "Context cumulative usage fields"
+      },
+      context
+    );
+  }
+  if (capabilities.context.compaction.kind === "supported") {
+    addCanonicalListIssues(
+      {
+        values: capabilities.context.compaction.triggers,
+        canonicalOrder: AGENT_CONTEXT_COMPACTION_TRIGGERS,
+        path: ["context", "compaction", "triggers"],
+        label: "Context compaction triggers"
+      },
+      context
+    );
+  }
   addCanonicalListIssues(
     {
       values: capabilities.output.artifactKinds,
@@ -215,6 +309,7 @@ const AgentCapabilitiesSchema = AgentCapabilitiesPortableSchema.superRefine((cap
   }
 });
 export {
+  AgentApprovalCapabilitySchema,
   AgentCapabilitiesPortableSchema,
   AgentCapabilitiesSchema,
   AgentImageInputCapabilitySchema,