@agen-ai/agent-protocol 0.2.2 → 0.2.3

package/dist/requests/types.d.ts

@@ -4,8 +4,13 @@ export declare const AGENT_APPROVAL_SCOPE_KINDS: readonly ["exact_action", "comm
 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 declare const AGENT_ELICITATION_FIELD_KINDS: readonly ["text", "single_select", "multi_select", "boolean", "confirmation"];
+export declare const AGENT_ELICITATION_FIELDS_MAX_LENGTH = 16;
+export declare const AGENT_ELICITATION_OPTIONS_MAX_LENGTH = 100;
+export declare const AGENT_ELICITATION_TEXT_VALUE_MAX_LENGTH = 4000;
 export type AgentApprovalPersistence = (typeof AGENT_APPROVAL_PERSISTENCES)[number];
 export type AgentApprovalScopeKind = (typeof AGENT_APPROVAL_SCOPE_KINDS)[number];
+export type AgentElicitationFieldKind = (typeof AGENT_ELICITATION_FIELD_KINDS)[number];
 interface AgentApprovalSubjectBase {
     readonly title: string;
     readonly description?: string;
@@ -45,21 +50,32 @@ interface AgentElicitationFieldBase {
     readonly label: string;
     readonly description?: string;
     readonly required: boolean;
+    readonly sensitivity: 'ordinary' | 'sensitive';
 }
 export interface AgentTextElicitationField extends AgentElicitationFieldBase {
     readonly kind: 'text';
-    readonly multiline?: boolean;
+    readonly multiline: boolean;
+    readonly maxLength: number;
 }
-export interface AgentChoiceElicitationField extends AgentElicitationFieldBase {
-    readonly kind: 'choice';
+export interface AgentSingleSelectElicitationField extends AgentElicitationFieldBase {
+    readonly kind: 'single_select';
     readonly options: readonly AgentRequestChoice[];
-    readonly multiple: boolean;
     readonly allowOther: boolean;
 }
+export interface AgentMultiSelectElicitationField extends AgentElicitationFieldBase {
+    readonly kind: 'multi_select';
+    readonly options: readonly AgentRequestChoice[];
+    readonly allowOther: boolean;
+    readonly maxSelections: number;
+}
 export interface AgentBooleanElicitationField extends AgentElicitationFieldBase {
     readonly kind: 'boolean';
 }
-export type AgentElicitationField = AgentTextElicitationField | AgentChoiceElicitationField | AgentBooleanElicitationField;
+export interface AgentConfirmationElicitationField extends AgentElicitationFieldBase {
+    readonly kind: 'confirmation';
+    readonly confirmLabel: string;
+}
+export type AgentElicitationField = AgentTextElicitationField | AgentSingleSelectElicitationField | AgentMultiSelectElicitationField | AgentBooleanElicitationField | AgentConfirmationElicitationField;
 export interface AgentElicitationRequest {
     readonly requestKind: 'elicitation';
     readonly requestId: AgentRequestId;
@@ -83,9 +99,15 @@ export interface AgentTextElicitationAnswer {
     readonly kind: 'text';
     readonly value: string;
 }
-export interface AgentChoiceElicitationAnswer {
+export interface AgentSingleSelectElicitationAnswer {
     readonly fieldId: AgentRequestFieldId;
-    readonly kind: 'choice';
+    readonly kind: 'single_select';
+    readonly value?: string;
+    readonly other?: string;
+}
+export interface AgentMultiSelectElicitationAnswer {
+    readonly fieldId: AgentRequestFieldId;
+    readonly kind: 'multi_select';
     readonly values: readonly string[];
     readonly other?: string;
 }
@@ -94,7 +116,12 @@ export interface AgentBooleanElicitationAnswer {
     readonly kind: 'boolean';
     readonly value: boolean;
 }
-export type AgentElicitationAnswer = AgentTextElicitationAnswer | AgentChoiceElicitationAnswer | AgentBooleanElicitationAnswer;
+export interface AgentConfirmationElicitationAnswer {
+    readonly fieldId: AgentRequestFieldId;
+    readonly kind: 'confirmation';
+    readonly confirmed: boolean;
+}
+export type AgentElicitationAnswer = AgentTextElicitationAnswer | AgentSingleSelectElicitationAnswer | AgentMultiSelectElicitationAnswer | AgentBooleanElicitationAnswer | AgentConfirmationElicitationAnswer;
 export interface AgentAnsweredElicitationResolution {
     readonly requestKind: 'elicitation';
     readonly requestId: AgentRequestId;

package/dist/requests/types.js

@@ -14,10 +14,24 @@ const AGENT_APPROVAL_SCOPE_KINDS = [
 const AGENT_APPROVAL_OPTIONS_MAX_LENGTH = 16;
 const AGENT_APPROVAL_LABEL_MAX_LENGTH = 120;
 const AGENT_APPROVAL_DESCRIPTION_MAX_LENGTH = 1e3;
+const AGENT_ELICITATION_FIELD_KINDS = [
+  "text",
+  "single_select",
+  "multi_select",
+  "boolean",
+  "confirmation"
+];
+const AGENT_ELICITATION_FIELDS_MAX_LENGTH = 16;
+const AGENT_ELICITATION_OPTIONS_MAX_LENGTH = 100;
+const AGENT_ELICITATION_TEXT_VALUE_MAX_LENGTH = 4e3;
 export {
   AGENT_APPROVAL_DESCRIPTION_MAX_LENGTH,
   AGENT_APPROVAL_LABEL_MAX_LENGTH,
   AGENT_APPROVAL_OPTIONS_MAX_LENGTH,
   AGENT_APPROVAL_PERSISTENCES,
-  AGENT_APPROVAL_SCOPE_KINDS
+  AGENT_APPROVAL_SCOPE_KINDS,
+  AGENT_ELICITATION_FIELDS_MAX_LENGTH,
+  AGENT_ELICITATION_FIELD_KINDS,
+  AGENT_ELICITATION_OPTIONS_MAX_LENGTH,
+  AGENT_ELICITATION_TEXT_VALUE_MAX_LENGTH
 };

package/dist/resources/index.d.ts

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

package/dist/resources/index.js

@@ -0,0 +1,2 @@
+export * from "./types.js";
+export * from "./parsers.js";

package/dist/resources/parsers.d.ts

@@ -0,0 +1,5 @@
+import type { AgentProtocolParseResult } from '../foundation/index.js';
+import type { AgentGeneratedResourceDescriptor } from './types.js';
+export declare function parseAgentGeneratedResourceDescriptor(input: unknown): AgentGeneratedResourceDescriptor;
+export declare function safeParseAgentGeneratedResourceDescriptor(input: unknown): AgentProtocolParseResult<AgentGeneratedResourceDescriptor>;
+//# sourceMappingURL=parsers.d.ts.map

package/dist/resources/parsers.js

@@ -0,0 +1,12 @@
+import { parseWithSchema, safeParseWithSchema } from "../internal/parsers.js";
+import { AgentGeneratedResourceDescriptorSchema } from "../zod/resources.js";
+function parseAgentGeneratedResourceDescriptor(input) {
+  return parseWithSchema(AgentGeneratedResourceDescriptorSchema, input);
+}
+function safeParseAgentGeneratedResourceDescriptor(input) {
+  return safeParseWithSchema(AgentGeneratedResourceDescriptorSchema, input);
+}
+export {
+  parseAgentGeneratedResourceDescriptor,
+  safeParseAgentGeneratedResourceDescriptor
+};

package/dist/resources/types.d.ts

@@ -0,0 +1,39 @@
+import type { AgentArtifactId, AgentCollaborationId, AgentError, AgentGeneratedResourceId, AgentIsoDateTime, AgentOperationInvocationId, AgentSessionId, AgentTurnId } from '../foundation/index.js';
+export declare const AGENT_GENERATED_RESOURCE_KINDS: readonly ["image", "document", "archive"];
+export declare const AGENT_GENERATED_RESOURCE_STATUSES: readonly ["pending", "available", "unavailable", "expired"];
+export declare const AGENT_GENERATED_RESOURCE_DISPLAY_NAME_MAX_LENGTH = 200;
+export declare const AGENT_GENERATED_RESOURCE_SUMMARY_MAX_LENGTH = 2000;
+export type AgentGeneratedResourceKind = (typeof AGENT_GENERATED_RESOURCE_KINDS)[number];
+export type AgentGeneratedResourceStatus = (typeof AGENT_GENERATED_RESOURCE_STATUSES)[number];
+export type AgentGeneratedResourceProducer = Readonly<{
+    kind: 'session';
+    sessionId: AgentSessionId;
+}> | Readonly<{
+    kind: 'turn';
+    turnId: AgentTurnId;
+}> | Readonly<{
+    kind: 'operation';
+    invocationId: AgentOperationInvocationId;
+}> | Readonly<{
+    kind: 'collaboration';
+    collaborationId: AgentCollaborationId;
+}>;
+export interface AgentGeneratedResourceDescriptor {
+    readonly resourceId: AgentGeneratedResourceId;
+    readonly kind: AgentGeneratedResourceKind;
+    readonly status: AgentGeneratedResourceStatus;
+    readonly displayName: string;
+    readonly producer: AgentGeneratedResourceProducer;
+    readonly summary?: string;
+    readonly mediaType?: string;
+    readonly byteSize?: number;
+    readonly sha256?: string;
+    readonly widthPixels?: number;
+    readonly heightPixels?: number;
+    readonly pageCount?: number;
+    readonly artifactId?: AgentArtifactId;
+    readonly createdAt: AgentIsoDateTime;
+    readonly expiresAt?: AgentIsoDateTime;
+    readonly error?: AgentError;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/resources/types.js

@@ -0,0 +1,19 @@
+const AGENT_GENERATED_RESOURCE_KINDS = [
+  "image",
+  "document",
+  "archive"
+];
+const AGENT_GENERATED_RESOURCE_STATUSES = [
+  "pending",
+  "available",
+  "unavailable",
+  "expired"
+];
+const AGENT_GENERATED_RESOURCE_DISPLAY_NAME_MAX_LENGTH = 200;
+const AGENT_GENERATED_RESOURCE_SUMMARY_MAX_LENGTH = 2e3;
+export {
+  AGENT_GENERATED_RESOURCE_DISPLAY_NAME_MAX_LENGTH,
+  AGENT_GENERATED_RESOURCE_KINDS,
+  AGENT_GENERATED_RESOURCE_STATUSES,
+  AGENT_GENERATED_RESOURCE_SUMMARY_MAX_LENGTH
+};

package/dist/sessions/types.d.ts

@@ -1,12 +1,23 @@
-import type { AgentConfigurationRevisionId, AgentJsonValue, AgentProviderConversationId, AgentProviderHistoryAnchor, AgentSessionId, AgentTurnId } from '../foundation/index.js';
+import type { AgentConfigurationRevisionId, AgentProviderConversationId, AgentProviderHistoryAnchor, AgentSessionId, AgentTurnId } from '../foundation/index.js';
+import type { AgentConfigurationValue } from '../configuration/index.js';
 export interface AgentSessionBinding {
     readonly conversationId: AgentProviderConversationId;
     readonly historyAnchor?: AgentProviderHistoryAnchor;
 }
-export interface AgentSessionConfiguration {
-    readonly revision: AgentConfigurationRevisionId;
-    readonly values: Readonly<Record<string, AgentJsonValue>>;
+export interface AgentSessionConfigurationSelection {
+    readonly key: string;
+    readonly fieldRevision: number;
+    readonly value: AgentConfigurationValue;
 }
+export type AgentSessionConfiguration = Readonly<{
+    kind: 'managed';
+    revision: AgentConfigurationRevisionId;
+}> | Readonly<{
+    kind: 'selected';
+    revision: AgentConfigurationRevisionId;
+    catalogRevision: number;
+    selections: readonly AgentSessionConfigurationSelection[];
+}>;
 export interface AgentSessionCreateInput {
     readonly operation: 'create';
     readonly sessionId: AgentSessionId;

package/dist/zod/capabilities.d.ts

@@ -68,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<7>;
+    protocolVersion: z.ZodLiteral<8>;
     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>;
@@ -140,9 +140,16 @@ export declare const AgentCapabilitiesPortableSchema: z.ZodReadonly<z.ZodObject<
         elicitation: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
             kind: z.ZodLiteral<"unsupported">;
         }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
-            kind: z.ZodLiteral<"text">;
-        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
-            kind: z.ZodLiteral<"structured">;
+            kind: z.ZodLiteral<"supported">;
+            fieldKinds: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                boolean: "boolean";
+                single_select: "single_select";
+                text: "text";
+                multi_select: "multi_select";
+                confirmation: "confirmation";
+            }>>>;
+            maxFields: z.ZodNumber;
+            sensitiveFields: z.ZodBoolean;
         }, z.core.$strict>>], "kind">;
     }, z.core.$strict>>;
     context: z.ZodReadonly<z.ZodObject<{
@@ -207,9 +214,9 @@ export declare const AgentCapabilitiesPortableSchema: z.ZodReadonly<z.ZodObject<
         streaming: z.ZodBoolean;
         plans: z.ZodBoolean;
         fileChanges: z.ZodEnum<{
-            structured: "structured";
             none: "none";
             final_diff: "final_diff";
+            structured: "structured";
         }>;
         artifactKinds: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
             file: "file";
@@ -225,17 +232,98 @@ export declare const AgentCapabilitiesPortableSchema: z.ZodReadonly<z.ZodObject<
         kind: z.ZodLiteral<"managed">;
     }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
         kind: z.ZodLiteral<"selectable">;
-        fields: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
-            key: z.ZodString;
-            optionIds: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-        }, z.core.$strict>>>>;
+        fieldKinds: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+            boolean: "boolean";
+            single_select: "single_select";
+            bounded_integer: "bounded_integer";
+            bounded_text: "bounded_text";
+        }>>>;
+        maxFields: z.ZodNumber;
+    }, z.core.$strict>>], "kind">;
+    operations: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"unsupported">;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"supported">;
+        operationKinds: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+            session_control: "session_control";
+            managed_content_invoke: "managed_content_invoke";
+            configuration_select: "configuration_select";
+            integration_control: "integration_control";
+            collaboration_control: "collaboration_control";
+            resource_generate: "resource_generate";
+        }>>>;
+        fieldKinds: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+            boolean: "boolean";
+            single_select: "single_select";
+            text: "text";
+            multi_select: "multi_select";
+            integer: "integer";
+        }>>>;
+        executionModes: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+            immediate: "immediate";
+            request_continuation: "request_continuation";
+            durable_job: "durable_job";
+        }>>>;
+        maxOperations: z.ZodNumber;
+        maxFieldsPerOperation: z.ZodNumber;
+    }, z.core.$strict>>], "kind">;
+    managedContent: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"unsupported">;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"supported">;
+        contentKinds: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+            prompt: "prompt";
+            skill: "skill";
+            rule: "rule";
+            agent_definition: "agent_definition";
+        }>>>;
+        maxEntries: z.ZodNumber;
+    }, z.core.$strict>>], "kind">;
+    integrations: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"unsupported">;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"supported">;
+        integrationKinds: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+            mcp: "mcp";
+        }>>>;
+        maxIntegrations: z.ZodNumber;
+        maxServersPerIntegration: z.ZodNumber;
+        maxToolsPerServer: z.ZodNumber;
+        maxResourcesPerServer: z.ZodNumber;
+    }, z.core.$strict>>], "kind">;
+    collaboration: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"unsupported">;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"supported">;
+        roles: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+            delegate: "delegate";
+            reviewer: "reviewer";
+            researcher: "researcher";
+            specialist: "specialist";
+        }>>>;
+        controlActions: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+            spawn: "spawn";
+            steer: "steer";
+            stop: "stop";
+            close: "close";
+            inspect: "inspect";
+        }>>>;
+        maxDepth: z.ZodNumber;
+        maxChildrenPerNode: z.ZodNumber;
+        maxActiveNodes: z.ZodNumber;
+    }, z.core.$strict>>], "kind">;
+    generatedResources: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"unsupported">;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"supported">;
+        resourceKinds: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+            image: "image";
+            document: "document";
+            archive: "archive";
+        }>>>;
+        maxResourcesPerTurn: z.ZodNumber;
+        maxBytesPerResource: z.ZodNumber;
     }, z.core.$strict>>], "kind">;
-    interactionExtensions: z.ZodReadonly<z.ZodObject<{
-        slashCommands: z.ZodBoolean;
-        mcp: z.ZodBoolean;
-        subagents: z.ZodBoolean;
-        imageGeneration: z.ZodBoolean;
-    }, z.core.$strict>>;
     authentication: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
         kind: z.ZodLiteral<"unsupported">;
     }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{

package/dist/zod/capabilities.js

@@ -1,6 +1,5 @@
 import { z } from "zod/v4";
 import {
-  AGENT_PROTOCOL_COLLECTION_MAX_LENGTH,
   AGENT_PROTOCOL_VERSION
 } from "../foundation/types.js";
 import { AGENT_ARTIFACT_KINDS } from "../artifacts/types.js";
@@ -8,10 +7,40 @@ import {
   AGENT_AUTHENTICATION_FLOWS,
   AGENT_FILE_CHANGE_MODES
 } from "../capabilities/types.js";
+import {
+  AGENT_COLLABORATION_CONTROL_ACTIONS,
+  AGENT_COLLABORATION_GRAPH_LIMITS,
+  AGENT_COLLABORATION_ROLES
+} from "../collaboration/types.js";
+import {
+  AGENT_CONFIGURATION_FIELD_KINDS,
+  AGENT_CONFIGURATION_FIELDS_MAX_LENGTH
+} from "../configuration/types.js";
+import {
+  AGENT_INTEGRATION_KINDS,
+  AGENT_INTEGRATION_RESOURCES_MAX_LENGTH,
+  AGENT_INTEGRATION_CATALOG_MAX_LENGTH,
+  AGENT_INTEGRATION_SERVERS_MAX_LENGTH,
+  AGENT_INTEGRATION_TOOLS_MAX_LENGTH
+} from "../integrations/types.js";
+import {
+  AGENT_MANAGED_CONTENT_CATALOG_MAX_LENGTH,
+  AGENT_MANAGED_CONTENT_KINDS
+} from "../managedContent/types.js";
+import {
+  AGENT_OPERATION_CATALOG_MAX_LENGTH,
+  AGENT_OPERATION_EXECUTION_MODES,
+  AGENT_OPERATION_FIELDS_MAX_LENGTH,
+  AGENT_OPERATION_FIELD_KINDS,
+  AGENT_OPERATION_KINDS
+} from "../operations/types.js";
 import {
   AGENT_APPROVAL_PERSISTENCES,
-  AGENT_APPROVAL_SCOPE_KINDS
+  AGENT_APPROVAL_SCOPE_KINDS,
+  AGENT_ELICITATION_FIELD_KINDS,
+  AGENT_ELICITATION_FIELDS_MAX_LENGTH
 } from "../requests/types.js";
+import { AGENT_GENERATED_RESOURCE_KINDS } from "../resources/types.js";
 import {
   AGENT_CONTEXT_COMPACTION_TRIGGERS,
   AGENT_CONTEXT_CUMULATIVE_USAGE_FIELDS,
@@ -21,7 +50,6 @@ import {
   AGENT_TURN_INTERACTION_MODES
 } from "../turns/types.js";
 import { AgentProviderKeySchema } from "./foundation.js";
-const AgentCapabilityIdentifierSchema = z.string().min(1).max(100).regex(/^[a-z][a-z0-9._:-]*$/u);
 function addCanonicalListIssues(input, context) {
   const seen = /* @__PURE__ */ new Set();
   let previousOrder = -1;
@@ -46,6 +74,9 @@ function addCanonicalListIssues(input, context) {
   });
 }
 const PositiveSafeIntegerSchema = z.number().int().positive().max(Number.MAX_SAFE_INTEGER);
+function boundedPositiveSafeInteger(maximum) {
+  return z.number().int().positive().max(maximum);
+}
 const AgentApprovalCapabilitySchema = z.discriminatedUnion("kind", [
   z.object({ kind: z.literal("unsupported") }).strict().readonly(),
   z.object({
@@ -154,6 +185,74 @@ const AgentOperationInputCapabilitySchema = z.object({
   text: z.literal(true),
   images: AgentImageInputCapabilitySchema
 }).strict().readonly();
+const AgentOperationsCapabilitySchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("unsupported") }).strict().readonly(),
+  z.object({
+    kind: z.literal("supported"),
+    operationKinds: z.array(z.enum(AGENT_OPERATION_KINDS)).min(1).max(AGENT_OPERATION_KINDS.length).meta({ uniqueItems: true }).readonly(),
+    fieldKinds: z.array(z.enum(AGENT_OPERATION_FIELD_KINDS)).min(1).max(AGENT_OPERATION_FIELD_KINDS.length).meta({ uniqueItems: true }).readonly(),
+    executionModes: z.array(z.enum(AGENT_OPERATION_EXECUTION_MODES)).min(1).max(AGENT_OPERATION_EXECUTION_MODES.length).meta({ uniqueItems: true }).readonly(),
+    maxOperations: boundedPositiveSafeInteger(
+      AGENT_OPERATION_CATALOG_MAX_LENGTH
+    ),
+    maxFieldsPerOperation: boundedPositiveSafeInteger(
+      AGENT_OPERATION_FIELDS_MAX_LENGTH
+    )
+  }).strict().readonly()
+]);
+const AgentManagedContentCapabilitySchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("unsupported") }).strict().readonly(),
+  z.object({
+    kind: z.literal("supported"),
+    contentKinds: z.array(z.enum(AGENT_MANAGED_CONTENT_KINDS)).min(1).max(AGENT_MANAGED_CONTENT_KINDS.length).meta({ uniqueItems: true }).readonly(),
+    maxEntries: boundedPositiveSafeInteger(
+      AGENT_MANAGED_CONTENT_CATALOG_MAX_LENGTH
+    )
+  }).strict().readonly()
+]);
+const AgentIntegrationsCapabilitySchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("unsupported") }).strict().readonly(),
+  z.object({
+    kind: z.literal("supported"),
+    integrationKinds: z.array(z.enum(AGENT_INTEGRATION_KINDS)).min(1).max(AGENT_INTEGRATION_KINDS.length).meta({ uniqueItems: true }).readonly(),
+    maxIntegrations: boundedPositiveSafeInteger(
+      AGENT_INTEGRATION_CATALOG_MAX_LENGTH
+    ),
+    maxServersPerIntegration: boundedPositiveSafeInteger(
+      AGENT_INTEGRATION_SERVERS_MAX_LENGTH
+    ),
+    maxToolsPerServer: boundedPositiveSafeInteger(
+      AGENT_INTEGRATION_TOOLS_MAX_LENGTH
+    ),
+    maxResourcesPerServer: boundedPositiveSafeInteger(
+      AGENT_INTEGRATION_RESOURCES_MAX_LENGTH
+    )
+  }).strict().readonly()
+]);
+const AgentCollaborationCapabilitySchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("unsupported") }).strict().readonly(),
+  z.object({
+    kind: z.literal("supported"),
+    roles: z.array(z.enum(AGENT_COLLABORATION_ROLES)).min(1).max(AGENT_COLLABORATION_ROLES.length).meta({ uniqueItems: true }).readonly(),
+    controlActions: z.array(z.enum(AGENT_COLLABORATION_CONTROL_ACTIONS)).min(1).max(AGENT_COLLABORATION_CONTROL_ACTIONS.length).meta({ uniqueItems: true }).readonly(),
+    maxDepth: boundedPositiveSafeInteger(AGENT_COLLABORATION_GRAPH_LIMITS.maxDepth),
+    maxChildrenPerNode: boundedPositiveSafeInteger(
+      AGENT_COLLABORATION_GRAPH_LIMITS.maxChildrenPerNode
+    ),
+    maxActiveNodes: boundedPositiveSafeInteger(
+      AGENT_COLLABORATION_GRAPH_LIMITS.maxActiveNodes
+    )
+  }).strict().readonly()
+]);
+const AgentGeneratedResourcesCapabilitySchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("unsupported") }).strict().readonly(),
+  z.object({
+    kind: z.literal("supported"),
+    resourceKinds: z.array(z.enum(AGENT_GENERATED_RESOURCE_KINDS)).min(1).max(AGENT_GENERATED_RESOURCE_KINDS.length).meta({ uniqueItems: true }).readonly(),
+    maxResourcesPerTurn: boundedPositiveSafeInteger(100),
+    maxBytesPerResource: boundedPositiveSafeInteger(1073741824)
+  }).strict().readonly()
+]);
 const AgentCapabilitiesPortableSchema = z.object({
   protocolVersion: z.literal(AGENT_PROTOCOL_VERSION),
   providerKey: AgentProviderKeySchema,
@@ -180,8 +279,14 @@ const AgentCapabilitiesPortableSchema = z.object({
     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()
+      z.object({
+        kind: z.literal("supported"),
+        fieldKinds: z.array(z.enum(AGENT_ELICITATION_FIELD_KINDS)).min(1).max(AGENT_ELICITATION_FIELD_KINDS.length).meta({ uniqueItems: true }).readonly(),
+        maxFields: boundedPositiveSafeInteger(
+          AGENT_ELICITATION_FIELDS_MAX_LENGTH
+        ),
+        sensitiveFields: z.boolean()
+      }).strict().readonly()
     ])
   }).strict().readonly(),
   context: z.object({
@@ -199,20 +304,17 @@ const AgentCapabilitiesPortableSchema = z.object({
     z.object({ kind: z.literal("managed") }).strict().readonly(),
     z.object({
       kind: z.literal("selectable"),
-      fields: z.array(
-        z.object({
-          key: AgentCapabilityIdentifierSchema,
-          optionIds: z.array(AgentCapabilityIdentifierSchema).min(1).max(AGENT_PROTOCOL_COLLECTION_MAX_LENGTH).meta({ uniqueItems: true }).readonly()
-        }).strict().readonly()
-      ).min(1).max(AGENT_PROTOCOL_COLLECTION_MAX_LENGTH).readonly()
+      fieldKinds: z.array(z.enum(AGENT_CONFIGURATION_FIELD_KINDS)).min(1).max(AGENT_CONFIGURATION_FIELD_KINDS.length).meta({ uniqueItems: true }).readonly(),
+      maxFields: boundedPositiveSafeInteger(
+        AGENT_CONFIGURATION_FIELDS_MAX_LENGTH
+      )
     }).strict().readonly()
   ]),
-  interactionExtensions: z.object({
-    slashCommands: z.boolean(),
-    mcp: z.boolean(),
-    subagents: z.boolean(),
-    imageGeneration: z.boolean()
-  }).strict().readonly(),
+  operations: AgentOperationsCapabilitySchema,
+  managedContent: AgentManagedContentCapabilitySchema,
+  integrations: AgentIntegrationsCapabilitySchema,
+  collaboration: AgentCollaborationCapabilitySchema,
+  generatedResources: AgentGeneratedResourcesCapabilitySchema,
   authentication: z.discriminatedUnion("kind", [
     z.object({ kind: z.literal("unsupported") }).strict().readonly(),
     z.object({
@@ -273,25 +375,88 @@ const AgentCapabilitiesSchema = AgentCapabilitiesPortableSchema.superRefine((cap
     context
   );
   if (capabilities.configuration.kind === "selectable") {
-    const keys = capabilities.configuration.fields.map((field) => field.key);
     addCanonicalListIssues(
       {
-        values: keys,
-        path: ["configuration", "fields"],
-        label: "Selectable configuration fields"
+        values: capabilities.configuration.fieldKinds,
+        canonicalOrder: AGENT_CONFIGURATION_FIELD_KINDS,
+        path: ["configuration", "fieldKinds"],
+        label: "Selectable configuration field kinds"
+      },
+      context
+    );
+  }
+  if (capabilities.requests.elicitation.kind === "supported") {
+    addCanonicalListIssues(
+      {
+        values: capabilities.requests.elicitation.fieldKinds,
+        canonicalOrder: AGENT_ELICITATION_FIELD_KINDS,
+        path: ["requests", "elicitation", "fieldKinds"],
+        label: "Elicitation field kinds"
+      },
+      context
+    );
+  }
+  if (capabilities.operations.kind === "supported") {
+    for (const [values, canonicalOrder, path, label] of [
+      [capabilities.operations.operationKinds, AGENT_OPERATION_KINDS, ["operations", "operationKinds"], "Operation kinds"],
+      [capabilities.operations.fieldKinds, AGENT_OPERATION_FIELD_KINDS, ["operations", "fieldKinds"], "Operation field kinds"],
+      [capabilities.operations.executionModes, AGENT_OPERATION_EXECUTION_MODES, ["operations", "executionModes"], "Operation execution modes"]
+    ]) {
+      addCanonicalListIssues({ values, canonicalOrder, path, label }, context);
+    }
+  }
+  if (capabilities.managedContent.kind === "supported") {
+    addCanonicalListIssues(
+      {
+        values: capabilities.managedContent.contentKinds,
+        canonicalOrder: AGENT_MANAGED_CONTENT_KINDS,
+        path: ["managedContent", "contentKinds"],
+        label: "Managed content kinds"
+      },
+      context
+    );
+  }
+  if (capabilities.integrations.kind === "supported") {
+    addCanonicalListIssues(
+      {
+        values: capabilities.integrations.integrationKinds,
+        canonicalOrder: AGENT_INTEGRATION_KINDS,
+        path: ["integrations", "integrationKinds"],
+        label: "Integration kinds"
+      },
+      context
+    );
+  }
+  if (capabilities.collaboration.kind === "supported") {
+    addCanonicalListIssues(
+      {
+        values: capabilities.collaboration.roles,
+        canonicalOrder: AGENT_COLLABORATION_ROLES,
+        path: ["collaboration", "roles"],
+        label: "Collaboration roles"
+      },
+      context
+    );
+    addCanonicalListIssues(
+      {
+        values: capabilities.collaboration.controlActions,
+        canonicalOrder: AGENT_COLLABORATION_CONTROL_ACTIONS,
+        path: ["collaboration", "controlActions"],
+        label: "Collaboration control actions"
+      },
+      context
+    );
+  }
+  if (capabilities.generatedResources.kind === "supported") {
+    addCanonicalListIssues(
+      {
+        values: capabilities.generatedResources.resourceKinds,
+        canonicalOrder: AGENT_GENERATED_RESOURCE_KINDS,
+        path: ["generatedResources", "resourceKinds"],
+        label: "Generated resource kinds"
       },
       context
     );
-    capabilities.configuration.fields.forEach((field, index) => {
-      addCanonicalListIssues(
-        {
-          values: field.optionIds,
-          path: ["configuration", "fields", index, "optionIds"],
-          label: "Selectable configuration option IDs"
-        },
-        context
-      );
-    });
   }
   if (capabilities.authentication.kind === "supported") {
     addCanonicalListIssues(