@agen-ai/agent-protocol 0.4.1 → 0.4.2

package/dist/zod/sessionInteractions.js

@@ -3,15 +3,26 @@ import {
   AGENT_PROTOCOL_JSON_DEPTH_LIMIT,
   agentProtocolSerializedJsonBytes
 } from "../foundation/types.js";
+import {
+  AGENT_ELICITATION_FIELDS_MAX_LENGTH,
+  AGENT_ELICITATION_OPTIONS_MAX_LENGTH
+} from "../requests/types.js";
 import {
   AGENT_SESSION_DECISION_CHOICE_DESCRIPTION_MAX_LENGTH,
   AGENT_SESSION_DECISION_CHOICE_ID_BYTES_LIMIT,
   AGENT_SESSION_DECISION_CHOICES_MAX_LENGTH,
   AGENT_SESSION_DECISION_DESCRIPTION_MAX_LENGTH,
-  AGENT_SESSION_DECISION_REQUEST_BYTES_LIMIT,
   AGENT_SESSION_DECISION_RESPONSE_BYTES_LIMIT,
   AGENT_SESSION_DECISION_TITLE_MAX_LENGTH,
-  AGENT_SESSION_DECISION_WORKSPACE_PATH_BYTES_LIMIT
+  AGENT_SESSION_DECISION_WORKSPACE_PATH_BYTES_LIMIT,
+  AGENT_SESSION_FORM_RESPONSE_BYTES_LIMIT,
+  AGENT_SESSION_PLAN_ID_BYTES_LIMIT,
+  AGENT_SESSION_PLAN_REVISION_BYTES_LIMIT,
+  AGENT_SESSION_PLAN_REVIEW_FEEDBACK_BYTES_LIMIT,
+  AGENT_SESSION_PLAN_REVIEW_FEEDBACK_MAX_LENGTH,
+  AGENT_SESSION_PLAN_REVIEW_RESPONSE_BYTES_LIMIT,
+  AGENT_SESSION_PLAN_TEXT_BYTES_LIMIT,
+  AGENT_SESSION_REQUEST_BYTES_LIMIT
 } from "../sessionInteractions/types.js";
 import {
   AgentIsoDateTimeSchema,
@@ -21,19 +32,48 @@ import {
   createAgentCanonicalOpaqueStringSchema,
   withAcyclicProtocolInput
 } from "./foundation.js";
+import {
+  AgentElicitationAnswerSchema,
+  AgentElicitationFieldSchema,
+  refineAgentElicitationAnswers,
+  refineAgentElicitationFields
+} from "./requests.js";
 const encoder = new TextEncoder();
+const inputBounds = {
+  maxDepth: AGENT_PROTOCOL_JSON_DEPTH_LIMIT,
+  maxCollectionLength: AGENT_ELICITATION_OPTIONS_MAX_LENGTH,
+  requireJsonData: true
+};
 const SingleLineTextSchema = createAgentCanonicalNonBlankStringSchema(
   AGENT_SESSION_DECISION_TITLE_MAX_LENGTH
 ).regex(/^[^\u0000-\u001F\u007F-\u009F]*$/u);
 function descriptionSchema(maxLength) {
   return createAgentCanonicalNonBlankStringSchema(maxLength).regex(/^[^\u0000-\u0009\u000B-\u001F\u007F-\u009F]*$/u);
 }
-const AgentSessionDecisionChoiceIdSchema = createAgentCanonicalOpaqueStringSchema(
-  AGENT_SESSION_DECISION_CHOICE_ID_BYTES_LIMIT,
-  "Session decision choice IDs must be canonical and contain no control characters."
-).refine(
-  (value) => encoder.encode(value).byteLength <= AGENT_SESSION_DECISION_CHOICE_ID_BYTES_LIMIT,
-  "Session decision choice ID exceeds its UTF-8 byte limit."
+function nominalIdSchema(byteLimit) {
+  return createAgentCanonicalOpaqueStringSchema(
+    byteLimit,
+    "Session identities must be canonical and contain no control characters."
+  ).refine(
+    (value) => encoder.encode(value).byteLength <= byteLimit,
+    "Session identity exceeds its UTF-8 byte limit."
+  );
+}
+function nonemptyArraySchema(schema, maxLength) {
+  return z.array(schema).min(1).max(maxLength).readonly();
+}
+const AgentSessionDecisionChoiceIdSchema = nominalIdSchema(
+  AGENT_SESSION_DECISION_CHOICE_ID_BYTES_LIMIT
+);
+const AgentSessionFormChoiceIdSchema = nominalIdSchema(
+  AGENT_SESSION_DECISION_CHOICE_ID_BYTES_LIMIT
+);
+const AgentSessionPlanReviewChoiceIdSchema = nominalIdSchema(
+  AGENT_SESSION_DECISION_CHOICE_ID_BYTES_LIMIT
+);
+const AgentSessionPlanIdSchema = nominalIdSchema(AGENT_SESSION_PLAN_ID_BYTES_LIMIT);
+const AgentSessionPlanRevisionSchema = nominalIdSchema(
+  AGENT_SESSION_PLAN_REVISION_BYTES_LIMIT
 );
 const AgentSessionWorkspaceTargetSchema = z.object({
   kind: z.literal("workspace"),
@@ -63,45 +103,155 @@ const AgentSessionDecisionChoiceSchema = z.object({
   description: descriptionSchema(AGENT_SESSION_DECISION_CHOICE_DESCRIPTION_MAX_LENGTH),
   consequence: AgentSessionDecisionConsequenceSchema
 }).strict().readonly();
-const ChoicesSchema = z.array(AgentSessionDecisionChoiceSchema).min(1).max(AGENT_SESSION_DECISION_CHOICES_MAX_LENGTH).readonly();
-const AgentSessionDecisionRequestPortableSchema = z.object({
-  kind: z.literal("decision"),
+const requestFields = {
   requestId: AgentRequestIdSchema,
   sessionId: AgentSessionIdSchema,
   title: SingleLineTextSchema,
   description: descriptionSchema(AGENT_SESSION_DECISION_DESCRIPTION_MAX_LENGTH).optional(),
+  expiresAt: AgentIsoDateTimeSchema.optional()
+};
+const AgentSessionDecisionRequestPortableSchema = z.object({
+  ...requestFields,
+  kind: z.literal("decision"),
   target: AgentSessionWorkspaceTargetSchema,
-  expiresAt: AgentIsoDateTimeSchema,
-  choices: ChoicesSchema
+  choices: nonemptyArraySchema(AgentSessionDecisionChoiceSchema, AGENT_SESSION_DECISION_CHOICES_MAX_LENGTH)
 }).strict().readonly();
-const inputBounds = {
-  maxDepth: AGENT_PROTOCOL_JSON_DEPTH_LIMIT,
-  maxCollectionLength: AGENT_SESSION_DECISION_CHOICES_MAX_LENGTH,
-  requireJsonData: true
+const offeredChoiceFields = {
+  label: SingleLineTextSchema,
+  description: descriptionSchema(AGENT_SESSION_DECISION_CHOICE_DESCRIPTION_MAX_LENGTH).optional()
 };
-const AgentSessionDecisionRequestSchema = withAcyclicProtocolInput(AgentSessionDecisionRequestPortableSchema, inputBounds).superRefine((request, context) => {
-  if (agentProtocolSerializedJsonBytes(request) > AGENT_SESSION_DECISION_REQUEST_BYTES_LIMIT) {
-    context.addIssue({ code: "custom", message: "Session decision exceeds its serialized UTF-8 byte limit." });
+const AgentSessionFormChoicePortableSchema = z.discriminatedUnion("action", [
+  z.object({ ...offeredChoiceFields, choiceId: AgentSessionFormChoiceIdSchema, action: z.literal("submit") }).strict().readonly(),
+  z.object({ ...offeredChoiceFields, choiceId: AgentSessionFormChoiceIdSchema, action: z.literal("cancel") }).strict().readonly()
+]);
+const AgentSessionFormChoiceSchema = withAcyclicProtocolInput(AgentSessionFormChoicePortableSchema, inputBounds);
+const AgentSessionFormRequestPortableSchema = z.object({
+  ...requestFields,
+  kind: z.literal("form"),
+  fields: nonemptyArraySchema(AgentElicitationFieldSchema, AGENT_ELICITATION_FIELDS_MAX_LENGTH),
+  choices: nonemptyArraySchema(AgentSessionFormChoicePortableSchema, AGENT_SESSION_DECISION_CHOICES_MAX_LENGTH)
+}).strict().readonly();
+const AgentSessionPlanSnapshotPortableSchema = z.object({
+  planId: AgentSessionPlanIdSchema,
+  revision: AgentSessionPlanRevisionSchema,
+  title: SingleLineTextSchema,
+  content: z.object({
+    kind: z.literal("text"),
+    format: z.enum(["plain_text", "markdown"]),
+    text: z.string().min(1).max(AGENT_SESSION_PLAN_TEXT_BYTES_LIMIT)
+  }).strict().readonly()
+}).strict().readonly();
+const AgentSessionPlanSnapshotSchema = AgentSessionPlanSnapshotPortableSchema.superRefine((plan, context) => {
+  if (encoder.encode(plan.content.text).byteLength > AGENT_SESSION_PLAN_TEXT_BYTES_LIMIT) {
+    context.addIssue({ code: "custom", path: ["content", "text"], message: "Plan text exceeds its UTF-8 byte limit." });
+  }
+});
+const AgentSessionPlanReviewChoicePortableSchema = z.object({
+  ...offeredChoiceFields,
+  choiceId: AgentSessionPlanReviewChoiceIdSchema,
+  action: z.enum(["approve", "revise", "abandon"])
+}).strict().readonly();
+const AgentSessionPlanReviewChoiceSchema = withAcyclicProtocolInput(AgentSessionPlanReviewChoicePortableSchema, inputBounds);
+const AgentSessionPlanReviewRequestPortableSchema = z.object({
+  ...requestFields,
+  kind: z.literal("plan_review"),
+  plan: AgentSessionPlanSnapshotPortableSchema,
+  choices: nonemptyArraySchema(AgentSessionPlanReviewChoicePortableSchema, AGENT_SESSION_DECISION_CHOICES_MAX_LENGTH)
+}).strict().readonly();
+const AgentSessionRequestPortableSchema = z.discriminatedUnion("kind", [
+  AgentSessionDecisionRequestPortableSchema,
+  AgentSessionFormRequestPortableSchema,
+  AgentSessionPlanReviewRequestPortableSchema
+]);
+function refineSessionRequest(request, context) {
+  if (agentProtocolSerializedJsonBytes(request) > AGENT_SESSION_REQUEST_BYTES_LIMIT) {
+    context.addIssue({ code: "custom", message: "Session request exceeds its serialized UTF-8 byte limit." });
   }
-  const seen = /* @__PURE__ */ new Set();
+  const seenIds = /* @__PURE__ */ new Set();
+  const seenActions = /* @__PURE__ */ new Set();
   request.choices.forEach((choice, index) => {
-    if (seen.has(choice.choiceId)) {
-      context.addIssue({
-        code: "custom",
-        path: ["choices", index, "choiceId"],
-        message: "Session decision choices must have unique IDs."
-      });
+    if (seenIds.has(choice.choiceId)) {
+      context.addIssue({ code: "custom", path: ["choices", index, "choiceId"], message: "Session choices must have unique IDs." });
+    }
+    seenIds.add(choice.choiceId);
+    if ("action" in choice) {
+      if (seenActions.has(choice.action)) {
+        context.addIssue({ code: "custom", path: ["choices", index, "action"], message: "Session choices must have distinct actions." });
+      }
+      seenActions.add(choice.action);
     }
-    seen.add(choice.choiceId);
   });
-});
+  if (request.kind === "form") {
+    refineAgentElicitationFields(request.fields, context);
+    if (!seenActions.has("submit")) {
+      context.addIssue({ code: "custom", path: ["choices"], message: "Session forms must offer exactly one submit choice." });
+    }
+  }
+  if (request.kind === "plan_review") {
+    const plan = AgentSessionPlanSnapshotSchema.safeParse(request.plan);
+    if (!plan.success) {
+      for (const issue of plan.error.issues) {
+        context.addIssue({ code: "custom", path: ["plan", ...issue.path], message: issue.message });
+      }
+    }
+  }
+}
+const AgentSessionDecisionRequestSchema = withAcyclicProtocolInput(AgentSessionDecisionRequestPortableSchema, inputBounds).superRefine(refineSessionRequest);
+const AgentSessionFormRequestSchema = withAcyclicProtocolInput(AgentSessionFormRequestPortableSchema, inputBounds).superRefine(refineSessionRequest);
+const AgentSessionPlanReviewRequestSchema = withAcyclicProtocolInput(AgentSessionPlanReviewRequestPortableSchema, inputBounds).superRefine(refineSessionRequest);
+const AgentSessionRequestSchema = withAcyclicProtocolInput(AgentSessionRequestPortableSchema, inputBounds).superRefine(refineSessionRequest);
 const AgentSessionDecisionResponsePortableSchema = z.object({
+  kind: z.literal("decision"),
   choiceId: AgentSessionDecisionChoiceIdSchema
 }).strict().readonly();
-const AgentSessionDecisionResponseSchema = withAcyclicProtocolInput(AgentSessionDecisionResponsePortableSchema, inputBounds).refine(
-  (response) => agentProtocolSerializedJsonBytes(response) <= AGENT_SESSION_DECISION_RESPONSE_BYTES_LIMIT,
-  "Session decision response exceeds its serialized UTF-8 byte limit."
-);
+const AgentSessionFormResponsePortableSchema = z.discriminatedUnion("action", [
+  z.object({
+    kind: z.literal("form"),
+    action: z.literal("submit"),
+    choiceId: AgentSessionFormChoiceIdSchema,
+    answers: z.array(AgentElicitationAnswerSchema).max(AGENT_ELICITATION_FIELDS_MAX_LENGTH).readonly()
+  }).strict().readonly(),
+  z.object({
+    kind: z.literal("form"),
+    action: z.literal("cancel"),
+    choiceId: AgentSessionFormChoiceIdSchema
+  }).strict().readonly()
+]);
+const planResponseFields = {
+  kind: z.literal("plan_review"),
+  choiceId: AgentSessionPlanReviewChoiceIdSchema,
+  planId: AgentSessionPlanIdSchema,
+  revision: AgentSessionPlanRevisionSchema
+};
+const AgentSessionPlanReviewResponsePortableSchema = z.discriminatedUnion("action", [
+  z.object({ ...planResponseFields, action: z.enum(["approve", "abandon"]) }).strict().readonly(),
+  z.object({
+    ...planResponseFields,
+    action: z.literal("revise"),
+    feedback: z.string().min(1).max(AGENT_SESSION_PLAN_REVIEW_FEEDBACK_MAX_LENGTH).regex(/\S/u, "Revision feedback must contain non-whitespace content.")
+  }).strict().readonly()
+]);
+const AgentSessionResponsePortableSchema = z.union([
+  AgentSessionDecisionResponsePortableSchema,
+  AgentSessionFormResponsePortableSchema,
+  AgentSessionPlanReviewResponsePortableSchema
+]);
+function refineSessionResponse(response, context) {
+  const byteLimit = response.kind === "decision" ? AGENT_SESSION_DECISION_RESPONSE_BYTES_LIMIT : response.kind === "form" ? AGENT_SESSION_FORM_RESPONSE_BYTES_LIMIT : AGENT_SESSION_PLAN_REVIEW_RESPONSE_BYTES_LIMIT;
+  if (agentProtocolSerializedJsonBytes(response) > byteLimit) {
+    context.addIssue({ code: "custom", message: "Session response exceeds its serialized UTF-8 byte limit." });
+  }
+  if (response.kind === "form" && response.action === "submit") {
+    refineAgentElicitationAnswers(response.answers, context);
+  }
+  if (response.kind === "plan_review" && response.action === "revise" && encoder.encode(response.feedback).byteLength > AGENT_SESSION_PLAN_REVIEW_FEEDBACK_BYTES_LIMIT) {
+    context.addIssue({ code: "custom", path: ["feedback"], message: "Revision feedback exceeds its UTF-8 byte limit." });
+  }
+}
+const AgentSessionDecisionResponseSchema = withAcyclicProtocolInput(AgentSessionDecisionResponsePortableSchema, inputBounds).superRefine(refineSessionResponse);
+const AgentSessionFormResponseSchema = withAcyclicProtocolInput(AgentSessionFormResponsePortableSchema, inputBounds).superRefine(refineSessionResponse);
+const AgentSessionPlanReviewResponseSchema = withAcyclicProtocolInput(AgentSessionPlanReviewResponsePortableSchema, inputBounds).superRefine(refineSessionResponse);
+const AgentSessionResponseSchema = withAcyclicProtocolInput(AgentSessionResponsePortableSchema, inputBounds).superRefine(refineSessionResponse);
 export {
   AgentSessionDecisionChoiceIdSchema,
   AgentSessionDecisionChoiceSchema,
@@ -110,5 +260,25 @@ export {
   AgentSessionDecisionRequestSchema,
   AgentSessionDecisionResponsePortableSchema,
   AgentSessionDecisionResponseSchema,
+  AgentSessionFormChoiceIdSchema,
+  AgentSessionFormChoiceSchema,
+  AgentSessionFormRequestPortableSchema,
+  AgentSessionFormRequestSchema,
+  AgentSessionFormResponsePortableSchema,
+  AgentSessionFormResponseSchema,
+  AgentSessionPlanIdSchema,
+  AgentSessionPlanReviewChoiceIdSchema,
+  AgentSessionPlanReviewChoiceSchema,
+  AgentSessionPlanReviewRequestPortableSchema,
+  AgentSessionPlanReviewRequestSchema,
+  AgentSessionPlanReviewResponsePortableSchema,
+  AgentSessionPlanReviewResponseSchema,
+  AgentSessionPlanRevisionSchema,
+  AgentSessionPlanSnapshotPortableSchema,
+  AgentSessionPlanSnapshotSchema,
+  AgentSessionRequestPortableSchema,
+  AgentSessionRequestSchema,
+  AgentSessionResponsePortableSchema,
+  AgentSessionResponseSchema,
   AgentSessionWorkspaceTargetSchema
 };

package/dist/zod/turns.d.ts

@@ -241,9 +241,9 @@ export declare const AgentPlanStepSchema: z.ZodType<AgentPlanStep>;
 export declare const AgentDiffSummarySchema: z.ZodType<AgentDiffSummary>;
 export declare const AgentTurnCompletedPayloadPortableSchema: z.ZodReadonly<z.ZodObject<{
     outcome: z.ZodEnum<{
+        canceled: "canceled";
         completed: "completed";
         failed: "failed";
-        canceled: "canceled";
         expired: "expired";
     }>;
     reason: z.ZodOptional<z.ZodString>;

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

@@ -16,7 +16,7 @@ import type { AgentManagedContentCatalog, AgentManagedContentDescriptor } from '
 import type { AgentOperationCatalog, AgentOperationDescriptor, AgentOperationInvocation, AgentOperationResult } from '../operations/types.js';
 import type { AgentApprovalConsequence, AgentRequest, AgentRequestResolution } from '../requests/types.js';
 import type { AgentGeneratedResourceDescriptor } from '../resources/types.js';
-import type { AgentSessionDecisionChoice, AgentSessionDecisionConsequence, AgentSessionDecisionRequest, AgentSessionDecisionResponse, AgentSessionWorkspaceTarget } from '../sessionInteractions/types.js';
+import type { AgentSessionDecisionChoice, AgentSessionDecisionConsequence, AgentSessionDecisionRequest, AgentSessionDecisionResponse, AgentSessionFormChoice, AgentSessionFormRequest, AgentSessionFormResponse, AgentSessionPlanReviewChoice, AgentSessionPlanReviewRequest, AgentSessionPlanReviewResponse, AgentSessionPlanSnapshot, AgentSessionRequest, AgentSessionResponse, AgentSessionWorkspaceTarget } from '../sessionInteractions/types.js';
 import type { AgentSessionBinding, AgentSessionConfiguration, AgentSessionOpenInput } from '../sessions/types.js';
 import type { AgentContentReferenceInputPart, AgentItemSnapshot, AgentTurnInputContent, AgentTurnInterruptionInput, AgentTurnRunInput } from '../turns/types.js';
 import { AgentAccountQuotaResetSchema, AgentAccountQuotaSnapshotSchema, AgentAccountQuotaWindowSchema } from './accountQuota.js';
@@ -36,7 +36,7 @@ import { AgentManagedContentCatalogSchema, AgentManagedContentDescriptorSchema }
 import { AgentOperationCatalogSchema, AgentOperationDescriptorSchema, AgentOperationInvocationSchema, AgentOperationResultSchema } from './operations.js';
 import { AgentApprovalConsequenceSchema, AgentRequestResolutionSchema, AgentRequestSchema } from './requests.js';
 import { AgentGeneratedResourceDescriptorSchema } from './resources.js';
-import { AgentSessionDecisionChoiceSchema, AgentSessionDecisionConsequenceSchema, AgentSessionDecisionRequestSchema, AgentSessionDecisionResponseSchema, AgentSessionWorkspaceTargetSchema } from './sessionInteractions.js';
+import { AgentSessionDecisionChoiceSchema, AgentSessionDecisionConsequenceSchema, AgentSessionDecisionRequestSchema, AgentSessionDecisionResponseSchema, AgentSessionFormChoiceSchema, AgentSessionFormRequestSchema, AgentSessionFormResponseSchema, AgentSessionPlanReviewChoiceSchema, AgentSessionPlanReviewRequestSchema, AgentSessionPlanReviewResponseSchema, AgentSessionPlanSnapshotSchema, AgentSessionRequestSchema, AgentSessionResponseSchema, AgentSessionWorkspaceTargetSchema } from './sessionInteractions.js';
 import { AgentSessionBindingSchema, AgentSessionConfigurationSchema, AgentSessionOpenInputSchema } from './sessions.js';
 import { AgentContentReferenceInputPartSchema, AgentItemSnapshotSchema, AgentTurnInputContentSchema, AgentTurnInterruptionInputSchema, AgentTurnRunInputSchema } from './turns.js';
 type Extends<Left, Right> = [Left] extends [Right] ? true : false;
@@ -52,6 +52,24 @@ export type AgentProtocolSchemaTypeAssertions = readonly [
     Assert<Extends<AgentSessionDecisionRequest, z.output<typeof AgentSessionDecisionRequestSchema>>>,
     Assert<Extends<z.output<typeof AgentSessionDecisionResponseSchema>, AgentSessionDecisionResponse>>,
     Assert<Extends<AgentSessionDecisionResponse, z.output<typeof AgentSessionDecisionResponseSchema>>>,
+    Assert<Extends<z.output<typeof AgentSessionFormChoiceSchema>, AgentSessionFormChoice>>,
+    Assert<Extends<AgentSessionFormChoice, z.output<typeof AgentSessionFormChoiceSchema>>>,
+    Assert<Extends<z.output<typeof AgentSessionFormRequestSchema>, AgentSessionFormRequest>>,
+    Assert<Extends<AgentSessionFormRequest, z.output<typeof AgentSessionFormRequestSchema>>>,
+    Assert<Extends<z.output<typeof AgentSessionFormResponseSchema>, AgentSessionFormResponse>>,
+    Assert<Extends<AgentSessionFormResponse, z.output<typeof AgentSessionFormResponseSchema>>>,
+    Assert<Extends<z.output<typeof AgentSessionPlanSnapshotSchema>, AgentSessionPlanSnapshot>>,
+    Assert<Extends<AgentSessionPlanSnapshot, z.output<typeof AgentSessionPlanSnapshotSchema>>>,
+    Assert<Extends<z.output<typeof AgentSessionPlanReviewChoiceSchema>, AgentSessionPlanReviewChoice>>,
+    Assert<Extends<AgentSessionPlanReviewChoice, z.output<typeof AgentSessionPlanReviewChoiceSchema>>>,
+    Assert<Extends<z.output<typeof AgentSessionPlanReviewRequestSchema>, AgentSessionPlanReviewRequest>>,
+    Assert<Extends<AgentSessionPlanReviewRequest, z.output<typeof AgentSessionPlanReviewRequestSchema>>>,
+    Assert<Extends<z.output<typeof AgentSessionPlanReviewResponseSchema>, AgentSessionPlanReviewResponse>>,
+    Assert<Extends<AgentSessionPlanReviewResponse, z.output<typeof AgentSessionPlanReviewResponseSchema>>>,
+    Assert<Extends<z.output<typeof AgentSessionRequestSchema>, AgentSessionRequest>>,
+    Assert<Extends<AgentSessionRequest, z.output<typeof AgentSessionRequestSchema>>>,
+    Assert<Extends<z.output<typeof AgentSessionResponseSchema>, AgentSessionResponse>>,
+    Assert<Extends<AgentSessionResponse, z.output<typeof AgentSessionResponseSchema>>>,
     Assert<Extends<z.output<typeof AgentEffectiveContentCatalogSchema>, AgentEffectiveContentCatalog>>,
     Assert<Extends<AgentEffectiveContentCatalog, z.output<typeof AgentEffectiveContentCatalogSchema>>>,
     Assert<Extends<z.output<typeof AgentEffectiveContentDescriptorSchema>, AgentEffectiveContentDescriptor>>,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agen-ai/agent-protocol",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "private": false,
   "description": "Provider-neutral sessions, turns, requests, capabilities, artifacts, and events for coding-agent runtimes.",
   "type": "module",
@@ -104,7 +104,7 @@
   },
   "dependencies": {
     "zod": "4.4.3",
-    "@agen-ai/validation": "^0.4.1"
+    "@agen-ai/validation": "^0.4.2"
   },
   "devDependencies": {
     "ajv": "8.17.1",