@agen-ai/agent-protocol 0.2.1 → 0.2.3

package/dist/zod/capabilities.js

@@ -1,6 +1,5 @@
 import { z } from "zod/v4";
 import {
-  AGENT_PROTOCOL_COLLECTION_MAX_LENGTH,
   AGENT_PROTOCOL_VERSION
 } from "../foundation/types.js";
 import { AGENT_ARTIFACT_KINDS } from "../artifacts/types.js";
@@ -8,10 +7,40 @@ import {
   AGENT_AUTHENTICATION_FLOWS,
   AGENT_FILE_CHANGE_MODES
 } from "../capabilities/types.js";
+import {
+  AGENT_COLLABORATION_CONTROL_ACTIONS,
+  AGENT_COLLABORATION_GRAPH_LIMITS,
+  AGENT_COLLABORATION_ROLES
+} from "../collaboration/types.js";
+import {
+  AGENT_CONFIGURATION_FIELD_KINDS,
+  AGENT_CONFIGURATION_FIELDS_MAX_LENGTH
+} from "../configuration/types.js";
+import {
+  AGENT_INTEGRATION_KINDS,
+  AGENT_INTEGRATION_RESOURCES_MAX_LENGTH,
+  AGENT_INTEGRATION_CATALOG_MAX_LENGTH,
+  AGENT_INTEGRATION_SERVERS_MAX_LENGTH,
+  AGENT_INTEGRATION_TOOLS_MAX_LENGTH
+} from "../integrations/types.js";
+import {
+  AGENT_MANAGED_CONTENT_CATALOG_MAX_LENGTH,
+  AGENT_MANAGED_CONTENT_KINDS
+} from "../managedContent/types.js";
+import {
+  AGENT_OPERATION_CATALOG_MAX_LENGTH,
+  AGENT_OPERATION_EXECUTION_MODES,
+  AGENT_OPERATION_FIELDS_MAX_LENGTH,
+  AGENT_OPERATION_FIELD_KINDS,
+  AGENT_OPERATION_KINDS
+} from "../operations/types.js";
 import {
   AGENT_APPROVAL_PERSISTENCES,
-  AGENT_APPROVAL_SCOPE_KINDS
+  AGENT_APPROVAL_SCOPE_KINDS,
+  AGENT_ELICITATION_FIELD_KINDS,
+  AGENT_ELICITATION_FIELDS_MAX_LENGTH
 } from "../requests/types.js";
+import { AGENT_GENERATED_RESOURCE_KINDS } from "../resources/types.js";
 import {
   AGENT_CONTEXT_COMPACTION_TRIGGERS,
   AGENT_CONTEXT_CUMULATIVE_USAGE_FIELDS,
@@ -21,7 +50,6 @@ import {
   AGENT_TURN_INTERACTION_MODES
 } from "../turns/types.js";
 import { AgentProviderKeySchema } from "./foundation.js";
-const AgentCapabilityIdentifierSchema = z.string().min(1).max(100).regex(/^[a-z][a-z0-9._:-]*$/u);
 function addCanonicalListIssues(input, context) {
   const seen = /* @__PURE__ */ new Set();
   let previousOrder = -1;
@@ -46,6 +74,9 @@ function addCanonicalListIssues(input, context) {
   });
 }
 const PositiveSafeIntegerSchema = z.number().int().positive().max(Number.MAX_SAFE_INTEGER);
+function boundedPositiveSafeInteger(maximum) {
+  return z.number().int().positive().max(maximum);
+}
 const AgentApprovalCapabilitySchema = z.discriminatedUnion("kind", [
   z.object({ kind: z.literal("unsupported") }).strict().readonly(),
   z.object({
@@ -56,7 +87,28 @@ const AgentApprovalCapabilitySchema = z.discriminatedUnion("kind", [
         scopeKinds: z.array(z.enum(AGENT_APPROVAL_SCOPE_KINDS)).min(1).max(AGENT_APPROVAL_SCOPE_KINDS.length).meta({ uniqueItems: true }).readonly()
       }).strict().readonly()
     ).min(1).max(AGENT_APPROVAL_PERSISTENCES.length).readonly()
-  }).strict().readonly()
+  }).strict().superRefine((capability, context) => {
+    addCanonicalListIssues(
+      {
+        values: capability.modes.map((mode) => mode.persistence),
+        canonicalOrder: AGENT_APPROVAL_PERSISTENCES,
+        path: ["modes"],
+        label: "Approval persistence modes"
+      },
+      context
+    );
+    capability.modes.forEach((mode, index) => {
+      addCanonicalListIssues(
+        {
+          values: mode.scopeKinds,
+          canonicalOrder: AGENT_APPROVAL_SCOPE_KINDS,
+          path: ["modes", index, "scopeKinds"],
+          label: "Approval scope kinds"
+        },
+        context
+      );
+    });
+  }).readonly()
 ]);
 const AgentContextUsageCapabilitySchema = z.discriminatedUnion("kind", [
   z.object({ kind: z.literal("unsupported") }).strict().readonly(),
@@ -133,6 +185,74 @@ const AgentOperationInputCapabilitySchema = z.object({
   text: z.literal(true),
   images: AgentImageInputCapabilitySchema
 }).strict().readonly();
+const AgentOperationsCapabilitySchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("unsupported") }).strict().readonly(),
+  z.object({
+    kind: z.literal("supported"),
+    operationKinds: z.array(z.enum(AGENT_OPERATION_KINDS)).min(1).max(AGENT_OPERATION_KINDS.length).meta({ uniqueItems: true }).readonly(),
+    fieldKinds: z.array(z.enum(AGENT_OPERATION_FIELD_KINDS)).min(1).max(AGENT_OPERATION_FIELD_KINDS.length).meta({ uniqueItems: true }).readonly(),
+    executionModes: z.array(z.enum(AGENT_OPERATION_EXECUTION_MODES)).min(1).max(AGENT_OPERATION_EXECUTION_MODES.length).meta({ uniqueItems: true }).readonly(),
+    maxOperations: boundedPositiveSafeInteger(
+      AGENT_OPERATION_CATALOG_MAX_LENGTH
+    ),
+    maxFieldsPerOperation: boundedPositiveSafeInteger(
+      AGENT_OPERATION_FIELDS_MAX_LENGTH
+    )
+  }).strict().readonly()
+]);
+const AgentManagedContentCapabilitySchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("unsupported") }).strict().readonly(),
+  z.object({
+    kind: z.literal("supported"),
+    contentKinds: z.array(z.enum(AGENT_MANAGED_CONTENT_KINDS)).min(1).max(AGENT_MANAGED_CONTENT_KINDS.length).meta({ uniqueItems: true }).readonly(),
+    maxEntries: boundedPositiveSafeInteger(
+      AGENT_MANAGED_CONTENT_CATALOG_MAX_LENGTH
+    )
+  }).strict().readonly()
+]);
+const AgentIntegrationsCapabilitySchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("unsupported") }).strict().readonly(),
+  z.object({
+    kind: z.literal("supported"),
+    integrationKinds: z.array(z.enum(AGENT_INTEGRATION_KINDS)).min(1).max(AGENT_INTEGRATION_KINDS.length).meta({ uniqueItems: true }).readonly(),
+    maxIntegrations: boundedPositiveSafeInteger(
+      AGENT_INTEGRATION_CATALOG_MAX_LENGTH
+    ),
+    maxServersPerIntegration: boundedPositiveSafeInteger(
+      AGENT_INTEGRATION_SERVERS_MAX_LENGTH
+    ),
+    maxToolsPerServer: boundedPositiveSafeInteger(
+      AGENT_INTEGRATION_TOOLS_MAX_LENGTH
+    ),
+    maxResourcesPerServer: boundedPositiveSafeInteger(
+      AGENT_INTEGRATION_RESOURCES_MAX_LENGTH
+    )
+  }).strict().readonly()
+]);
+const AgentCollaborationCapabilitySchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("unsupported") }).strict().readonly(),
+  z.object({
+    kind: z.literal("supported"),
+    roles: z.array(z.enum(AGENT_COLLABORATION_ROLES)).min(1).max(AGENT_COLLABORATION_ROLES.length).meta({ uniqueItems: true }).readonly(),
+    controlActions: z.array(z.enum(AGENT_COLLABORATION_CONTROL_ACTIONS)).min(1).max(AGENT_COLLABORATION_CONTROL_ACTIONS.length).meta({ uniqueItems: true }).readonly(),
+    maxDepth: boundedPositiveSafeInteger(AGENT_COLLABORATION_GRAPH_LIMITS.maxDepth),
+    maxChildrenPerNode: boundedPositiveSafeInteger(
+      AGENT_COLLABORATION_GRAPH_LIMITS.maxChildrenPerNode
+    ),
+    maxActiveNodes: boundedPositiveSafeInteger(
+      AGENT_COLLABORATION_GRAPH_LIMITS.maxActiveNodes
+    )
+  }).strict().readonly()
+]);
+const AgentGeneratedResourcesCapabilitySchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("unsupported") }).strict().readonly(),
+  z.object({
+    kind: z.literal("supported"),
+    resourceKinds: z.array(z.enum(AGENT_GENERATED_RESOURCE_KINDS)).min(1).max(AGENT_GENERATED_RESOURCE_KINDS.length).meta({ uniqueItems: true }).readonly(),
+    maxResourcesPerTurn: boundedPositiveSafeInteger(100),
+    maxBytesPerResource: boundedPositiveSafeInteger(1073741824)
+  }).strict().readonly()
+]);
 const AgentCapabilitiesPortableSchema = z.object({
   protocolVersion: z.literal(AGENT_PROTOCOL_VERSION),
   providerKey: AgentProviderKeySchema,
@@ -159,8 +279,14 @@ const AgentCapabilitiesPortableSchema = z.object({
     approval: AgentApprovalCapabilitySchema,
     elicitation: z.discriminatedUnion("kind", [
       z.object({ kind: z.literal("unsupported") }).strict().readonly(),
-      z.object({ kind: z.literal("text") }).strict().readonly(),
-      z.object({ kind: z.literal("structured") }).strict().readonly()
+      z.object({
+        kind: z.literal("supported"),
+        fieldKinds: z.array(z.enum(AGENT_ELICITATION_FIELD_KINDS)).min(1).max(AGENT_ELICITATION_FIELD_KINDS.length).meta({ uniqueItems: true }).readonly(),
+        maxFields: boundedPositiveSafeInteger(
+          AGENT_ELICITATION_FIELDS_MAX_LENGTH
+        ),
+        sensitiveFields: z.boolean()
+      }).strict().readonly()
     ])
   }).strict().readonly(),
   context: z.object({
@@ -178,20 +304,17 @@ const AgentCapabilitiesPortableSchema = z.object({
     z.object({ kind: z.literal("managed") }).strict().readonly(),
     z.object({
       kind: z.literal("selectable"),
-      fields: z.array(
-        z.object({
-          key: AgentCapabilityIdentifierSchema,
-          optionIds: z.array(AgentCapabilityIdentifierSchema).min(1).max(AGENT_PROTOCOL_COLLECTION_MAX_LENGTH).meta({ uniqueItems: true }).readonly()
-        }).strict().readonly()
-      ).min(1).max(AGENT_PROTOCOL_COLLECTION_MAX_LENGTH).readonly()
+      fieldKinds: z.array(z.enum(AGENT_CONFIGURATION_FIELD_KINDS)).min(1).max(AGENT_CONFIGURATION_FIELD_KINDS.length).meta({ uniqueItems: true }).readonly(),
+      maxFields: boundedPositiveSafeInteger(
+        AGENT_CONFIGURATION_FIELDS_MAX_LENGTH
+      )
     }).strict().readonly()
   ]),
-  interactionExtensions: z.object({
-    slashCommands: z.boolean(),
-    mcp: z.boolean(),
-    subagents: z.boolean(),
-    imageGeneration: z.boolean()
-  }).strict().readonly(),
+  operations: AgentOperationsCapabilitySchema,
+  managedContent: AgentManagedContentCapabilitySchema,
+  integrations: AgentIntegrationsCapabilitySchema,
+  collaboration: AgentCollaborationCapabilitySchema,
+  generatedResources: AgentGeneratedResourcesCapabilitySchema,
   authentication: z.discriminatedUnion("kind", [
     z.object({ kind: z.literal("unsupported") }).strict().readonly(),
     z.object({
@@ -211,30 +334,6 @@ const AgentCapabilitiesSchema = AgentCapabilitiesPortableSchema.superRefine((cap
     },
     context
   );
-  if (capabilities.requests.approval.kind === "supported") {
-    addCanonicalListIssues(
-      {
-        values: capabilities.requests.approval.modes.map(
-          (mode) => mode.persistence
-        ),
-        canonicalOrder: AGENT_APPROVAL_PERSISTENCES,
-        path: ["requests", "approval", "modes"],
-        label: "Approval persistence modes"
-      },
-      context
-    );
-    capabilities.requests.approval.modes.forEach((mode, index) => {
-      addCanonicalListIssues(
-        {
-          values: mode.scopeKinds,
-          canonicalOrder: AGENT_APPROVAL_SCOPE_KINDS,
-          path: ["requests", "approval", "modes", index, "scopeKinds"],
-          label: "Approval scope kinds"
-        },
-        context
-      );
-    });
-  }
   if (capabilities.context.usage.kind === "supported") {
     addCanonicalListIssues(
       {
@@ -276,25 +375,88 @@ const AgentCapabilitiesSchema = AgentCapabilitiesPortableSchema.superRefine((cap
     context
   );
   if (capabilities.configuration.kind === "selectable") {
-    const keys = capabilities.configuration.fields.map((field) => field.key);
     addCanonicalListIssues(
       {
-        values: keys,
-        path: ["configuration", "fields"],
-        label: "Selectable configuration fields"
+        values: capabilities.configuration.fieldKinds,
+        canonicalOrder: AGENT_CONFIGURATION_FIELD_KINDS,
+        path: ["configuration", "fieldKinds"],
+        label: "Selectable configuration field kinds"
+      },
+      context
+    );
+  }
+  if (capabilities.requests.elicitation.kind === "supported") {
+    addCanonicalListIssues(
+      {
+        values: capabilities.requests.elicitation.fieldKinds,
+        canonicalOrder: AGENT_ELICITATION_FIELD_KINDS,
+        path: ["requests", "elicitation", "fieldKinds"],
+        label: "Elicitation field kinds"
+      },
+      context
+    );
+  }
+  if (capabilities.operations.kind === "supported") {
+    for (const [values, canonicalOrder, path, label] of [
+      [capabilities.operations.operationKinds, AGENT_OPERATION_KINDS, ["operations", "operationKinds"], "Operation kinds"],
+      [capabilities.operations.fieldKinds, AGENT_OPERATION_FIELD_KINDS, ["operations", "fieldKinds"], "Operation field kinds"],
+      [capabilities.operations.executionModes, AGENT_OPERATION_EXECUTION_MODES, ["operations", "executionModes"], "Operation execution modes"]
+    ]) {
+      addCanonicalListIssues({ values, canonicalOrder, path, label }, context);
+    }
+  }
+  if (capabilities.managedContent.kind === "supported") {
+    addCanonicalListIssues(
+      {
+        values: capabilities.managedContent.contentKinds,
+        canonicalOrder: AGENT_MANAGED_CONTENT_KINDS,
+        path: ["managedContent", "contentKinds"],
+        label: "Managed content kinds"
+      },
+      context
+    );
+  }
+  if (capabilities.integrations.kind === "supported") {
+    addCanonicalListIssues(
+      {
+        values: capabilities.integrations.integrationKinds,
+        canonicalOrder: AGENT_INTEGRATION_KINDS,
+        path: ["integrations", "integrationKinds"],
+        label: "Integration kinds"
+      },
+      context
+    );
+  }
+  if (capabilities.collaboration.kind === "supported") {
+    addCanonicalListIssues(
+      {
+        values: capabilities.collaboration.roles,
+        canonicalOrder: AGENT_COLLABORATION_ROLES,
+        path: ["collaboration", "roles"],
+        label: "Collaboration roles"
+      },
+      context
+    );
+    addCanonicalListIssues(
+      {
+        values: capabilities.collaboration.controlActions,
+        canonicalOrder: AGENT_COLLABORATION_CONTROL_ACTIONS,
+        path: ["collaboration", "controlActions"],
+        label: "Collaboration control actions"
+      },
+      context
+    );
+  }
+  if (capabilities.generatedResources.kind === "supported") {
+    addCanonicalListIssues(
+      {
+        values: capabilities.generatedResources.resourceKinds,
+        canonicalOrder: AGENT_GENERATED_RESOURCE_KINDS,
+        path: ["generatedResources", "resourceKinds"],
+        label: "Generated resource kinds"
       },
       context
     );
-    capabilities.configuration.fields.forEach((field, index) => {
-      addCanonicalListIssues(
-        {
-          values: field.optionIds,
-          path: ["configuration", "fields", index, "optionIds"],
-          label: "Selectable configuration option IDs"
-        },
-        context
-      );
-    });
   }
   if (capabilities.authentication.kind === "supported") {
     addCanonicalListIssues(

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
+};