@agen-ai/agent-protocol 0.2.2 → 0.2.3

package/dist/zod/resources.js

@@ -0,0 +1,82 @@
+import { z } from "zod/v4";
+import { AGENT_ARTIFACT_BYTE_SIZE_MAX } from "../artifacts/types.js";
+import {
+  AGENT_GENERATED_RESOURCE_DISPLAY_NAME_MAX_LENGTH,
+  AGENT_GENERATED_RESOURCE_KINDS,
+  AGENT_GENERATED_RESOURCE_STATUSES,
+  AGENT_GENERATED_RESOURCE_SUMMARY_MAX_LENGTH
+} from "../resources/types.js";
+import {
+  AgentArtifactIdSchema,
+  AgentCollaborationIdSchema,
+  AgentErrorSchema,
+  AgentGeneratedResourceIdSchema,
+  AgentIsoDateTimeSchema,
+  AgentOperationInvocationIdSchema,
+  AgentSessionIdSchema,
+  AgentTurnIdSchema,
+  createAgentCanonicalNonBlankStringSchema
+} from "./foundation.js";
+const PositiveSafeIntegerSchema = z.number().int().positive().max(Number.MAX_SAFE_INTEGER);
+const MediaTypeSchema = z.string().min(1).max(200).regex(/^[a-z0-9!#$&^_.+-]+\/[a-z0-9!#$&^_.+-]+$/u);
+const ProducerSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("session"), sessionId: AgentSessionIdSchema }).strict().readonly(),
+  z.object({ kind: z.literal("turn"), turnId: AgentTurnIdSchema }).strict().readonly(),
+  z.object({ kind: z.literal("operation"), invocationId: AgentOperationInvocationIdSchema }).strict().readonly(),
+  z.object({ kind: z.literal("collaboration"), collaborationId: AgentCollaborationIdSchema }).strict().readonly()
+]);
+const AgentGeneratedResourceDescriptorPortableSchema = z.object({
+  resourceId: AgentGeneratedResourceIdSchema,
+  kind: z.enum(AGENT_GENERATED_RESOURCE_KINDS),
+  status: z.enum(AGENT_GENERATED_RESOURCE_STATUSES),
+  displayName: createAgentCanonicalNonBlankStringSchema(AGENT_GENERATED_RESOURCE_DISPLAY_NAME_MAX_LENGTH),
+  producer: ProducerSchema,
+  summary: createAgentCanonicalNonBlankStringSchema(AGENT_GENERATED_RESOURCE_SUMMARY_MAX_LENGTH).optional(),
+  mediaType: MediaTypeSchema.optional(),
+  byteSize: z.number().int().nonnegative().max(AGENT_ARTIFACT_BYTE_SIZE_MAX).optional(),
+  sha256: z.string().regex(/^[a-f0-9]{64}$/u).optional(),
+  widthPixels: PositiveSafeIntegerSchema.optional(),
+  heightPixels: PositiveSafeIntegerSchema.optional(),
+  pageCount: PositiveSafeIntegerSchema.optional(),
+  artifactId: AgentArtifactIdSchema.optional(),
+  createdAt: AgentIsoDateTimeSchema,
+  expiresAt: AgentIsoDateTimeSchema.optional(),
+  error: AgentErrorSchema.optional()
+}).strict().readonly();
+const AgentGeneratedResourceDescriptorSchema = AgentGeneratedResourceDescriptorPortableSchema.superRefine((resource, context) => {
+  const available = resource.status === "available";
+  if (available !== (resource.artifactId !== void 0)) {
+    context.addIssue({ code: "custom", path: ["artifactId"], message: "Exactly available resources must reference a published artifact." });
+  }
+  if (available !== (resource.sha256 !== void 0)) {
+    context.addIssue({ code: "custom", path: ["sha256"], message: "Exactly available resources must include a SHA-256 digest." });
+  }
+  if (available && (resource.byteSize === void 0 || resource.mediaType === void 0)) {
+    context.addIssue({ code: "custom", path: ["byteSize"], message: "Available resources must include byte size and media type." });
+  }
+  if (resource.status === "unavailable" !== (resource.error !== void 0)) {
+    context.addIssue({ code: "custom", path: ["error"], message: "Exactly unavailable resources must include an error." });
+  }
+  if (resource.status === "expired" && resource.expiresAt === void 0) {
+    context.addIssue({ code: "custom", path: ["expiresAt"], message: "Expired resources must include their expiry." });
+  }
+  if (resource.widthPixels === void 0 !== (resource.heightPixels === void 0)) {
+    context.addIssue({ code: "custom", path: ["widthPixels"], message: "Image dimensions must include both width and height." });
+  }
+  if (available && resource.kind === "image" && resource.widthPixels === void 0) {
+    context.addIssue({ code: "custom", path: ["widthPixels"], message: "Available image resources must include decoded dimensions." });
+  }
+  if (resource.kind !== "image" && resource.widthPixels !== void 0) {
+    context.addIssue({ code: "custom", path: ["widthPixels"], message: "Only image resources may include pixel dimensions." });
+  }
+  if (resource.kind !== "document" && resource.pageCount !== void 0) {
+    context.addIssue({ code: "custom", path: ["pageCount"], message: "Only document resources may include a page count." });
+  }
+  if (resource.expiresAt !== void 0 && Date.parse(resource.expiresAt) <= Date.parse(resource.createdAt)) {
+    context.addIssue({ code: "custom", path: ["expiresAt"], message: "Resource expiry must follow creation." });
+  }
+});
+export {
+  AgentGeneratedResourceDescriptorPortableSchema,
+  AgentGeneratedResourceDescriptorSchema
+};

package/dist/zod/sessions.d.ts

@@ -1,61 +1,208 @@
 import { z } from 'zod/v4';
 import type { AgentSessionBinding, AgentSessionBranchSource, AgentSessionBranchInput, AgentSessionConfiguration, AgentSessionCreateInput, AgentSessionOpenInput, AgentSessionResumeInput } from '../sessions/types.js';
 export declare const AgentSessionBindingSchema: z.ZodType<AgentSessionBinding>;
-export declare const AgentSessionConfigurationPortableSchema: z.ZodReadonly<z.ZodObject<{
+export declare const AgentSessionConfigurationPortableSchema: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"managed">;
     revision: z.ZodType<import("../index.js").AgentConfigurationRevisionId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentConfigurationRevisionId, unknown>>;
-    values: z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("../index.js").AgentJsonValue, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentJsonValue, unknown>>>>;
-}, z.core.$strict>>;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"selected">;
+    revision: z.ZodType<import("../index.js").AgentConfigurationRevisionId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentConfigurationRevisionId, unknown>>;
+    catalogRevision: z.ZodNumber;
+    selections: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        key: z.ZodString;
+        fieldRevision: z.ZodNumber;
+        value: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            fieldKind: z.ZodLiteral<"boolean">;
+            value: z.ZodBoolean;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            fieldKind: z.ZodLiteral<"single_select">;
+            optionId: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            fieldKind: z.ZodLiteral<"bounded_integer">;
+            value: z.ZodNumber;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            fieldKind: z.ZodLiteral<"bounded_text">;
+            value: z.ZodString;
+        }, z.core.$strict>>], "fieldKind">;
+    }, z.core.$strict>>>>;
+}, z.core.$strict>>], "kind">;
 export declare const AgentSessionConfigurationSchema: z.ZodType<AgentSessionConfiguration>;
 export declare const AgentSessionCreateInputPortableSchema: z.ZodReadonly<z.ZodObject<{
     operation: z.ZodLiteral<"create">;
     sessionId: z.ZodType<import("../index.js").AgentSessionId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentSessionId, unknown>>;
-    configuration: z.ZodReadonly<z.ZodObject<{
+    configuration: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"managed">;
         revision: z.ZodType<import("../index.js").AgentConfigurationRevisionId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentConfigurationRevisionId, unknown>>;
-        values: z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("../index.js").AgentJsonValue, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentJsonValue, unknown>>>>;
-    }, z.core.$strict>>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"selected">;
+        revision: z.ZodType<import("../index.js").AgentConfigurationRevisionId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentConfigurationRevisionId, unknown>>;
+        catalogRevision: z.ZodNumber;
+        selections: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            key: z.ZodString;
+            fieldRevision: z.ZodNumber;
+            value: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+                fieldKind: z.ZodLiteral<"boolean">;
+                value: z.ZodBoolean;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                fieldKind: z.ZodLiteral<"single_select">;
+                optionId: z.ZodString;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                fieldKind: z.ZodLiteral<"bounded_integer">;
+                value: z.ZodNumber;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                fieldKind: z.ZodLiteral<"bounded_text">;
+                value: z.ZodString;
+            }, z.core.$strict>>], "fieldKind">;
+        }, z.core.$strict>>>>;
+    }, z.core.$strict>>], "kind">;
 }, z.core.$strict>>;
 export declare const AgentSessionResumeInputPortableSchema: z.ZodReadonly<z.ZodObject<{
     operation: z.ZodLiteral<"resume">;
     sessionId: z.ZodType<import("../index.js").AgentSessionId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentSessionId, unknown>>;
     binding: z.ZodType<AgentSessionBinding, unknown, z.core.$ZodTypeInternals<AgentSessionBinding, unknown>>;
-    configuration: z.ZodReadonly<z.ZodObject<{
+    configuration: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"managed">;
+        revision: z.ZodType<import("../index.js").AgentConfigurationRevisionId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentConfigurationRevisionId, unknown>>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"selected">;
         revision: z.ZodType<import("../index.js").AgentConfigurationRevisionId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentConfigurationRevisionId, unknown>>;
-        values: z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("../index.js").AgentJsonValue, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentJsonValue, unknown>>>>;
-    }, z.core.$strict>>;
+        catalogRevision: z.ZodNumber;
+        selections: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            key: z.ZodString;
+            fieldRevision: z.ZodNumber;
+            value: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+                fieldKind: z.ZodLiteral<"boolean">;
+                value: z.ZodBoolean;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                fieldKind: z.ZodLiteral<"single_select">;
+                optionId: z.ZodString;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                fieldKind: z.ZodLiteral<"bounded_integer">;
+                value: z.ZodNumber;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                fieldKind: z.ZodLiteral<"bounded_text">;
+                value: z.ZodString;
+            }, z.core.$strict>>], "fieldKind">;
+        }, z.core.$strict>>>>;
+    }, z.core.$strict>>], "kind">;
 }, z.core.$strict>>;
 export declare const AgentSessionBranchSourceSchema: z.ZodType<AgentSessionBranchSource>;
 export declare const AgentSessionBranchInputPortableSchema: z.ZodReadonly<z.ZodObject<{
     operation: z.ZodLiteral<"branch">;
     sessionId: z.ZodType<import("../index.js").AgentSessionId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentSessionId, unknown>>;
     source: z.ZodType<AgentSessionBranchSource, unknown, z.core.$ZodTypeInternals<AgentSessionBranchSource, unknown>>;
-    configuration: z.ZodReadonly<z.ZodObject<{
+    configuration: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"managed">;
         revision: z.ZodType<import("../index.js").AgentConfigurationRevisionId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentConfigurationRevisionId, unknown>>;
-        values: z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("../index.js").AgentJsonValue, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentJsonValue, unknown>>>>;
-    }, z.core.$strict>>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"selected">;
+        revision: z.ZodType<import("../index.js").AgentConfigurationRevisionId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentConfigurationRevisionId, unknown>>;
+        catalogRevision: z.ZodNumber;
+        selections: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            key: z.ZodString;
+            fieldRevision: z.ZodNumber;
+            value: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+                fieldKind: z.ZodLiteral<"boolean">;
+                value: z.ZodBoolean;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                fieldKind: z.ZodLiteral<"single_select">;
+                optionId: z.ZodString;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                fieldKind: z.ZodLiteral<"bounded_integer">;
+                value: z.ZodNumber;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                fieldKind: z.ZodLiteral<"bounded_text">;
+                value: z.ZodString;
+            }, z.core.$strict>>], "fieldKind">;
+        }, z.core.$strict>>>>;
+    }, z.core.$strict>>], "kind">;
 }, z.core.$strict>>;
 declare const AgentSessionOpenInputPortableSchema: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
     operation: z.ZodLiteral<"create">;
     sessionId: z.ZodType<import("../index.js").AgentSessionId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentSessionId, unknown>>;
-    configuration: z.ZodReadonly<z.ZodObject<{
+    configuration: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"managed">;
+        revision: z.ZodType<import("../index.js").AgentConfigurationRevisionId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentConfigurationRevisionId, unknown>>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"selected">;
         revision: z.ZodType<import("../index.js").AgentConfigurationRevisionId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentConfigurationRevisionId, unknown>>;
-        values: z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("../index.js").AgentJsonValue, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentJsonValue, unknown>>>>;
-    }, z.core.$strict>>;
+        catalogRevision: z.ZodNumber;
+        selections: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            key: z.ZodString;
+            fieldRevision: z.ZodNumber;
+            value: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+                fieldKind: z.ZodLiteral<"boolean">;
+                value: z.ZodBoolean;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                fieldKind: z.ZodLiteral<"single_select">;
+                optionId: z.ZodString;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                fieldKind: z.ZodLiteral<"bounded_integer">;
+                value: z.ZodNumber;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                fieldKind: z.ZodLiteral<"bounded_text">;
+                value: z.ZodString;
+            }, z.core.$strict>>], "fieldKind">;
+        }, z.core.$strict>>>>;
+    }, z.core.$strict>>], "kind">;
 }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
     operation: z.ZodLiteral<"resume">;
     sessionId: z.ZodType<import("../index.js").AgentSessionId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentSessionId, unknown>>;
     binding: z.ZodType<AgentSessionBinding, unknown, z.core.$ZodTypeInternals<AgentSessionBinding, unknown>>;
-    configuration: z.ZodReadonly<z.ZodObject<{
+    configuration: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"managed">;
         revision: z.ZodType<import("../index.js").AgentConfigurationRevisionId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentConfigurationRevisionId, unknown>>;
-        values: z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("../index.js").AgentJsonValue, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentJsonValue, unknown>>>>;
-    }, z.core.$strict>>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"selected">;
+        revision: z.ZodType<import("../index.js").AgentConfigurationRevisionId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentConfigurationRevisionId, unknown>>;
+        catalogRevision: z.ZodNumber;
+        selections: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            key: z.ZodString;
+            fieldRevision: z.ZodNumber;
+            value: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+                fieldKind: z.ZodLiteral<"boolean">;
+                value: z.ZodBoolean;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                fieldKind: z.ZodLiteral<"single_select">;
+                optionId: z.ZodString;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                fieldKind: z.ZodLiteral<"bounded_integer">;
+                value: z.ZodNumber;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                fieldKind: z.ZodLiteral<"bounded_text">;
+                value: z.ZodString;
+            }, z.core.$strict>>], "fieldKind">;
+        }, z.core.$strict>>>>;
+    }, z.core.$strict>>], "kind">;
 }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
     operation: z.ZodLiteral<"branch">;
     sessionId: z.ZodType<import("../index.js").AgentSessionId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentSessionId, unknown>>;
     source: z.ZodType<AgentSessionBranchSource, unknown, z.core.$ZodTypeInternals<AgentSessionBranchSource, unknown>>;
-    configuration: z.ZodReadonly<z.ZodObject<{
+    configuration: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"managed">;
+        revision: z.ZodType<import("../index.js").AgentConfigurationRevisionId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentConfigurationRevisionId, unknown>>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"selected">;
         revision: z.ZodType<import("../index.js").AgentConfigurationRevisionId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentConfigurationRevisionId, unknown>>;
-        values: z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("../index.js").AgentJsonValue, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentJsonValue, unknown>>>>;
-    }, z.core.$strict>>;
+        catalogRevision: z.ZodNumber;
+        selections: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            key: z.ZodString;
+            fieldRevision: z.ZodNumber;
+            value: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+                fieldKind: z.ZodLiteral<"boolean">;
+                value: z.ZodBoolean;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                fieldKind: z.ZodLiteral<"single_select">;
+                optionId: z.ZodString;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                fieldKind: z.ZodLiteral<"bounded_integer">;
+                value: z.ZodNumber;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                fieldKind: z.ZodLiteral<"bounded_text">;
+                value: z.ZodString;
+            }, z.core.$strict>>], "fieldKind">;
+        }, z.core.$strict>>>>;
+    }, z.core.$strict>>], "kind">;
 }, z.core.$strict>>], "operation">;
 export declare const AgentSessionCreateInputSchema: z.ZodType<AgentSessionCreateInput>;
 export declare const AgentSessionResumeInputSchema: z.ZodType<AgentSessionResumeInput>;

package/dist/zod/sessions.js

@@ -1,48 +1,72 @@
 import { z } from "zod/v4";
+import { compareStringsByUnicodeCodePoint } from "../foundation/ordering.js";
 import {
-  AGENT_PROTOCOL_COLLECTION_MAX_LENGTH,
   AGENT_PROTOCOL_JSON_BYTES_LIMIT,
-  AGENT_PROTOCOL_JSON_DEPTH_LIMIT,
   agentProtocolSerializedJsonBytes
 } from "../foundation/types.js";
+import { AGENT_CONFIGURATION_FIELDS_MAX_LENGTH } from "../configuration/types.js";
 import {
   AgentConfigurationRevisionIdSchema,
-  AgentJsonObjectKeySchema,
-  AgentJsonValuePortableSchema,
+  AgentCanonicalIdValueSchema,
   AgentProviderConversationIdSchema,
   AgentProviderHistoryAnchorSchema,
   AgentSessionIdSchema,
-  AgentTurnIdSchema,
-  withAcyclicProtocolInput
+  AgentTurnIdSchema
 } from "./foundation.js";
-const SESSION_CONFIGURATION_JSON_DEPTH_OFFSET = 2;
-const SESSION_OPEN_JSON_DEPTH_OFFSET = 3;
+import { AgentConfigurationValueSchema } from "./configuration.js";
+const PositiveSafeIntegerSchema = z.number().int().positive().max(Number.MAX_SAFE_INTEGER);
 const AgentSessionBindingSchema = z.object({
   conversationId: AgentProviderConversationIdSchema,
   historyAnchor: AgentProviderHistoryAnchorSchema.optional()
 }).strict().readonly();
-const AgentSessionConfigurationPortableSchema = z.object({
-  revision: AgentConfigurationRevisionIdSchema,
-  values: z.record(
-    AgentJsonObjectKeySchema,
-    AgentJsonValuePortableSchema
-  ).readonly()
-}).strict().readonly();
-const AgentSessionConfigurationSchema = withAcyclicProtocolInput(AgentSessionConfigurationPortableSchema, {
-  maxDepth: AGENT_PROTOCOL_JSON_DEPTH_LIMIT + SESSION_CONFIGURATION_JSON_DEPTH_OFFSET,
-  maxCollectionLength: AGENT_PROTOCOL_COLLECTION_MAX_LENGTH
-}).superRefine((configuration, context) => {
-  if (Object.keys(configuration.values).length > AGENT_PROTOCOL_COLLECTION_MAX_LENGTH) {
-    context.addIssue({
-      code: "custom",
-      path: ["values"],
-      message: `Session configuration cannot exceed ${AGENT_PROTOCOL_COLLECTION_MAX_LENGTH} entries.`
+const AgentSessionConfigurationPortableSchema = z.discriminatedUnion(
+  "kind",
+  [
+    z.object({
+      kind: z.literal("managed"),
+      revision: AgentConfigurationRevisionIdSchema
+    }).strict().readonly(),
+    z.object({
+      kind: z.literal("selected"),
+      revision: AgentConfigurationRevisionIdSchema,
+      catalogRevision: PositiveSafeIntegerSchema,
+      selections: z.array(
+        z.object({
+          key: AgentCanonicalIdValueSchema,
+          fieldRevision: PositiveSafeIntegerSchema,
+          value: AgentConfigurationValueSchema
+        }).strict().readonly()
+      ).max(AGENT_CONFIGURATION_FIELDS_MAX_LENGTH).readonly()
+    }).strict().readonly()
+  ]
+);
+const AgentSessionConfigurationSchema = AgentSessionConfigurationPortableSchema.superRefine((configuration, context) => {
+  if (configuration.kind === "selected") {
+    const keys = /* @__PURE__ */ new Set();
+    let previousKey = "";
+    configuration.selections.forEach((selection, selectionIndex) => {
+      if (keys.has(selection.key)) {
+        context.addIssue({
+          code: "custom",
+          path: ["selections", selectionIndex, "key"],
+          message: "Session configuration keys must be unique."
+        });
+      }
+      if (selectionIndex > 0 && compareStringsByUnicodeCodePoint(previousKey, selection.key) >= 0) {
+        context.addIssue({
+          code: "custom",
+          path: ["selections", selectionIndex, "key"],
+          message: "Session configuration selections must be ordered by key."
+        });
+      }
+      keys.add(selection.key);
+      previousKey = selection.key;
     });
   }
-  if (agentProtocolSerializedJsonBytes(configuration.values) > AGENT_PROTOCOL_JSON_BYTES_LIMIT) {
+  if (agentProtocolSerializedJsonBytes(configuration) > AGENT_PROTOCOL_JSON_BYTES_LIMIT) {
     context.addIssue({
       code: "custom",
-      path: ["values"],
+      path: [],
       message: `Session configuration cannot exceed ${AGENT_PROTOCOL_JSON_BYTES_LIMIT} serialized bytes.`
     });
   }
@@ -92,22 +116,10 @@ function validateSessionOpenInput(input, context) {
     });
   }
 }
-const AgentSessionCreateInputSchema = withAcyclicProtocolInput(AgentSessionCreateInputPortableSchema, {
-  maxDepth: AGENT_PROTOCOL_JSON_DEPTH_LIMIT + SESSION_OPEN_JSON_DEPTH_OFFSET,
-  maxCollectionLength: AGENT_PROTOCOL_COLLECTION_MAX_LENGTH
-}).superRefine(validateSessionOpenInput);
-const AgentSessionResumeInputSchema = withAcyclicProtocolInput(AgentSessionResumeInputPortableSchema, {
-  maxDepth: AGENT_PROTOCOL_JSON_DEPTH_LIMIT + SESSION_OPEN_JSON_DEPTH_OFFSET,
-  maxCollectionLength: AGENT_PROTOCOL_COLLECTION_MAX_LENGTH
-}).superRefine(validateSessionOpenInput);
-const AgentSessionBranchInputSchema = withAcyclicProtocolInput(AgentSessionBranchInputPortableSchema, {
-  maxDepth: AGENT_PROTOCOL_JSON_DEPTH_LIMIT + SESSION_OPEN_JSON_DEPTH_OFFSET,
-  maxCollectionLength: AGENT_PROTOCOL_COLLECTION_MAX_LENGTH
-}).superRefine(validateSessionOpenInput);
-const AgentSessionOpenInputSchema = withAcyclicProtocolInput(AgentSessionOpenInputPortableSchema, {
-  maxDepth: AGENT_PROTOCOL_JSON_DEPTH_LIMIT + SESSION_OPEN_JSON_DEPTH_OFFSET,
-  maxCollectionLength: AGENT_PROTOCOL_COLLECTION_MAX_LENGTH
-}).superRefine(validateSessionOpenInput);
+const AgentSessionCreateInputSchema = AgentSessionCreateInputPortableSchema.superRefine(validateSessionOpenInput);
+const AgentSessionResumeInputSchema = AgentSessionResumeInputPortableSchema.superRefine(validateSessionOpenInput);
+const AgentSessionBranchInputSchema = AgentSessionBranchInputPortableSchema.superRefine(validateSessionOpenInput);
+const AgentSessionOpenInputSchema = AgentSessionOpenInputPortableSchema.superRefine(validateSessionOpenInput);
 export {
   AgentSessionBindingSchema,
   AgentSessionBranchInputPortableSchema,

package/dist/zod/typeEquality.generated.d.ts

@@ -1,16 +1,28 @@
 import type { z } from 'zod/v4';
 import type { AgentArtifactDescriptor } from '../artifacts/types.js';
 import type { AgentCapabilities } from '../capabilities/types.js';
+import type { AgentCollaborationControlInput, AgentCollaborationNode, AgentCollaborationSpawnInput } from '../collaboration/types.js';
+import type { AgentConfigurationCatalog, AgentConfigurationSelectionInput } from '../configuration/types.js';
 import type { AgentEvent } from '../events/types.js';
 import type { AgentError, AgentJsonValue, AgentProviderRefs } from '../foundation/types.js';
+import type { AgentIntegrationCatalog, AgentIntegrationDescriptor } from '../integrations/types.js';
+import type { AgentManagedContentCatalog, AgentManagedContentDescriptor } from '../managedContent/types.js';
+import type { AgentOperationCatalog, AgentOperationDescriptor, AgentOperationInvocation, AgentOperationResult } from '../operations/types.js';
 import type { AgentRequest, AgentRequestResolution } from '../requests/types.js';
+import type { AgentGeneratedResourceDescriptor } from '../resources/types.js';
 import type { AgentSessionBinding, AgentSessionConfiguration, AgentSessionOpenInput } from '../sessions/types.js';
 import type { AgentItemSnapshot, AgentTurnInputContent, AgentTurnInterruptionInput, AgentTurnRunInput } from '../turns/types.js';
 import { AgentArtifactDescriptorSchema } from './artifacts.js';
 import { AgentCapabilitiesSchema } from './capabilities.js';
+import { AgentCollaborationControlInputSchema, AgentCollaborationNodeSchema, AgentCollaborationSpawnInputSchema } from './collaboration.js';
+import { AgentConfigurationCatalogSchema, AgentConfigurationSelectionInputSchema } from './configuration.js';
 import { AgentEventSchema } from './events.js';
 import { AgentErrorSchema, AgentJsonValueSchema, AgentProviderRefsSchema } from './foundation.js';
+import { AgentIntegrationCatalogSchema, AgentIntegrationDescriptorSchema } from './integrations.js';
+import { AgentManagedContentCatalogSchema, AgentManagedContentDescriptorSchema } from './managedContent.js';
+import { AgentOperationCatalogSchema, AgentOperationDescriptorSchema, AgentOperationInvocationSchema, AgentOperationResultSchema } from './operations.js';
 import { AgentRequestResolutionSchema, AgentRequestSchema } from './requests.js';
+import { AgentGeneratedResourceDescriptorSchema } from './resources.js';
 import { AgentSessionBindingSchema, AgentSessionConfigurationSchema, AgentSessionOpenInputSchema } from './sessions.js';
 import { AgentItemSnapshotSchema, AgentTurnInputContentSchema, AgentTurnInterruptionInputSchema, AgentTurnRunInputSchema } from './turns.js';
 type Extends<Left, Right> = [Left] extends [Right] ? true : false;
@@ -40,6 +52,34 @@ export type AgentProtocolSchemaTypeAssertions = readonly [
     Assert<Extends<AgentRequest, z.output<typeof AgentRequestSchema>>>,
     Assert<Extends<z.output<typeof AgentRequestResolutionSchema>, AgentRequestResolution>>,
     Assert<Extends<AgentRequestResolution, z.output<typeof AgentRequestResolutionSchema>>>,
+    Assert<Extends<z.output<typeof AgentOperationCatalogSchema>, AgentOperationCatalog>>,
+    Assert<Extends<AgentOperationCatalog, z.output<typeof AgentOperationCatalogSchema>>>,
+    Assert<Extends<z.output<typeof AgentOperationDescriptorSchema>, AgentOperationDescriptor>>,
+    Assert<Extends<AgentOperationDescriptor, z.output<typeof AgentOperationDescriptorSchema>>>,
+    Assert<Extends<z.output<typeof AgentOperationInvocationSchema>, AgentOperationInvocation>>,
+    Assert<Extends<AgentOperationInvocation, z.output<typeof AgentOperationInvocationSchema>>>,
+    Assert<Extends<z.output<typeof AgentOperationResultSchema>, AgentOperationResult>>,
+    Assert<Extends<AgentOperationResult, z.output<typeof AgentOperationResultSchema>>>,
+    Assert<Extends<z.output<typeof AgentManagedContentCatalogSchema>, AgentManagedContentCatalog>>,
+    Assert<Extends<AgentManagedContentCatalog, z.output<typeof AgentManagedContentCatalogSchema>>>,
+    Assert<Extends<z.output<typeof AgentManagedContentDescriptorSchema>, AgentManagedContentDescriptor>>,
+    Assert<Extends<AgentManagedContentDescriptor, z.output<typeof AgentManagedContentDescriptorSchema>>>,
+    Assert<Extends<z.output<typeof AgentConfigurationCatalogSchema>, AgentConfigurationCatalog>>,
+    Assert<Extends<AgentConfigurationCatalog, z.output<typeof AgentConfigurationCatalogSchema>>>,
+    Assert<Extends<z.output<typeof AgentConfigurationSelectionInputSchema>, AgentConfigurationSelectionInput>>,
+    Assert<Extends<AgentConfigurationSelectionInput, z.output<typeof AgentConfigurationSelectionInputSchema>>>,
+    Assert<Extends<z.output<typeof AgentIntegrationCatalogSchema>, AgentIntegrationCatalog>>,
+    Assert<Extends<AgentIntegrationCatalog, z.output<typeof AgentIntegrationCatalogSchema>>>,
+    Assert<Extends<z.output<typeof AgentIntegrationDescriptorSchema>, AgentIntegrationDescriptor>>,
+    Assert<Extends<AgentIntegrationDescriptor, z.output<typeof AgentIntegrationDescriptorSchema>>>,
+    Assert<Extends<z.output<typeof AgentCollaborationNodeSchema>, AgentCollaborationNode>>,
+    Assert<Extends<AgentCollaborationNode, z.output<typeof AgentCollaborationNodeSchema>>>,
+    Assert<Extends<z.output<typeof AgentCollaborationSpawnInputSchema>, AgentCollaborationSpawnInput>>,
+    Assert<Extends<AgentCollaborationSpawnInput, z.output<typeof AgentCollaborationSpawnInputSchema>>>,
+    Assert<Extends<z.output<typeof AgentCollaborationControlInputSchema>, AgentCollaborationControlInput>>,
+    Assert<Extends<AgentCollaborationControlInput, z.output<typeof AgentCollaborationControlInputSchema>>>,
+    Assert<Extends<z.output<typeof AgentGeneratedResourceDescriptorSchema>, AgentGeneratedResourceDescriptor>>,
+    Assert<Extends<AgentGeneratedResourceDescriptor, z.output<typeof AgentGeneratedResourceDescriptorSchema>>>,
     Assert<Extends<z.output<typeof AgentCapabilitiesSchema>, AgentCapabilities>>,
     Assert<Extends<AgentCapabilities, z.output<typeof AgentCapabilitiesSchema>>>,
     Assert<Extends<z.output<typeof AgentArtifactDescriptorSchema>, AgentArtifactDescriptor>>,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agen-ai/agent-protocol",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "private": false,
   "description": "Provider-neutral sessions, turns, requests, capabilities, artifacts, and events for coding-agent runtimes.",
   "type": "module",
@@ -32,6 +32,30 @@
       "types": "./dist/public/requests.d.ts",
       "import": "./dist/public/requests.js"
     },
+    "./operations": {
+      "types": "./dist/public/operations.d.ts",
+      "import": "./dist/public/operations.js"
+    },
+    "./managed-content": {
+      "types": "./dist/public/managedContent.d.ts",
+      "import": "./dist/public/managedContent.js"
+    },
+    "./configuration": {
+      "types": "./dist/public/configuration.d.ts",
+      "import": "./dist/public/configuration.js"
+    },
+    "./integrations": {
+      "types": "./dist/public/integrations.d.ts",
+      "import": "./dist/public/integrations.js"
+    },
+    "./collaboration": {
+      "types": "./dist/public/collaboration.d.ts",
+      "import": "./dist/public/collaboration.js"
+    },
+    "./resources": {
+      "types": "./dist/public/resources.d.ts",
+      "import": "./dist/public/resources.js"
+    },
     "./events": {
       "types": "./dist/public/events.d.ts",
       "import": "./dist/public/events.js"
@@ -56,7 +80,7 @@
   },
   "dependencies": {
     "zod": "4.4.3",
-    "@agen-ai/validation": "^0.2.2"
+    "@agen-ai/validation": "^0.2.3"
   },
   "devDependencies": {
     "ajv": "8.17.1",