@agen-ai/agent-protocol 0.2.2 → 0.2.3

package/dist/zod/collaboration.d.ts

@@ -0,0 +1,60 @@
+import { z } from 'zod/v4';
+import { type AgentCollaborationControlInput, type AgentCollaborationNode, type AgentCollaborationSpawnInput } from '../collaboration/types.js';
+export declare const AgentCollaborationNodePortableSchema: z.ZodReadonly<z.ZodObject<{
+    collaborationId: z.ZodType<import("../index.js").AgentCollaborationId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentCollaborationId, unknown>>;
+    rootCollaborationId: z.ZodType<import("../index.js").AgentCollaborationId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentCollaborationId, unknown>>;
+    parentCollaborationId: z.ZodOptional<z.ZodType<import("../index.js").AgentCollaborationId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentCollaborationId, unknown>>>;
+    role: z.ZodEnum<{
+        delegate: "delegate";
+        reviewer: "reviewer";
+        researcher: "researcher";
+        specialist: "specialist";
+    }>;
+    title: z.ZodString;
+    status: z.ZodEnum<{
+        completed: "completed";
+        failed: "failed";
+        canceled: "canceled";
+        running: "running";
+        starting: "starting";
+        queued: "queued";
+        waiting: "waiting";
+    }>;
+    objective: z.ZodString;
+    progress: z.ZodOptional<z.ZodString>;
+    usage: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"unavailable">;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"reported">;
+        inputTokens: z.ZodOptional<z.ZodNumber>;
+        outputTokens: z.ZodOptional<z.ZodNumber>;
+        reasoningTokens: z.ZodOptional<z.ZodNumber>;
+        totalTokens: z.ZodOptional<z.ZodNumber>;
+        modelCalls: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>], "kind">;
+    outcome: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"completed">;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"failed">;
+        error: z.ZodType<import("../index.js").AgentError, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentError, unknown>>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"canceled">;
+        reason: z.ZodEnum<{
+            user_requested: "user_requested";
+            timeout: "timeout";
+            shutdown: "shutdown";
+            superseded: "superseded";
+            other: "other";
+        }>;
+    }, z.core.$strict>>], "kind">>;
+    createdAt: z.ZodType<import("../index.js").AgentIsoDateTime, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIsoDateTime, unknown>>;
+    updatedAt: z.ZodType<import("../index.js").AgentIsoDateTime, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIsoDateTime, unknown>>;
+    terminalAt: z.ZodOptional<z.ZodType<import("../index.js").AgentIsoDateTime, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIsoDateTime, unknown>>>;
+    closedAt: z.ZodOptional<z.ZodType<import("../index.js").AgentIsoDateTime, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIsoDateTime, unknown>>>;
+    artifactIds: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodType<import("../index.js").AgentArtifactId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentArtifactId, unknown>>>>>;
+    resourceIds: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodType<import("../index.js").AgentGeneratedResourceId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentGeneratedResourceId, unknown>>>>>;
+}, z.core.$strict>>;
+export declare const AgentCollaborationNodeSchema: z.ZodType<AgentCollaborationNode>;
+export declare const AgentCollaborationSpawnInputSchema: z.ZodType<AgentCollaborationSpawnInput>;
+export declare const AgentCollaborationControlInputSchema: z.ZodType<AgentCollaborationControlInput>;
+//# sourceMappingURL=collaboration.d.ts.map

package/dist/zod/collaboration.js

@@ -0,0 +1,155 @@
+import { z } from "zod/v4";
+import { compareStringsByUnicodeCodePoint } from "../foundation/ordering.js";
+import {
+  AGENT_COLLABORATION_OBJECTIVE_MAX_LENGTH,
+  AGENT_COLLABORATION_PROGRESS_MAX_LENGTH,
+  AGENT_COLLABORATION_RESULT_REFERENCES_MAX_LENGTH,
+  AGENT_COLLABORATION_ROLES,
+  AGENT_COLLABORATION_STATUSES,
+  AGENT_COLLABORATION_STOP_REASONS,
+  AGENT_COLLABORATION_TITLE_MAX_LENGTH,
+  AGENT_COLLABORATION_USAGE_FIELDS
+} from "../collaboration/types.js";
+import {
+  AgentArtifactIdSchema,
+  AgentCollaborationIdSchema,
+  AgentErrorSchema,
+  AgentGeneratedResourceIdSchema,
+  AgentIsoDateTimeSchema,
+  createAgentCanonicalNonBlankStringSchema
+} from "./foundation.js";
+import { AgentTurnInputContentSchema } from "./turns.js";
+const ObjectiveSchema = createAgentCanonicalNonBlankStringSchema(
+  AGENT_COLLABORATION_OBJECTIVE_MAX_LENGTH
+);
+const TitleSchema = createAgentCanonicalNonBlankStringSchema(
+  AGENT_COLLABORATION_TITLE_MAX_LENGTH
+);
+const ProgressSchema = createAgentCanonicalNonBlankStringSchema(
+  AGENT_COLLABORATION_PROGRESS_MAX_LENGTH
+);
+const NonNegativeSafeIntegerSchema = z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+const CollaborationStopReasonSchema = z.enum(AGENT_COLLABORATION_STOP_REASONS);
+const AgentCollaborationOutcomeSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("completed") }).strict().readonly(),
+  z.object({ kind: z.literal("failed"), error: AgentErrorSchema }).strict().readonly(),
+  z.object({ kind: z.literal("canceled"), reason: CollaborationStopReasonSchema }).strict().readonly()
+]);
+const AgentCollaborationUsageSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("unavailable") }).strict().readonly(),
+  z.object({
+    kind: z.literal("reported"),
+    inputTokens: NonNegativeSafeIntegerSchema.optional(),
+    outputTokens: NonNegativeSafeIntegerSchema.optional(),
+    reasoningTokens: NonNegativeSafeIntegerSchema.optional(),
+    totalTokens: NonNegativeSafeIntegerSchema.optional(),
+    modelCalls: NonNegativeSafeIntegerSchema.optional()
+  }).strict().refine(
+    (usage) => AGENT_COLLABORATION_USAGE_FIELDS.some(
+      (field) => usage[field] !== void 0
+    ),
+    { message: "Reported collaboration usage must include at least one counter." }
+  ).readonly()
+]);
+const artifactIds = z.array(AgentArtifactIdSchema).min(1).max(AGENT_COLLABORATION_RESULT_REFERENCES_MAX_LENGTH).readonly().optional();
+const resourceIds = z.array(AgentGeneratedResourceIdSchema).min(1).max(AGENT_COLLABORATION_RESULT_REFERENCES_MAX_LENGTH).readonly().optional();
+const AgentCollaborationNodePortableSchema = z.object({
+  collaborationId: AgentCollaborationIdSchema,
+  rootCollaborationId: AgentCollaborationIdSchema,
+  parentCollaborationId: AgentCollaborationIdSchema.optional(),
+  role: z.enum(AGENT_COLLABORATION_ROLES),
+  title: TitleSchema,
+  status: z.enum(AGENT_COLLABORATION_STATUSES),
+  objective: ObjectiveSchema,
+  progress: ProgressSchema.optional(),
+  usage: AgentCollaborationUsageSchema,
+  outcome: AgentCollaborationOutcomeSchema.optional(),
+  createdAt: AgentIsoDateTimeSchema,
+  updatedAt: AgentIsoDateTimeSchema,
+  terminalAt: AgentIsoDateTimeSchema.optional(),
+  closedAt: AgentIsoDateTimeSchema.optional(),
+  artifactIds,
+  resourceIds
+}).strict().readonly();
+const AgentCollaborationNodeSchema = AgentCollaborationNodePortableSchema.superRefine((node, context) => {
+  const terminal = ["completed", "failed", "canceled"].includes(node.status);
+  if (terminal !== (node.terminalAt !== void 0)) {
+    context.addIssue({ code: "custom", path: ["terminalAt"], message: "Exactly terminal collaboration nodes must include terminalAt." });
+  }
+  if (terminal !== (node.outcome !== void 0)) {
+    context.addIssue({ code: "custom", path: ["outcome"], message: "Exactly terminal collaboration nodes must include an outcome." });
+  }
+  if (node.outcome !== void 0 && node.outcome.kind !== node.status) {
+    context.addIssue({ code: "custom", path: ["outcome"], message: "Collaboration outcome must match its terminal lifecycle status." });
+  }
+  if (!terminal && (node.artifactIds !== void 0 || node.resourceIds !== void 0)) {
+    context.addIssue({ code: "custom", path: ["artifactIds"], message: "Only terminal collaboration nodes may expose result references." });
+  }
+  if (node.parentCollaborationId === void 0 && node.rootCollaborationId !== node.collaborationId) {
+    context.addIssue({ code: "custom", path: ["rootCollaborationId"], message: "A root collaboration node must identify itself as root." });
+  }
+  if (node.parentCollaborationId === node.collaborationId) {
+    context.addIssue({ code: "custom", path: ["parentCollaborationId"], message: "A collaboration node cannot parent itself." });
+  }
+  if (Date.parse(node.updatedAt) < Date.parse(node.createdAt)) {
+    context.addIssue({ code: "custom", path: ["updatedAt"], message: "Collaboration updatedAt cannot precede createdAt." });
+  }
+  if (node.terminalAt !== void 0 && (Date.parse(node.terminalAt) < Date.parse(node.createdAt) || Date.parse(node.terminalAt) > Date.parse(node.updatedAt))) {
+    context.addIssue({ code: "custom", path: ["terminalAt"], message: "Collaboration terminalAt must fall within its observed lifetime." });
+  }
+  if (node.closedAt !== void 0 && (node.terminalAt === void 0 || Date.parse(node.closedAt) < Date.parse(node.terminalAt) || Date.parse(node.closedAt) > Date.parse(node.updatedAt))) {
+    context.addIssue({ code: "custom", path: ["closedAt"], message: "A collaboration may close only after its terminal outcome." });
+  }
+  if (node.artifactIds !== void 0 && new Set(node.artifactIds).size !== node.artifactIds.length) {
+    context.addIssue({ code: "custom", path: ["artifactIds"], message: "Collaboration artifact IDs must be unique." });
+  }
+  if (node.artifactIds?.some(
+    (artifactId, artifactIndex) => artifactIndex > 0 && compareStringsByUnicodeCodePoint(
+      node.artifactIds[artifactIndex - 1],
+      artifactId
+    ) >= 0
+  )) {
+    context.addIssue({ code: "custom", path: ["artifactIds"], message: "Collaboration artifact IDs must use canonical order." });
+  }
+  if (node.resourceIds !== void 0 && new Set(node.resourceIds).size !== node.resourceIds.length) {
+    context.addIssue({ code: "custom", path: ["resourceIds"], message: "Collaboration resource IDs must be unique." });
+  }
+  if (node.resourceIds?.some(
+    (resourceId, resourceIndex) => resourceIndex > 0 && compareStringsByUnicodeCodePoint(
+      node.resourceIds[resourceIndex - 1],
+      resourceId
+    ) >= 0
+  )) {
+    context.addIssue({ code: "custom", path: ["resourceIds"], message: "Collaboration resource IDs must use canonical order." });
+  }
+});
+const AgentCollaborationSpawnInputSchema = z.object({
+  collaborationId: AgentCollaborationIdSchema,
+  parentCollaborationId: AgentCollaborationIdSchema.optional(),
+  role: z.enum(AGENT_COLLABORATION_ROLES),
+  title: TitleSchema,
+  objective: ObjectiveSchema,
+  createdAt: AgentIsoDateTimeSchema
+}).strict().refine((input) => input.parentCollaborationId !== input.collaborationId, {
+  path: ["parentCollaborationId"],
+  message: "A collaboration node cannot parent itself."
+}).readonly();
+const SteerPortableSchema = AgentTurnInputContentSchema.and(
+  z.object({ action: z.literal("steer"), collaborationId: AgentCollaborationIdSchema }).strict()
+).readonly();
+const AgentCollaborationControlInputSchema = z.union([
+  SteerPortableSchema,
+  z.object({
+    action: z.literal("stop"),
+    collaborationId: AgentCollaborationIdSchema,
+    reason: CollaborationStopReasonSchema
+  }).strict().readonly(),
+  z.object({ action: z.literal("close"), collaborationId: AgentCollaborationIdSchema }).strict().readonly(),
+  z.object({ action: z.literal("inspect"), collaborationId: AgentCollaborationIdSchema }).strict().readonly()
+]);
+export {
+  AgentCollaborationControlInputSchema,
+  AgentCollaborationNodePortableSchema,
+  AgentCollaborationNodeSchema,
+  AgentCollaborationSpawnInputSchema
+};

package/dist/zod/configuration.d.ts

@@ -0,0 +1,177 @@
+import { z } from 'zod/v4';
+import { type AgentConfigurationCatalog, type AgentConfigurationSelectionInput } from '../configuration/types.js';
+export declare const AgentConfigurationFieldPortableSchema: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+    fieldKind: z.ZodLiteral<"boolean">;
+    currentValue: z.ZodBoolean;
+    key: z.ZodString;
+    revision: z.ZodNumber;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    scope: z.ZodEnum<{
+        session: "session";
+        provider_instance: "provider_instance";
+    }>;
+    applicationTiming: z.ZodEnum<{
+        immediate: "immediate";
+        next_session: "next_session";
+        provider_restart: "provider_restart";
+    }>;
+    mutable: z.ZodBoolean;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    fieldKind: z.ZodLiteral<"single_select">;
+    currentValue: z.ZodString;
+    options: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        optionId: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>>;
+    key: z.ZodString;
+    revision: z.ZodNumber;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    scope: z.ZodEnum<{
+        session: "session";
+        provider_instance: "provider_instance";
+    }>;
+    applicationTiming: z.ZodEnum<{
+        immediate: "immediate";
+        next_session: "next_session";
+        provider_restart: "provider_restart";
+    }>;
+    mutable: z.ZodBoolean;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    fieldKind: z.ZodLiteral<"bounded_integer">;
+    currentValue: z.ZodNumber;
+    minimum: z.ZodNumber;
+    maximum: z.ZodNumber;
+    key: z.ZodString;
+    revision: z.ZodNumber;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    scope: z.ZodEnum<{
+        session: "session";
+        provider_instance: "provider_instance";
+    }>;
+    applicationTiming: z.ZodEnum<{
+        immediate: "immediate";
+        next_session: "next_session";
+        provider_restart: "provider_restart";
+    }>;
+    mutable: z.ZodBoolean;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    fieldKind: z.ZodLiteral<"bounded_text">;
+    currentValue: z.ZodString;
+    maxLength: z.ZodNumber;
+    multiline: z.ZodBoolean;
+    key: z.ZodString;
+    revision: z.ZodNumber;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    scope: z.ZodEnum<{
+        session: "session";
+        provider_instance: "provider_instance";
+    }>;
+    applicationTiming: z.ZodEnum<{
+        immediate: "immediate";
+        next_session: "next_session";
+        provider_restart: "provider_restart";
+    }>;
+    mutable: z.ZodBoolean;
+}, z.core.$strict>>], "fieldKind">;
+export declare const AgentConfigurationCatalogPortableSchema: z.ZodReadonly<z.ZodObject<{
+    revision: z.ZodNumber;
+    fields: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        fieldKind: z.ZodLiteral<"boolean">;
+        currentValue: z.ZodBoolean;
+        key: z.ZodString;
+        revision: z.ZodNumber;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        scope: z.ZodEnum<{
+            session: "session";
+            provider_instance: "provider_instance";
+        }>;
+        applicationTiming: z.ZodEnum<{
+            immediate: "immediate";
+            next_session: "next_session";
+            provider_restart: "provider_restart";
+        }>;
+        mutable: z.ZodBoolean;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        fieldKind: z.ZodLiteral<"single_select">;
+        currentValue: z.ZodString;
+        options: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            optionId: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>>;
+        key: z.ZodString;
+        revision: z.ZodNumber;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        scope: z.ZodEnum<{
+            session: "session";
+            provider_instance: "provider_instance";
+        }>;
+        applicationTiming: z.ZodEnum<{
+            immediate: "immediate";
+            next_session: "next_session";
+            provider_restart: "provider_restart";
+        }>;
+        mutable: z.ZodBoolean;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        fieldKind: z.ZodLiteral<"bounded_integer">;
+        currentValue: z.ZodNumber;
+        minimum: z.ZodNumber;
+        maximum: z.ZodNumber;
+        key: z.ZodString;
+        revision: z.ZodNumber;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        scope: z.ZodEnum<{
+            session: "session";
+            provider_instance: "provider_instance";
+        }>;
+        applicationTiming: z.ZodEnum<{
+            immediate: "immediate";
+            next_session: "next_session";
+            provider_restart: "provider_restart";
+        }>;
+        mutable: z.ZodBoolean;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        fieldKind: z.ZodLiteral<"bounded_text">;
+        currentValue: z.ZodString;
+        maxLength: z.ZodNumber;
+        multiline: z.ZodBoolean;
+        key: z.ZodString;
+        revision: z.ZodNumber;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        scope: z.ZodEnum<{
+            session: "session";
+            provider_instance: "provider_instance";
+        }>;
+        applicationTiming: z.ZodEnum<{
+            immediate: "immediate";
+            next_session: "next_session";
+            provider_restart: "provider_restart";
+        }>;
+        mutable: z.ZodBoolean;
+    }, z.core.$strict>>], "fieldKind">>>;
+}, z.core.$strict>>;
+export declare const AgentConfigurationCatalogSchema: z.ZodType<AgentConfigurationCatalog>;
+export declare const AgentConfigurationValueSchema: 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">;
+export declare const AgentConfigurationSelectionInputSchema: z.ZodType<AgentConfigurationSelectionInput>;
+//# sourceMappingURL=configuration.d.ts.map

package/dist/zod/configuration.js

@@ -0,0 +1,157 @@
+import { z } from "zod/v4";
+import { compareStringsByUnicodeCodePoint } from "../foundation/ordering.js";
+import {
+  AGENT_CONFIGURATION_APPLICATION_TIMINGS,
+  AGENT_CONFIGURATION_DESCRIPTION_MAX_LENGTH,
+  AGENT_CONFIGURATION_FIELDS_MAX_LENGTH,
+  AGENT_CONFIGURATION_LABEL_MAX_LENGTH,
+  AGENT_CONFIGURATION_OPTIONS_MAX_LENGTH,
+  AGENT_CONFIGURATION_SCOPES,
+  AGENT_CONFIGURATION_TEXT_VALUE_MAX_LENGTH
+} from "../configuration/types.js";
+import {
+  AgentCanonicalIdValueSchema,
+  createAgentCanonicalNonBlankStringSchema
+} from "./foundation.js";
+const PositiveSafeIntegerSchema = z.number().int().positive().max(Number.MAX_SAFE_INTEGER);
+const SafeIntegerSchema = z.number().int().min(Number.MIN_SAFE_INTEGER).max(Number.MAX_SAFE_INTEGER);
+const LabelSchema = createAgentCanonicalNonBlankStringSchema(
+  AGENT_CONFIGURATION_LABEL_MAX_LENGTH
+);
+const DescriptionSchema = createAgentCanonicalNonBlankStringSchema(
+  AGENT_CONFIGURATION_DESCRIPTION_MAX_LENGTH
+);
+const CanonicalTextValueSchema = z.string().max(AGENT_CONFIGURATION_TEXT_VALUE_MAX_LENGTH).regex(/^(?:$|\S|\S[\s\S]*\S)$/u);
+const AgentConfigurationSelectOptionSchema = z.object({
+  optionId: AgentCanonicalIdValueSchema,
+  label: LabelSchema,
+  description: DescriptionSchema.optional()
+}).strict().readonly();
+const fieldBase = {
+  key: AgentCanonicalIdValueSchema,
+  revision: PositiveSafeIntegerSchema,
+  label: LabelSchema,
+  description: DescriptionSchema.optional(),
+  scope: z.enum(AGENT_CONFIGURATION_SCOPES),
+  applicationTiming: z.enum(AGENT_CONFIGURATION_APPLICATION_TIMINGS),
+  mutable: z.boolean()
+};
+const AgentConfigurationFieldPortableSchema = z.discriminatedUnion(
+  "fieldKind",
+  [
+    z.object({
+      ...fieldBase,
+      fieldKind: z.literal("boolean"),
+      currentValue: z.boolean()
+    }).strict().readonly(),
+    z.object({
+      ...fieldBase,
+      fieldKind: z.literal("single_select"),
+      currentValue: AgentCanonicalIdValueSchema,
+      options: z.array(AgentConfigurationSelectOptionSchema).min(1).max(AGENT_CONFIGURATION_OPTIONS_MAX_LENGTH).readonly()
+    }).strict().readonly(),
+    z.object({
+      ...fieldBase,
+      fieldKind: z.literal("bounded_integer"),
+      currentValue: SafeIntegerSchema,
+      minimum: SafeIntegerSchema,
+      maximum: SafeIntegerSchema
+    }).strict().readonly(),
+    z.object({
+      ...fieldBase,
+      fieldKind: z.literal("bounded_text"),
+      currentValue: CanonicalTextValueSchema,
+      maxLength: z.number().int().positive().max(AGENT_CONFIGURATION_TEXT_VALUE_MAX_LENGTH),
+      multiline: z.boolean()
+    }).strict().readonly()
+  ]
+);
+const AgentConfigurationCatalogPortableSchema = z.object({
+  revision: PositiveSafeIntegerSchema,
+  fields: z.array(AgentConfigurationFieldPortableSchema).max(AGENT_CONFIGURATION_FIELDS_MAX_LENGTH).readonly()
+}).strict().readonly();
+const AgentConfigurationCatalogSchema = AgentConfigurationCatalogPortableSchema.superRefine((catalog, context) => {
+  const keys = /* @__PURE__ */ new Set();
+  let previousKey = "";
+  catalog.fields.forEach((field, fieldIndex) => {
+    if (keys.has(field.key)) {
+      context.addIssue({
+        code: "custom",
+        path: ["fields", fieldIndex, "key"],
+        message: "Configuration field keys must be unique."
+      });
+    }
+    if (fieldIndex > 0 && compareStringsByUnicodeCodePoint(previousKey, field.key) >= 0) {
+      context.addIssue({
+        code: "custom",
+        path: ["fields", fieldIndex, "key"],
+        message: "Configuration fields must be ordered by key."
+      });
+    }
+    keys.add(field.key);
+    previousKey = field.key;
+    if (field.fieldKind === "single_select") {
+      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: "Configuration 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: "Configuration options must use canonical optionId order."
+          });
+        }
+        optionIds.add(option.optionId);
+      });
+      if (!optionIds.has(field.currentValue)) {
+        context.addIssue({
+          code: "custom",
+          path: ["fields", fieldIndex, "currentValue"],
+          message: "Current configuration value must be an offered option."
+        });
+      }
+    }
+    if (field.fieldKind === "bounded_integer" && (field.minimum > field.maximum || field.currentValue < field.minimum || field.currentValue > field.maximum)) {
+      context.addIssue({
+        code: "custom",
+        path: ["fields", fieldIndex, "currentValue"],
+        message: "Integer configuration bounds and current value are inconsistent."
+      });
+    }
+    if (field.fieldKind === "bounded_text" && field.currentValue.length > field.maxLength) {
+      context.addIssue({
+        code: "custom",
+        path: ["fields", fieldIndex, "currentValue"],
+        message: "Current text configuration value exceeds the field maximum."
+      });
+    }
+  });
+});
+const AgentConfigurationValueSchema = z.discriminatedUnion("fieldKind", [
+  z.object({ fieldKind: z.literal("boolean"), value: z.boolean() }).strict().readonly(),
+  z.object({ fieldKind: z.literal("single_select"), optionId: AgentCanonicalIdValueSchema }).strict().readonly(),
+  z.object({ fieldKind: z.literal("bounded_integer"), value: SafeIntegerSchema }).strict().readonly(),
+  z.object({ fieldKind: z.literal("bounded_text"), value: CanonicalTextValueSchema }).strict().readonly()
+]);
+const AgentConfigurationSelectionInputSchema = z.object({
+  key: AgentCanonicalIdValueSchema,
+  expectedCatalogRevision: PositiveSafeIntegerSchema,
+  expectedFieldRevision: PositiveSafeIntegerSchema,
+  value: AgentConfigurationValueSchema
+}).strict().readonly();
+export {
+  AgentConfigurationCatalogPortableSchema,
+  AgentConfigurationCatalogSchema,
+  AgentConfigurationFieldPortableSchema,
+  AgentConfigurationSelectionInputSchema,
+  AgentConfigurationValueSchema
+};