@agen-ai/agent-protocol 0.2.4 → 0.3.0

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

package/dist/zod/effectiveContent.js

@@ -0,0 +1,157 @@
+import { z } from "zod/v4";
+import {
+  AGENT_PROTOCOL_JSON_DEPTH_LIMIT,
+  agentProtocolSerializedJsonBytes
+} from "../foundation/types.js";
+import { compareStringsByUnicodeCodePoint } from "../foundation/ordering.js";
+import {
+  AGENT_EFFECTIVE_CONTENT_CATALOG_BYTES_LIMIT,
+  AGENT_EFFECTIVE_CONTENT_CATALOG_MAX_LENGTH,
+  AGENT_EFFECTIVE_CONTENT_KINDS,
+  AGENT_EFFECTIVE_CONTENT_NAME_MAX_LENGTH,
+  AGENT_EFFECTIVE_CONTENT_SUMMARY_MAX_LENGTH,
+  AGENT_DEFINITION_MODES
+} from "../effectiveContent/types.js";
+import {
+  AgentAvailabilityFactSchema,
+  AgentEnvironmentSourceSchema,
+  AgentInvocationPostureSchema,
+  AgentQualifiedExtensionReferenceSchema
+} from "./environmentFacts.js";
+import {
+  AgentEffectiveContentIdSchema,
+  AgentIsoDateTimeSchema,
+  createAgentCanonicalNonBlankStringSchema,
+  withAcyclicProtocolInput
+} from "./foundation.js";
+const PositiveSafeIntegerSchema = z.number().int().positive().max(Number.MAX_SAFE_INTEGER);
+const NameSchema = createAgentCanonicalNonBlankStringSchema(
+  AGENT_EFFECTIVE_CONTENT_NAME_MAX_LENGTH
+);
+const SummarySchema = createAgentCanonicalNonBlankStringSchema(
+  AGENT_EFFECTIVE_CONTENT_SUMMARY_MAX_LENGTH
+);
+const AgentDefinitionObservationSchema = z.object({
+  mode: z.enum(AGENT_DEFINITION_MODES),
+  hidden: AgentAvailabilityFactSchema
+}).strict().readonly();
+const AgentEffectiveContentDescriptorPortableSchema = z.object({
+  contentId: AgentEffectiveContentIdSchema,
+  revision: PositiveSafeIntegerSchema,
+  kind: z.enum(AGENT_EFFECTIVE_CONTENT_KINDS),
+  name: NameSchema,
+  summary: SummarySchema.optional(),
+  source: AgentEnvironmentSourceSchema,
+  registration: AgentAvailabilityFactSchema,
+  enablement: AgentAvailabilityFactSchema,
+  invocation: AgentInvocationPostureSchema,
+  modelCallability: AgentAvailabilityFactSchema,
+  extension: AgentQualifiedExtensionReferenceSchema.optional(),
+  agentDefinition: AgentDefinitionObservationSchema.optional()
+}).strict().readonly();
+function validateEffectiveContentSemantics(descriptor, context) {
+  if (descriptor.agentDefinition && descriptor.kind !== "agent_definition") {
+    context.addIssue({
+      code: "custom",
+      path: ["agentDefinition"],
+      message: "Only agent definitions can carry definition observations."
+    });
+  }
+  const unavailable = descriptor.registration.kind === "known" && !descriptor.registration.value || descriptor.enablement.kind === "known" && !descriptor.enablement.value;
+  const positiveInvocation = descriptor.invocation === "user_and_model" || descriptor.invocation === "user_only" || descriptor.invocation === "model_only";
+  if (unavailable && positiveInvocation) {
+    context.addIssue({
+      code: "custom",
+      path: ["invocation"],
+      message: "Denied registration or enablement cannot advertise a positive invocation posture."
+    });
+  }
+  if (unavailable && descriptor.modelCallability.kind === "known" && descriptor.modelCallability.value) {
+    context.addIssue({
+      code: "custom",
+      path: ["modelCallability"],
+      message: "Denied registration or enablement cannot be model-callable."
+    });
+  }
+  if (descriptor.modelCallability.kind !== "known") return;
+  const modelIsIncluded = descriptor.invocation === "user_and_model" || descriptor.invocation === "model_only";
+  const modelIsExcluded = descriptor.invocation === "user_only" || descriptor.invocation === "unavailable";
+  if (modelIsIncluded && !descriptor.modelCallability.value || modelIsExcluded && descriptor.modelCallability.value) {
+    context.addIssue({
+      code: "custom",
+      path: ["modelCallability"],
+      message: "modelCallability must agree with the explicit invocation posture."
+    });
+  }
+}
+const AgentEffectiveContentDescriptorSchema = withAcyclicProtocolInput(
+  AgentEffectiveContentDescriptorPortableSchema,
+  {
+    maxDepth: AGENT_PROTOCOL_JSON_DEPTH_LIMIT,
+    maxCollectionLength: AGENT_EFFECTIVE_CONTENT_CATALOG_MAX_LENGTH
+  }
+).superRefine(validateEffectiveContentSemantics);
+const AgentEffectiveContentCatalogPortableSchema = z.object({
+  revision: PositiveSafeIntegerSchema,
+  observedAt: AgentIsoDateTimeSchema,
+  content: z.array(AgentEffectiveContentDescriptorPortableSchema).max(AGENT_EFFECTIVE_CONTENT_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: "Effective content IDs must be unique."
+      });
+    }
+    if (index > 0 && compareStringsByUnicodeCodePoint(values[index - 1], value) >= 0) {
+      context.addIssue({
+        code: "custom",
+        path: [...path, index],
+        message: "Effective content IDs must use canonical order."
+      });
+    }
+    seen.add(value);
+  });
+}
+const AgentEffectiveContentCatalogSchema = withAcyclicProtocolInput(
+  AgentEffectiveContentCatalogPortableSchema,
+  {
+    maxDepth: AGENT_PROTOCOL_JSON_DEPTH_LIMIT,
+    maxCollectionLength: AGENT_EFFECTIVE_CONTENT_CATALOG_MAX_LENGTH
+  }
+).superRefine((catalog, context) => {
+  if (agentProtocolSerializedJsonBytes(catalog) > AGENT_EFFECTIVE_CONTENT_CATALOG_BYTES_LIMIT) {
+    context.addIssue({
+      code: "custom",
+      path: ["content"],
+      message: "Effective content catalog exceeds its serialized UTF-8 byte limit."
+    });
+  }
+  addOrderedUniqueIssues(
+    catalog.content.map((descriptor) => descriptor.contentId),
+    ["content"],
+    context
+  );
+  catalog.content.forEach((descriptor, descriptorIndex) => {
+    const parsed = AgentEffectiveContentDescriptorSchema.safeParse(descriptor);
+    if (!parsed.success) {
+      for (const issue of parsed.error.issues) {
+        context.addIssue({
+          code: "custom",
+          path: ["content", descriptorIndex, ...issue.path],
+          message: issue.message
+        });
+      }
+    }
+  });
+});
+export {
+  AgentDefinitionObservationSchema,
+  AgentEffectiveContentCatalogPortableSchema,
+  AgentEffectiveContentCatalogSchema,
+  AgentEffectiveContentDescriptorPortableSchema,
+  AgentEffectiveContentDescriptorSchema
+};