@agen-ai/agent-protocol 0.2.5 → 0.3.1

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

@@ -5,6 +5,10 @@ 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

@@ -5,6 +5,10 @@ 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/capabilities.d.ts

@@ -42,6 +42,25 @@ export declare const AgentImageInputCapabilitySchema: z.ZodDiscriminatedUnion<[z
     maxPixelsPerImage: z.ZodNumber;
     supportsImageOnly: z.ZodBoolean;
 }, z.core.$strict>>], "kind">;
+export declare const AgentContentReferenceInputCapabilitySchema: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"unsupported">;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"supported">;
+    maxReferences: z.ZodNumber;
+    arguments: z.ZodBoolean;
+    textFormats: z.ZodReadonly<z.ZodObject<{
+        prompt: z.ZodEnum<{
+            unrestricted: "unrestricted";
+            single_line: "single_line";
+            literal_single_line: "literal_single_line";
+        }>;
+        arguments: z.ZodEnum<{
+            unrestricted: "unrestricted";
+            single_line: "single_line";
+            literal_single_line: "literal_single_line";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>>], "kind">;
 export declare const AgentOperationInputCapabilitySchema: z.ZodReadonly<z.ZodObject<{
     text: z.ZodLiteral<true>;
     images: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
@@ -66,9 +85,28 @@ export declare const AgentOperationInputCapabilitySchema: z.ZodReadonly<z.ZodObj
         maxPixelsPerImage: z.ZodNumber;
         supportsImageOnly: z.ZodBoolean;
     }, z.core.$strict>>], "kind">;
+    contentReferences: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"unsupported">;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"supported">;
+        maxReferences: z.ZodNumber;
+        arguments: z.ZodBoolean;
+        textFormats: z.ZodReadonly<z.ZodObject<{
+            prompt: z.ZodEnum<{
+                unrestricted: "unrestricted";
+                single_line: "single_line";
+                literal_single_line: "literal_single_line";
+            }>;
+            arguments: z.ZodEnum<{
+                unrestricted: "unrestricted";
+                single_line: "single_line";
+                literal_single_line: "literal_single_line";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>], "kind">;
 }, z.core.$strict>>;
 export declare const AgentCapabilitiesPortableSchema: z.ZodReadonly<z.ZodObject<{
-    protocolVersion: z.ZodLiteral<8>;
+    protocolVersion: z.ZodLiteral<9>;
     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>;
@@ -113,6 +151,25 @@ export declare const AgentCapabilitiesPortableSchema: z.ZodReadonly<z.ZodObject<
                     maxPixelsPerImage: z.ZodNumber;
                     supportsImageOnly: z.ZodBoolean;
                 }, z.core.$strict>>], "kind">;
+                contentReferences: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+                    kind: z.ZodLiteral<"unsupported">;
+                }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                    kind: z.ZodLiteral<"supported">;
+                    maxReferences: z.ZodNumber;
+                    arguments: z.ZodBoolean;
+                    textFormats: z.ZodReadonly<z.ZodObject<{
+                        prompt: z.ZodEnum<{
+                            unrestricted: "unrestricted";
+                            single_line: "single_line";
+                            literal_single_line: "literal_single_line";
+                        }>;
+                        arguments: z.ZodEnum<{
+                            unrestricted: "unrestricted";
+                            single_line: "single_line";
+                            literal_single_line: "literal_single_line";
+                        }>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>], "kind">;
             }, z.core.$strict>>;
         }, z.core.$strict>>], "kind">;
     }, z.core.$strict>>;
@@ -209,6 +266,25 @@ export declare const AgentCapabilitiesPortableSchema: z.ZodReadonly<z.ZodObject<
             maxPixelsPerImage: z.ZodNumber;
             supportsImageOnly: z.ZodBoolean;
         }, z.core.$strict>>], "kind">;
+        contentReferences: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"unsupported">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"supported">;
+            maxReferences: z.ZodNumber;
+            arguments: z.ZodBoolean;
+            textFormats: z.ZodReadonly<z.ZodObject<{
+                prompt: z.ZodEnum<{
+                    unrestricted: "unrestricted";
+                    single_line: "single_line";
+                    literal_single_line: "literal_single_line";
+                }>;
+                arguments: z.ZodEnum<{
+                    unrestricted: "unrestricted";
+                    single_line: "single_line";
+                    literal_single_line: "literal_single_line";
+                }>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>], "kind">;
     }, z.core.$strict>>;
     output: z.ZodReadonly<z.ZodObject<{
         streaming: z.ZodBoolean;
@@ -284,6 +360,7 @@ export declare const AgentCapabilitiesPortableSchema: z.ZodReadonly<z.ZodObject<
     }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
         kind: z.ZodLiteral<"supported">;
         integrationKinds: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+            connector: "connector";
             mcp: "mcp";
         }>>>;
         maxIntegrations: z.ZodNumber;
@@ -291,6 +368,7 @@ export declare const AgentCapabilitiesPortableSchema: z.ZodReadonly<z.ZodObject<
         maxToolsPerServer: z.ZodNumber;
         maxResourcesPerServer: z.ZodNumber;
     }, z.core.$strict>>], "kind">;
+    environment: z.ZodType<import("../index.js").AgentEnvironmentCapability, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentEnvironmentCapability, unknown>>;
     collaboration: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
         kind: z.ZodLiteral<"unsupported">;
     }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{

package/dist/zod/capabilities.js

@@ -1,10 +1,13 @@
 import { z } from "zod/v4";
+import { AgentEnvironmentCapabilitySchema } from "./environment.js";
+import { AGENT_CONTENT_REFERENCES_MAX_LENGTH } from "../turns/types.js";
 import {
   AGENT_PROTOCOL_VERSION
 } from "../foundation/types.js";
 import { AGENT_ARTIFACT_KINDS } from "../artifacts/types.js";
 import {
   AGENT_AUTHENTICATION_FLOWS,
+  AGENT_CONTENT_REFERENCE_TEXT_FORMATS,
   AGENT_FILE_CHANGE_MODES
 } from "../capabilities/types.js";
 import {
@@ -181,23 +184,34 @@ const AgentImageInputCapabilitySchema = z.discriminatedUnion("kind", [
     }
   }).readonly()
 ]);
+const AgentContentReferenceInputCapabilitySchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("unsupported") }).strict().readonly(),
+  z.object({
+    kind: z.literal("supported"),
+    maxReferences: z.number().int().min(1).max(AGENT_CONTENT_REFERENCES_MAX_LENGTH),
+    arguments: z.boolean(),
+    textFormats: z.object({
+      prompt: z.enum(AGENT_CONTENT_REFERENCE_TEXT_FORMATS),
+      arguments: z.enum(AGENT_CONTENT_REFERENCE_TEXT_FORMATS)
+    }).strict().readonly()
+  }).strict().readonly()
+]);
 const AgentOperationInputCapabilitySchema = z.object({
   text: z.literal(true),
-  images: AgentImageInputCapabilitySchema
+  images: AgentImageInputCapabilitySchema,
+  contentReferences: AgentContentReferenceInputCapabilitySchema
 }).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(),
+    fieldKinds: z.array(z.enum(AGENT_OPERATION_FIELD_KINDS)).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
-    )
+    maxFieldsPerOperation: z.number().int().min(0).max(AGENT_OPERATION_FIELDS_MAX_LENGTH)
   }).strict().readonly()
 ]);
 const AgentManagedContentCapabilitySchema = z.discriminatedUnion("kind", [
@@ -313,6 +327,7 @@ const AgentCapabilitiesPortableSchema = z.object({
   operations: AgentOperationsCapabilitySchema,
   managedContent: AgentManagedContentCapabilitySchema,
   integrations: AgentIntegrationsCapabilitySchema,
+  environment: AgentEnvironmentCapabilitySchema,
   collaboration: AgentCollaborationCapabilitySchema,
   generatedResources: AgentGeneratedResourcesCapabilitySchema,
   authentication: z.discriminatedUnion("kind", [
@@ -474,6 +489,7 @@ export {
   AgentApprovalCapabilitySchema,
   AgentCapabilitiesPortableSchema,
   AgentCapabilitiesSchema,
+  AgentContentReferenceInputCapabilitySchema,
   AgentImageInputCapabilitySchema,
   AgentOperationInputCapabilitySchema
 };

package/dist/zod/commands.d.ts

@@ -0,0 +1,35 @@
+import { z } from 'zod/v4';
+import { type AgentCommandCatalog, type AgentCommandDescriptor } from '../commands/types.js';
+export declare const AgentCommandDescriptorPortableSchema: z.ZodReadonly<z.ZodObject<{
+    commandId: z.ZodType<import("../index.js").AgentCommandId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentCommandId, unknown>>;
+    revision: z.ZodNumber;
+    name: z.ZodString;
+    summary: z.ZodOptional<z.ZodString>;
+    source: z.ZodType<import("../index.js").AgentEnvironmentSource, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentEnvironmentSource, unknown>>;
+    availability: z.ZodType<import("../index.js").AgentAvailabilityFact, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentAvailabilityFact, unknown>>;
+    operation: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+        operationId: z.ZodType<import("../index.js").AgentOperationId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentOperationId, unknown>>;
+        revision: z.ZodNumber;
+        catalogRevision: z.ZodNumber;
+    }, z.core.$strict>>>;
+}, z.core.$strict>>;
+export declare const AgentCommandDescriptorSchema: z.ZodType<AgentCommandDescriptor>;
+export declare const AgentCommandCatalogPortableSchema: z.ZodReadonly<z.ZodObject<{
+    revision: z.ZodNumber;
+    observedAt: z.ZodType<import("../index.js").AgentIsoDateTime, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIsoDateTime, unknown>>;
+    commands: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        commandId: z.ZodType<import("../index.js").AgentCommandId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentCommandId, unknown>>;
+        revision: z.ZodNumber;
+        name: z.ZodString;
+        summary: z.ZodOptional<z.ZodString>;
+        source: z.ZodType<import("../index.js").AgentEnvironmentSource, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentEnvironmentSource, unknown>>;
+        availability: z.ZodType<import("../index.js").AgentAvailabilityFact, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentAvailabilityFact, unknown>>;
+        operation: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+            operationId: z.ZodType<import("../index.js").AgentOperationId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentOperationId, unknown>>;
+            revision: z.ZodNumber;
+            catalogRevision: z.ZodNumber;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>>>;
+}, z.core.$strict>>;
+export declare const AgentCommandCatalogSchema: z.ZodType<AgentCommandCatalog>;
+//# sourceMappingURL=commands.d.ts.map

package/dist/zod/commands.js

@@ -0,0 +1,114 @@
+import { z } from "zod/v4";
+import {
+  AGENT_PROTOCOL_JSON_DEPTH_LIMIT,
+  agentProtocolSerializedJsonBytes
+} from "../foundation/types.js";
+import { compareStringsByUnicodeCodePoint } from "../foundation/ordering.js";
+import {
+  AGENT_COMMAND_CATALOG_BYTES_LIMIT,
+  AGENT_COMMAND_CATALOG_MAX_LENGTH,
+  AGENT_COMMAND_NAME_MAX_LENGTH,
+  AGENT_COMMAND_SUMMARY_MAX_LENGTH
+} from "../commands/types.js";
+import {
+  AgentAvailabilityFactSchema,
+  AgentEnvironmentSourceSchema
+} from "./environmentFacts.js";
+import {
+  AgentCommandIdSchema,
+  AgentIsoDateTimeSchema,
+  AgentOperationIdSchema,
+  createAgentCanonicalNonBlankStringSchema,
+  withAcyclicProtocolInput
+} from "./foundation.js";
+const PositiveSafeIntegerSchema = z.number().int().positive().max(Number.MAX_SAFE_INTEGER);
+const NameSchema = createAgentCanonicalNonBlankStringSchema(
+  AGENT_COMMAND_NAME_MAX_LENGTH
+);
+const SummarySchema = createAgentCanonicalNonBlankStringSchema(
+  AGENT_COMMAND_SUMMARY_MAX_LENGTH
+);
+const AgentCommandOperationReferenceSchema = z.object({
+  operationId: AgentOperationIdSchema,
+  revision: PositiveSafeIntegerSchema,
+  catalogRevision: PositiveSafeIntegerSchema
+}).strict().readonly();
+const AgentCommandDescriptorPortableSchema = z.object({
+  commandId: AgentCommandIdSchema,
+  revision: PositiveSafeIntegerSchema,
+  name: NameSchema,
+  summary: SummarySchema.optional(),
+  source: AgentEnvironmentSourceSchema,
+  availability: AgentAvailabilityFactSchema,
+  operation: AgentCommandOperationReferenceSchema.optional()
+}).strict().readonly();
+const AgentCommandDescriptorSchema = withAcyclicProtocolInput(
+  AgentCommandDescriptorPortableSchema,
+  {
+    maxDepth: AGENT_PROTOCOL_JSON_DEPTH_LIMIT,
+    maxCollectionLength: AGENT_COMMAND_CATALOG_MAX_LENGTH
+  }
+);
+const AgentCommandCatalogPortableSchema = z.object({
+  revision: PositiveSafeIntegerSchema,
+  observedAt: AgentIsoDateTimeSchema,
+  commands: z.array(AgentCommandDescriptorPortableSchema).max(AGENT_COMMAND_CATALOG_MAX_LENGTH).readonly()
+}).strict().readonly();
+function addOrderedUniqueIssues(values, path, context) {
+  const seen = /* @__PURE__ */ new Set();
+  values.forEach((value, index) => {
+    if (seen.has(value)) {
+      context.addIssue({
+        code: "custom",
+        path: [...path, index],
+        message: "Command IDs must be unique."
+      });
+    }
+    if (index > 0 && compareStringsByUnicodeCodePoint(values[index - 1], value) >= 0) {
+      context.addIssue({
+        code: "custom",
+        path: [...path, index],
+        message: "Command IDs must use canonical order."
+      });
+    }
+    seen.add(value);
+  });
+}
+const AgentCommandCatalogSchema = withAcyclicProtocolInput(
+  AgentCommandCatalogPortableSchema,
+  {
+    maxDepth: AGENT_PROTOCOL_JSON_DEPTH_LIMIT,
+    maxCollectionLength: AGENT_COMMAND_CATALOG_MAX_LENGTH
+  }
+).superRefine((catalog, context) => {
+  if (agentProtocolSerializedJsonBytes(catalog) > AGENT_COMMAND_CATALOG_BYTES_LIMIT) {
+    context.addIssue({
+      code: "custom",
+      path: ["commands"],
+      message: "Command catalog exceeds its serialized UTF-8 byte limit."
+    });
+  }
+  addOrderedUniqueIssues(
+    catalog.commands.map((descriptor) => descriptor.commandId),
+    ["commands"],
+    context
+  );
+  catalog.commands.forEach((descriptor, descriptorIndex) => {
+    const parsed = AgentCommandDescriptorSchema.safeParse(descriptor);
+    if (!parsed.success) {
+      for (const issue of parsed.error.issues) {
+        context.addIssue({
+          code: "custom",
+          path: ["commands", descriptorIndex, ...issue.path],
+          message: issue.message
+        });
+      }
+    }
+  });
+});
+export {
+  AgentCommandCatalogPortableSchema,
+  AgentCommandCatalogSchema,
+  AgentCommandDescriptorPortableSchema,
+  AgentCommandDescriptorSchema
+};

package/dist/zod/effectiveContent.d.ts

@@ -0,0 +1,72 @@
+import { z } from 'zod/v4';
+import { type AgentEffectiveContentCatalog, type AgentEffectiveContentDescriptor } from '../effectiveContent/types.js';
+export declare const AgentDefinitionObservationSchema: z.ZodReadonly<z.ZodObject<{
+    mode: z.ZodEnum<{
+        unknown: "unknown";
+        primary: "primary";
+        subagent: "subagent";
+        all: "all";
+    }>;
+    hidden: z.ZodType<import("../index.js").AgentAvailabilityFact, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentAvailabilityFact, unknown>>;
+}, z.core.$strict>>;
+export declare const AgentEffectiveContentDescriptorPortableSchema: z.ZodReadonly<z.ZodObject<{
+    contentId: z.ZodType<import("../index.js").AgentEffectiveContentId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentEffectiveContentId, unknown>>;
+    revision: z.ZodNumber;
+    kind: z.ZodEnum<{
+        prompt: "prompt";
+        skill: "skill";
+        rule: "rule";
+        agent_definition: "agent_definition";
+    }>;
+    name: z.ZodString;
+    summary: z.ZodOptional<z.ZodString>;
+    source: z.ZodType<import("../index.js").AgentEnvironmentSource, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentEnvironmentSource, unknown>>;
+    registration: z.ZodType<import("../index.js").AgentAvailabilityFact, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentAvailabilityFact, unknown>>;
+    enablement: z.ZodType<import("../index.js").AgentAvailabilityFact, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentAvailabilityFact, unknown>>;
+    invocation: z.ZodType<"unknown" | "unavailable" | "user_and_model" | "user_only" | "model_only", unknown, z.core.$ZodTypeInternals<"unknown" | "unavailable" | "user_and_model" | "user_only" | "model_only", unknown>>;
+    modelCallability: z.ZodType<import("../index.js").AgentAvailabilityFact, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentAvailabilityFact, unknown>>;
+    extension: z.ZodOptional<z.ZodType<import("../index.js").AgentQualifiedExtensionReference, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentQualifiedExtensionReference, unknown>>>;
+    agentDefinition: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+        mode: z.ZodEnum<{
+            unknown: "unknown";
+            primary: "primary";
+            subagent: "subagent";
+            all: "all";
+        }>;
+        hidden: z.ZodType<import("../index.js").AgentAvailabilityFact, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentAvailabilityFact, unknown>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>>;
+export declare const AgentEffectiveContentDescriptorSchema: z.ZodType<AgentEffectiveContentDescriptor>;
+export declare const AgentEffectiveContentCatalogPortableSchema: z.ZodReadonly<z.ZodObject<{
+    revision: z.ZodNumber;
+    observedAt: z.ZodType<import("../index.js").AgentIsoDateTime, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIsoDateTime, unknown>>;
+    content: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        contentId: z.ZodType<import("../index.js").AgentEffectiveContentId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentEffectiveContentId, unknown>>;
+        revision: z.ZodNumber;
+        kind: z.ZodEnum<{
+            prompt: "prompt";
+            skill: "skill";
+            rule: "rule";
+            agent_definition: "agent_definition";
+        }>;
+        name: z.ZodString;
+        summary: z.ZodOptional<z.ZodString>;
+        source: z.ZodType<import("../index.js").AgentEnvironmentSource, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentEnvironmentSource, unknown>>;
+        registration: z.ZodType<import("../index.js").AgentAvailabilityFact, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentAvailabilityFact, unknown>>;
+        enablement: z.ZodType<import("../index.js").AgentAvailabilityFact, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentAvailabilityFact, unknown>>;
+        invocation: z.ZodType<"unknown" | "unavailable" | "user_and_model" | "user_only" | "model_only", unknown, z.core.$ZodTypeInternals<"unknown" | "unavailable" | "user_and_model" | "user_only" | "model_only", unknown>>;
+        modelCallability: z.ZodType<import("../index.js").AgentAvailabilityFact, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentAvailabilityFact, unknown>>;
+        extension: z.ZodOptional<z.ZodType<import("../index.js").AgentQualifiedExtensionReference, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentQualifiedExtensionReference, unknown>>>;
+        agentDefinition: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+            mode: z.ZodEnum<{
+                unknown: "unknown";
+                primary: "primary";
+                subagent: "subagent";
+                all: "all";
+            }>;
+            hidden: z.ZodType<import("../index.js").AgentAvailabilityFact, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentAvailabilityFact, unknown>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>>>;
+}, z.core.$strict>>;
+export declare const AgentEffectiveContentCatalogSchema: z.ZodType<AgentEffectiveContentCatalog>;
+//# sourceMappingURL=effectiveContent.d.ts.map