@agen-ai/agent-protocol 0.2.2 → 0.2.4

package/dist/zod/operations.js

@@ -0,0 +1,229 @@
+import { z } from "zod/v4";
+import { compareStringsByUnicodeCodePoint } from "../foundation/ordering.js";
+import {
+  AGENT_OPERATION_CATALOG_MAX_LENGTH,
+  AGENT_OPERATION_CONTEXTS,
+  AGENT_OPERATION_DESCRIPTION_MAX_LENGTH,
+  AGENT_OPERATION_EXECUTION_MODES,
+  AGENT_OPERATION_FIELDS_MAX_LENGTH,
+  AGENT_OPERATION_IDEMPOTENCY_REQUIREMENTS,
+  AGENT_OPERATION_KINDS,
+  AGENT_OPERATION_OPTIONS_MAX_LENGTH,
+  AGENT_OPERATION_OUTPUT_TEXT_MAX_LENGTH,
+  AGENT_OPERATION_RESULT_KINDS,
+  AGENT_OPERATION_RESULT_REFERENCES_MAX_LENGTH,
+  AGENT_OPERATION_TEXT_VALUE_MAX_LENGTH,
+  AGENT_OPERATION_TIMINGS,
+  AGENT_OPERATION_TITLE_MAX_LENGTH
+} from "../operations/types.js";
+import {
+  AgentArtifactIdSchema,
+  AgentCanonicalIdValueSchema,
+  AgentErrorSchema,
+  AgentGeneratedResourceIdSchema,
+  AgentOperationIdSchema,
+  AgentOperationInvocationIdSchema,
+  AgentRequestFieldIdSchema,
+  createAgentCanonicalNonBlankStringSchema
+} from "./foundation.js";
+const PositiveSafeIntegerSchema = z.number().int().positive().max(Number.MAX_SAFE_INTEGER);
+const CanonicalTitleSchema = createAgentCanonicalNonBlankStringSchema(
+  AGENT_OPERATION_TITLE_MAX_LENGTH
+);
+const CanonicalDescriptionSchema = createAgentCanonicalNonBlankStringSchema(
+  AGENT_OPERATION_DESCRIPTION_MAX_LENGTH
+);
+const AgentOperationSelectOptionSchema = z.object({
+  optionId: AgentCanonicalIdValueSchema,
+  label: CanonicalTitleSchema,
+  description: CanonicalDescriptionSchema.optional()
+}).strict().readonly();
+const fieldBase = {
+  fieldId: AgentRequestFieldIdSchema,
+  label: CanonicalTitleSchema,
+  description: CanonicalDescriptionSchema.optional(),
+  required: z.boolean(),
+  sensitivity: z.enum(["ordinary", "sensitive"])
+};
+const SelectOptionsSchema = z.array(AgentOperationSelectOptionSchema).min(1).max(AGENT_OPERATION_OPTIONS_MAX_LENGTH).readonly();
+const AgentOperationFieldSchema = z.discriminatedUnion("fieldKind", [
+  z.object({
+    ...fieldBase,
+    fieldKind: z.literal("text"),
+    multiline: z.boolean(),
+    maxLength: z.number().int().positive().max(AGENT_OPERATION_TEXT_VALUE_MAX_LENGTH)
+  }).strict().readonly(),
+  z.object({ ...fieldBase, fieldKind: z.literal("boolean") }).strict().readonly(),
+  z.object({
+    ...fieldBase,
+    fieldKind: z.literal("single_select"),
+    options: SelectOptionsSchema
+  }).strict().readonly(),
+  z.object({
+    ...fieldBase,
+    fieldKind: z.literal("multi_select"),
+    options: SelectOptionsSchema,
+    maxSelections: z.number().int().positive().max(AGENT_OPERATION_OPTIONS_MAX_LENGTH)
+  }).strict().readonly(),
+  z.object({
+    ...fieldBase,
+    fieldKind: z.literal("integer"),
+    minimum: z.number().int().min(Number.MIN_SAFE_INTEGER).max(Number.MAX_SAFE_INTEGER),
+    maximum: z.number().int().min(Number.MIN_SAFE_INTEGER).max(Number.MAX_SAFE_INTEGER)
+  }).strict().readonly()
+]);
+const AgentOperationDescriptorPortableSchema = z.object({
+  operationId: AgentOperationIdSchema,
+  revision: PositiveSafeIntegerSchema,
+  kind: z.enum(AGENT_OPERATION_KINDS),
+  title: CanonicalTitleSchema,
+  description: CanonicalDescriptionSchema.optional(),
+  context: z.enum(AGENT_OPERATION_CONTEXTS),
+  timing: z.enum(AGENT_OPERATION_TIMINGS),
+  executionMode: z.enum(AGENT_OPERATION_EXECUTION_MODES),
+  fields: z.array(AgentOperationFieldSchema).max(AGENT_OPERATION_FIELDS_MAX_LENGTH).readonly(),
+  confirmation: z.enum(["none", "required"]),
+  idempotency: z.enum(AGENT_OPERATION_IDEMPOTENCY_REQUIREMENTS),
+  resultKind: z.enum(AGENT_OPERATION_RESULT_KINDS)
+}).strict().readonly();
+function addFieldIssues(fields, context) {
+  const fieldIds = /* @__PURE__ */ new Set();
+  fields.forEach((field, fieldIndex) => {
+    if (fieldIds.has(field.fieldId)) {
+      context.addIssue({ code: "custom", path: ["fields", fieldIndex, "fieldId"], message: "Operation field IDs must be unique." });
+    }
+    if (fieldIndex > 0 && compareStringsByUnicodeCodePoint(
+      fields[fieldIndex - 1].fieldId,
+      field.fieldId
+    ) >= 0) {
+      context.addIssue({ code: "custom", path: ["fields", fieldIndex, "fieldId"], message: "Operation fields must use canonical fieldId order." });
+    }
+    fieldIds.add(field.fieldId);
+    if (field.fieldKind === "integer" && field.minimum > field.maximum) {
+      context.addIssue({ code: "custom", path: ["fields", fieldIndex, "minimum"], message: "Integer field minimum cannot exceed maximum." });
+    }
+    if (field.fieldKind !== "single_select" && field.fieldKind !== "multi_select") return;
+    const optionIds = /* @__PURE__ */ new Set();
+    field.options.forEach((option, optionIndex) => {
+      if (optionIds.has(option.optionId)) {
+        context.addIssue({ code: "custom", path: ["fields", fieldIndex, "options", optionIndex, "optionId"], message: "Operation option IDs must be unique within a field." });
+      }
+      if (optionIndex > 0 && compareStringsByUnicodeCodePoint(
+        field.options[optionIndex - 1].optionId,
+        option.optionId
+      ) >= 0) {
+        context.addIssue({ code: "custom", path: ["fields", fieldIndex, "options", optionIndex, "optionId"], message: "Operation options must use canonical optionId order." });
+      }
+      optionIds.add(option.optionId);
+    });
+    if (field.fieldKind === "multi_select" && field.maxSelections > field.options.length) {
+      context.addIssue({ code: "custom", path: ["fields", fieldIndex, "maxSelections"], message: "Maximum selections cannot exceed available options." });
+    }
+  });
+}
+const AgentOperationDescriptorSchema = AgentOperationDescriptorPortableSchema.superRefine((descriptor, context) => {
+  addFieldIssues(descriptor.fields, context);
+});
+const AgentOperationCatalogPortableSchema = z.object({
+  revision: PositiveSafeIntegerSchema,
+  operations: z.array(AgentOperationDescriptorPortableSchema).max(AGENT_OPERATION_CATALOG_MAX_LENGTH).readonly()
+}).strict().readonly();
+const AgentOperationCatalogSchema = AgentOperationCatalogPortableSchema.superRefine((catalog, context) => {
+  let previous = "";
+  const operationIds = /* @__PURE__ */ new Set();
+  catalog.operations.forEach((operation, operationIndex) => {
+    const parsed = AgentOperationDescriptorSchema.safeParse(operation);
+    if (!parsed.success) {
+      for (const issue of parsed.error.issues) {
+        context.addIssue({ code: "custom", path: ["operations", operationIndex, ...issue.path], message: issue.message });
+      }
+    }
+    if (operationIds.has(operation.operationId)) {
+      context.addIssue({ code: "custom", path: ["operations", operationIndex, "operationId"], message: "Operation IDs must be unique within a catalog." });
+    }
+    if (operationIndex > 0 && compareStringsByUnicodeCodePoint(previous, operation.operationId) >= 0) {
+      context.addIssue({ code: "custom", path: ["operations", operationIndex, "operationId"], message: "Operations must be ordered by operationId." });
+    }
+    operationIds.add(operation.operationId);
+    previous = operation.operationId;
+  });
+});
+const AgentOperationFieldValueSchema = z.discriminatedUnion("fieldKind", [
+  z.object({ fieldId: AgentRequestFieldIdSchema, fieldKind: z.literal("text"), value: z.string().max(AGENT_OPERATION_TEXT_VALUE_MAX_LENGTH) }).strict().readonly(),
+  z.object({ fieldId: AgentRequestFieldIdSchema, fieldKind: z.literal("boolean"), value: z.boolean() }).strict().readonly(),
+  z.object({ fieldId: AgentRequestFieldIdSchema, fieldKind: z.literal("single_select"), optionId: AgentCanonicalIdValueSchema }).strict().readonly(),
+  z.object({ fieldId: AgentRequestFieldIdSchema, fieldKind: z.literal("multi_select"), optionIds: z.array(AgentCanonicalIdValueSchema).min(1).max(AGENT_OPERATION_OPTIONS_MAX_LENGTH).readonly() }).strict().readonly(),
+  z.object({ fieldId: AgentRequestFieldIdSchema, fieldKind: z.literal("integer"), value: z.number().int().min(Number.MIN_SAFE_INTEGER).max(Number.MAX_SAFE_INTEGER) }).strict().readonly()
+]);
+const AgentOperationInvocationPortableSchema = z.object({
+  invocationId: AgentOperationInvocationIdSchema,
+  operationId: AgentOperationIdSchema,
+  expectedRevision: PositiveSafeIntegerSchema,
+  values: z.array(AgentOperationFieldValueSchema).max(AGENT_OPERATION_FIELDS_MAX_LENGTH).readonly()
+}).strict().readonly();
+const AgentOperationInvocationSchema = AgentOperationInvocationPortableSchema.superRefine((invocation, context) => {
+  const fieldIds = /* @__PURE__ */ new Set();
+  invocation.values.forEach((value, valueIndex) => {
+    if (fieldIds.has(value.fieldId)) {
+      context.addIssue({ code: "custom", path: ["values", valueIndex, "fieldId"], message: "Each operation field may be supplied once." });
+    }
+    if (valueIndex > 0 && compareStringsByUnicodeCodePoint(
+      invocation.values[valueIndex - 1].fieldId,
+      value.fieldId
+    ) >= 0) {
+      context.addIssue({ code: "custom", path: ["values", valueIndex, "fieldId"], message: "Operation values must use canonical fieldId order." });
+    }
+    fieldIds.add(value.fieldId);
+    if (value.fieldKind === "multi_select" && new Set(value.optionIds).size !== value.optionIds.length) {
+      context.addIssue({ code: "custom", path: ["values", valueIndex, "optionIds"], message: "Multi-select operation values must be unique." });
+    }
+    if (value.fieldKind === "multi_select" && value.optionIds.some(
+      (optionId, optionIndex) => optionIndex > 0 && compareStringsByUnicodeCodePoint(
+        value.optionIds[optionIndex - 1],
+        optionId
+      ) >= 0
+    )) {
+      context.addIssue({ code: "custom", path: ["values", valueIndex, "optionIds"], message: "Multi-select operation values must use canonical optionId order." });
+    }
+  });
+});
+const AgentOperationResultPortableSchema = z.object({
+  invocationId: AgentOperationInvocationIdSchema,
+  status: z.enum(["accepted", "completed", "failed", "canceled", "waiting_for_request"]),
+  artifactIds: z.array(AgentArtifactIdSchema).min(1).max(AGENT_OPERATION_RESULT_REFERENCES_MAX_LENGTH).readonly().optional(),
+  resourceIds: z.array(AgentGeneratedResourceIdSchema).min(1).max(AGENT_OPERATION_RESULT_REFERENCES_MAX_LENGTH).readonly().optional(),
+  outputText: createAgentCanonicalNonBlankStringSchema(AGENT_OPERATION_OUTPUT_TEXT_MAX_LENGTH).optional(),
+  error: AgentErrorSchema.optional()
+}).strict().readonly();
+const AgentOperationResultSchema = AgentOperationResultPortableSchema.superRefine((result, context) => {
+  if (result.status === "failed" !== (result.error !== void 0)) {
+    context.addIssue({ code: "custom", path: ["error"], message: "Only failed operation results must include an error." });
+  }
+  if (result.status !== "completed" && (result.artifactIds !== void 0 || result.resourceIds !== void 0 || result.outputText !== void 0)) {
+    context.addIssue({ code: "custom", path: [], message: "Only completed operation results may expose result values." });
+  }
+  for (const [field, values] of [["artifactIds", result.artifactIds], ["resourceIds", result.resourceIds]]) {
+    if (values !== void 0 && new Set(values).size !== values.length) {
+      context.addIssue({ code: "custom", path: [field], message: `${field} must be unique.` });
+    }
+    if (values !== void 0 && values.some(
+      (value, valueIndex) => valueIndex > 0 && compareStringsByUnicodeCodePoint(
+        values[valueIndex - 1],
+        value
+      ) >= 0
+    )) {
+      context.addIssue({ code: "custom", path: [field], message: `${field} must use canonical ID order.` });
+    }
+  }
+});
+export {
+  AgentOperationCatalogPortableSchema,
+  AgentOperationCatalogSchema,
+  AgentOperationDescriptorPortableSchema,
+  AgentOperationDescriptorSchema,
+  AgentOperationFieldSchema,
+  AgentOperationInvocationPortableSchema,
+  AgentOperationInvocationSchema,
+  AgentOperationResultPortableSchema,
+  AgentOperationResultSchema
+};

package/dist/zod/requests.d.ts

@@ -52,31 +52,71 @@ export declare const AgentElicitationRequestPortableSchema: z.ZodReadonly<z.ZodO
     requestId: z.ZodType<import("../index.js").AgentRequestId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestId, unknown>>;
     prompt: z.ZodString;
     fields: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"text">;
+        multiline: z.ZodBoolean;
+        maxLength: z.ZodNumber;
         fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
         label: z.ZodString;
         description: z.ZodOptional<z.ZodString>;
         required: z.ZodBoolean;
-        kind: z.ZodLiteral<"text">;
-        multiline: z.ZodOptional<z.ZodBoolean>;
+        sensitivity: z.ZodEnum<{
+            ordinary: "ordinary";
+            sensitive: "sensitive";
+        }>;
     }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"single_select">;
+        options: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            value: z.ZodIntersection<z.ZodString, z.ZodString>;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>>;
+        allowOther: z.ZodBoolean;
         fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
         label: z.ZodString;
         description: z.ZodOptional<z.ZodString>;
         required: z.ZodBoolean;
-        kind: z.ZodLiteral<"choice">;
+        sensitivity: z.ZodEnum<{
+            ordinary: "ordinary";
+            sensitive: "sensitive";
+        }>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"multi_select">;
         options: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
             value: z.ZodIntersection<z.ZodString, z.ZodString>;
             label: z.ZodString;
             description: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>>>;
-        multiple: z.ZodBoolean;
         allowOther: z.ZodBoolean;
-    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        maxSelections: z.ZodNumber;
         fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
         label: z.ZodString;
         description: z.ZodOptional<z.ZodString>;
         required: z.ZodBoolean;
+        sensitivity: z.ZodEnum<{
+            ordinary: "ordinary";
+            sensitive: "sensitive";
+        }>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
         kind: z.ZodLiteral<"boolean">;
+        fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        required: z.ZodBoolean;
+        sensitivity: z.ZodEnum<{
+            ordinary: "ordinary";
+            sensitive: "sensitive";
+        }>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"confirmation">;
+        confirmLabel: z.ZodString;
+        fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        required: z.ZodBoolean;
+        sensitivity: z.ZodEnum<{
+            ordinary: "ordinary";
+            sensitive: "sensitive";
+        }>;
     }, z.core.$strict>>], "kind">>>;
     expiresAt: z.ZodOptional<z.ZodType<import("../index.js").AgentIsoDateTime, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIsoDateTime, unknown>>>;
 }, z.core.$strict>>;
@@ -131,31 +171,71 @@ export declare const AgentRequestPortableSchema: z.ZodDiscriminatedUnion<[z.ZodR
     requestId: z.ZodType<import("../index.js").AgentRequestId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestId, unknown>>;
     prompt: z.ZodString;
     fields: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"text">;
+        multiline: z.ZodBoolean;
+        maxLength: z.ZodNumber;
         fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
         label: z.ZodString;
         description: z.ZodOptional<z.ZodString>;
         required: z.ZodBoolean;
-        kind: z.ZodLiteral<"text">;
-        multiline: z.ZodOptional<z.ZodBoolean>;
+        sensitivity: z.ZodEnum<{
+            ordinary: "ordinary";
+            sensitive: "sensitive";
+        }>;
     }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"single_select">;
+        options: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            value: z.ZodIntersection<z.ZodString, z.ZodString>;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>>;
+        allowOther: z.ZodBoolean;
         fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
         label: z.ZodString;
         description: z.ZodOptional<z.ZodString>;
         required: z.ZodBoolean;
-        kind: z.ZodLiteral<"choice">;
+        sensitivity: z.ZodEnum<{
+            ordinary: "ordinary";
+            sensitive: "sensitive";
+        }>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"multi_select">;
         options: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
             value: z.ZodIntersection<z.ZodString, z.ZodString>;
             label: z.ZodString;
             description: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>>>;
-        multiple: z.ZodBoolean;
         allowOther: z.ZodBoolean;
-    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        maxSelections: z.ZodNumber;
         fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
         label: z.ZodString;
         description: z.ZodOptional<z.ZodString>;
         required: z.ZodBoolean;
+        sensitivity: z.ZodEnum<{
+            ordinary: "ordinary";
+            sensitive: "sensitive";
+        }>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
         kind: z.ZodLiteral<"boolean">;
+        fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        required: z.ZodBoolean;
+        sensitivity: z.ZodEnum<{
+            ordinary: "ordinary";
+            sensitive: "sensitive";
+        }>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"confirmation">;
+        confirmLabel: z.ZodString;
+        fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        required: z.ZodBoolean;
+        sensitivity: z.ZodEnum<{
+            ordinary: "ordinary";
+            sensitive: "sensitive";
+        }>;
     }, z.core.$strict>>], "kind">>>;
     expiresAt: z.ZodOptional<z.ZodType<import("../index.js").AgentIsoDateTime, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIsoDateTime, unknown>>>;
 }, z.core.$strict>>], "requestKind">;
@@ -171,13 +251,22 @@ export declare const AgentRequestResolutionPortableSchema: z.ZodUnion<readonly [
         value: z.ZodString;
     }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
         fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
-        kind: z.ZodLiteral<"choice">;
+        kind: z.ZodLiteral<"single_select">;
+        value: z.ZodOptional<z.ZodIntersection<z.ZodString, z.ZodString>>;
+        other: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
+        kind: z.ZodLiteral<"multi_select">;
         values: z.ZodReadonly<z.ZodArray<z.ZodIntersection<z.ZodString, z.ZodString>>>;
         other: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
         fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
         kind: z.ZodLiteral<"boolean">;
         value: z.ZodBoolean;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
+        kind: z.ZodLiteral<"confirmation">;
+        confirmed: z.ZodBoolean;
     }, z.core.$strict>>], "kind">>>;
 }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
     requestKind: z.ZodLiteral<"elicitation">;

package/dist/zod/requests.js

@@ -1,6 +1,5 @@
 import { z } from "zod/v4";
 import {
-  AGENT_PROTOCOL_COLLECTION_MAX_LENGTH,
   AGENT_PROTOCOL_SUMMARY_MAX_LENGTH,
   AGENT_PROTOCOL_TEXT_MAX_LENGTH
 } from "../foundation/types.js";
@@ -9,7 +8,10 @@ import {
   AGENT_APPROVAL_LABEL_MAX_LENGTH,
   AGENT_APPROVAL_OPTIONS_MAX_LENGTH,
   AGENT_APPROVAL_PERSISTENCES,
-  AGENT_APPROVAL_SCOPE_KINDS
+  AGENT_APPROVAL_SCOPE_KINDS,
+  AGENT_ELICITATION_FIELDS_MAX_LENGTH,
+  AGENT_ELICITATION_OPTIONS_MAX_LENGTH,
+  AGENT_ELICITATION_TEXT_VALUE_MAX_LENGTH
 } from "../requests/types.js";
 import {
   AgentApprovalOptionIdSchema,
@@ -73,38 +75,49 @@ const AgentRequestChoiceSchema = z.object({
   label: z.string().min(1).max(200),
   description: z.string().max(AGENT_PROTOCOL_SUMMARY_MAX_LENGTH).optional()
 }).strict().readonly();
+const AgentElicitationFieldBase = {
+  fieldId: AgentRequestFieldIdSchema,
+  label: z.string().min(1).max(200),
+  description: z.string().max(AGENT_PROTOCOL_SUMMARY_MAX_LENGTH).optional(),
+  required: z.boolean(),
+  sensitivity: z.enum(["ordinary", "sensitive"])
+};
+const AgentElicitationOptionsSchema = z.array(AgentRequestChoiceSchema).min(1).max(AGENT_ELICITATION_OPTIONS_MAX_LENGTH).readonly();
 const AgentElicitationFieldSchema = z.discriminatedUnion("kind", [
   z.object({
-    fieldId: AgentRequestFieldIdSchema,
-    label: z.string().min(1).max(200),
-    description: z.string().max(AGENT_PROTOCOL_SUMMARY_MAX_LENGTH).optional(),
-    required: z.boolean(),
+    ...AgentElicitationFieldBase,
     kind: z.literal("text"),
-    multiline: z.boolean().optional()
+    multiline: z.boolean(),
+    maxLength: z.number().int().positive().max(AGENT_ELICITATION_TEXT_VALUE_MAX_LENGTH)
   }).strict().readonly(),
   z.object({
-    fieldId: AgentRequestFieldIdSchema,
-    label: z.string().min(1).max(200),
-    description: z.string().max(AGENT_PROTOCOL_SUMMARY_MAX_LENGTH).optional(),
-    required: z.boolean(),
-    kind: z.literal("choice"),
-    options: z.array(AgentRequestChoiceSchema).min(1).max(AGENT_PROTOCOL_COLLECTION_MAX_LENGTH).readonly(),
-    multiple: z.boolean(),
+    ...AgentElicitationFieldBase,
+    kind: z.literal("single_select"),
+    options: AgentElicitationOptionsSchema,
     allowOther: z.boolean()
   }).strict().readonly(),
   z.object({
-    fieldId: AgentRequestFieldIdSchema,
-    label: z.string().min(1).max(200),
-    description: z.string().max(AGENT_PROTOCOL_SUMMARY_MAX_LENGTH).optional(),
-    required: z.boolean(),
+    ...AgentElicitationFieldBase,
+    kind: z.literal("multi_select"),
+    options: AgentElicitationOptionsSchema,
+    allowOther: z.boolean(),
+    maxSelections: z.number().int().positive().max(AGENT_ELICITATION_OPTIONS_MAX_LENGTH)
+  }).strict().readonly(),
+  z.object({
+    ...AgentElicitationFieldBase,
     kind: z.literal("boolean")
+  }).strict().readonly(),
+  z.object({
+    ...AgentElicitationFieldBase,
+    kind: z.literal("confirmation"),
+    confirmLabel: z.string().min(1).max(200)
   }).strict().readonly()
 ]);
 const AgentElicitationRequestPortableSchema = z.object({
   requestKind: z.literal("elicitation"),
   requestId: AgentRequestIdSchema,
   prompt: z.string().min(1).max(AGENT_PROTOCOL_TEXT_MAX_LENGTH),
-  fields: z.array(AgentElicitationFieldSchema).min(1).max(AGENT_PROTOCOL_COLLECTION_MAX_LENGTH).readonly(),
+  fields: z.array(AgentElicitationFieldSchema).min(1).max(AGENT_ELICITATION_FIELDS_MAX_LENGTH).readonly(),
   expiresAt: AgentIsoDateTimeSchema.optional()
 }).strict().readonly();
 const AgentElicitationRequestSchema = AgentElicitationRequestPortableSchema.superRefine((request, context) => {
@@ -118,7 +131,9 @@ const AgentElicitationRequestSchema = AgentElicitationRequestPortableSchema.supe
       });
     }
     fieldIds.add(field.fieldId);
-    if (field.kind !== "choice") return;
+    if (field.kind !== "single_select" && field.kind !== "multi_select") {
+      return;
+    }
     const optionValues = /* @__PURE__ */ new Set();
     field.options.forEach((option, optionIndex) => {
       if (optionValues.has(option.value)) {
@@ -130,6 +145,13 @@ const AgentElicitationRequestSchema = AgentElicitationRequestPortableSchema.supe
       }
       optionValues.add(option.value);
     });
+    if (field.kind === "multi_select" && field.maxSelections > field.options.length + (field.allowOther ? 1 : 0)) {
+      context.addIssue({
+        code: "custom",
+        path: ["fields", fieldIndex, "maxSelections"],
+        message: "Maximum selections cannot exceed the available choices."
+      });
+    }
   });
 });
 const AgentRequestPortableSchema = z.discriminatedUnion("requestKind", [
@@ -147,7 +169,7 @@ const AgentRequestSchema = AgentRequestPortableSchema.superRefine((request, cont
     });
   }
 });
-const AgentElicitationFreeformAnswerSchema = z.string().max(AGENT_PROTOCOL_TEXT_MAX_LENGTH).regex(/\S/u, "Free-form answers must contain non-whitespace content.");
+const AgentElicitationFreeformAnswerSchema = z.string().max(AGENT_ELICITATION_TEXT_VALUE_MAX_LENGTH).regex(/\S/u, "Free-form answers must contain non-whitespace content.");
 const AgentElicitationAnswerSchema = z.discriminatedUnion("kind", [
   z.object({
     fieldId: AgentRequestFieldIdSchema,
@@ -156,14 +178,25 @@ const AgentElicitationAnswerSchema = z.discriminatedUnion("kind", [
   }).strict().readonly(),
   z.object({
     fieldId: AgentRequestFieldIdSchema,
-    kind: z.literal("choice"),
-    values: z.array(AgentRequestChoiceValueSchema).max(AGENT_PROTOCOL_COLLECTION_MAX_LENGTH).readonly(),
+    kind: z.literal("single_select"),
+    value: AgentRequestChoiceValueSchema.optional(),
+    other: AgentElicitationFreeformAnswerSchema.optional()
+  }).strict().readonly(),
+  z.object({
+    fieldId: AgentRequestFieldIdSchema,
+    kind: z.literal("multi_select"),
+    values: z.array(AgentRequestChoiceValueSchema).max(AGENT_ELICITATION_OPTIONS_MAX_LENGTH).readonly(),
     other: AgentElicitationFreeformAnswerSchema.optional()
   }).strict().readonly(),
   z.object({
     fieldId: AgentRequestFieldIdSchema,
     kind: z.literal("boolean"),
     value: z.boolean()
+  }).strict().readonly(),
+  z.object({
+    fieldId: AgentRequestFieldIdSchema,
+    kind: z.literal("confirmation"),
+    confirmed: z.boolean()
   }).strict().readonly()
 ]);
 const AgentApprovalResolutionSchema = z.discriminatedUnion("disposition", [
@@ -185,7 +218,7 @@ const AgentRequestResolutionPortableSchema = z.union([
     requestKind: z.literal("elicitation"),
     requestId: AgentRequestIdSchema,
     disposition: z.literal("answered"),
-    answers: z.array(AgentElicitationAnswerSchema).max(AGENT_PROTOCOL_COLLECTION_MAX_LENGTH).readonly()
+    answers: z.array(AgentElicitationAnswerSchema).max(AGENT_ELICITATION_FIELDS_MAX_LENGTH).readonly()
   }).strict().readonly(),
   z.object({
     requestKind: z.literal("elicitation"),
@@ -198,11 +231,18 @@ const AgentRequestResolutionSchema = AgentRequestResolutionPortableSchema.superR
     return;
   }
   resolution.answers.forEach((answer, answerIndex) => {
-    if (answer.kind === "choice" && new Set(answer.values).size !== answer.values.length) {
+    if (answer.kind === "multi_select" && new Set(answer.values).size !== answer.values.length) {
       context.addIssue({
         code: "custom",
         path: ["answers", answerIndex, "values"],
-        message: "Choice answers cannot select the same option more than once."
+        message: "Multi-select answers cannot select the same option more than once."
+      });
+    }
+    if (answer.kind === "single_select" && answer.value === void 0 === (answer.other === void 0)) {
+      context.addIssue({
+        code: "custom",
+        path: ["answers", answerIndex],
+        message: "Single-select answers require exactly one declared or custom choice."
       });
     }
   });

package/dist/zod/resources.d.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod/v4';
+import { type AgentGeneratedResourceDescriptor } from '../resources/types.js';
+export declare const AgentGeneratedResourceDescriptorPortableSchema: z.ZodReadonly<z.ZodObject<{
+    resourceId: z.ZodType<import("../index.js").AgentGeneratedResourceId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentGeneratedResourceId, unknown>>;
+    kind: z.ZodEnum<{
+        image: "image";
+        document: "document";
+        archive: "archive";
+    }>;
+    status: z.ZodEnum<{
+        pending: "pending";
+        expired: "expired";
+        available: "available";
+        unavailable: "unavailable";
+    }>;
+    displayName: z.ZodString;
+    producer: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"session">;
+        sessionId: z.ZodType<import("../index.js").AgentSessionId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentSessionId, unknown>>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"turn">;
+        turnId: z.ZodType<import("../index.js").AgentTurnId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentTurnId, unknown>>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"operation">;
+        invocationId: z.ZodType<import("../index.js").AgentOperationInvocationId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentOperationInvocationId, unknown>>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"collaboration">;
+        collaborationId: z.ZodType<import("../index.js").AgentCollaborationId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentCollaborationId, unknown>>;
+    }, z.core.$strict>>], "kind">;
+    summary: z.ZodOptional<z.ZodString>;
+    mediaType: z.ZodOptional<z.ZodString>;
+    byteSize: z.ZodOptional<z.ZodNumber>;
+    sha256: z.ZodOptional<z.ZodString>;
+    widthPixels: z.ZodOptional<z.ZodNumber>;
+    heightPixels: z.ZodOptional<z.ZodNumber>;
+    pageCount: z.ZodOptional<z.ZodNumber>;
+    artifactId: z.ZodOptional<z.ZodType<import("../index.js").AgentArtifactId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentArtifactId, unknown>>>;
+    createdAt: z.ZodType<import("../index.js").AgentIsoDateTime, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIsoDateTime, unknown>>;
+    expiresAt: z.ZodOptional<z.ZodType<import("../index.js").AgentIsoDateTime, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIsoDateTime, unknown>>>;
+    error: z.ZodOptional<z.ZodType<import("../index.js").AgentError, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentError, unknown>>>;
+}, z.core.$strict>>;
+export declare const AgentGeneratedResourceDescriptorSchema: z.ZodType<AgentGeneratedResourceDescriptor>;
+//# sourceMappingURL=resources.d.ts.map