@agen-ai/agent-protocol 0.4.0 → 0.4.2

package/dist/zod/sessionInteractions.js

@@ -0,0 +1,284 @@
+import { z } from "zod/v4";
+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_RESPONSE_BYTES_LIMIT,
+  AGENT_SESSION_DECISION_TITLE_MAX_LENGTH,
+  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,
+  AgentRequestIdSchema,
+  AgentSessionIdSchema,
+  createAgentCanonicalNonBlankStringSchema,
+  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);
+}
+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"),
+  path: createAgentCanonicalNonBlankStringSchema(AGENT_SESSION_DECISION_WORKSPACE_PATH_BYTES_LIMIT).regex(/^[^\p{Cc}\p{Cf}]*$/u).refine(
+    (value) => encoder.encode(value).byteLength <= AGENT_SESSION_DECISION_WORKSPACE_PATH_BYTES_LIMIT,
+    "Workspace target path exceeds its UTF-8 byte limit."
+  )
+}).strict().readonly();
+const AgentSessionDecisionConsequenceSchema = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("grant"),
+    scope: z.literal("workspace"),
+    persistence: z.object({
+      kind: z.literal("provider_managed"),
+      duration: z.literal("persistent"),
+      mayAffectOtherSessions: z.literal(true)
+    }).strict().readonly()
+  }).strict().readonly(),
+  z.object({
+    kind: z.literal("decline"),
+    configuration: z.literal("remains_gated")
+  }).strict().readonly()
+]);
+const AgentSessionDecisionChoiceSchema = z.object({
+  choiceId: AgentSessionDecisionChoiceIdSchema,
+  label: SingleLineTextSchema,
+  description: descriptionSchema(AGENT_SESSION_DECISION_CHOICE_DESCRIPTION_MAX_LENGTH),
+  consequence: AgentSessionDecisionConsequenceSchema
+}).strict().readonly();
+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,
+  choices: nonemptyArraySchema(AgentSessionDecisionChoiceSchema, AGENT_SESSION_DECISION_CHOICES_MAX_LENGTH)
+}).strict().readonly();
+const offeredChoiceFields = {
+  label: SingleLineTextSchema,
+  description: descriptionSchema(AGENT_SESSION_DECISION_CHOICE_DESCRIPTION_MAX_LENGTH).optional()
+};
+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 seenIds = /* @__PURE__ */ new Set();
+  const seenActions = /* @__PURE__ */ new Set();
+  request.choices.forEach((choice, index) => {
+    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);
+    }
+  });
+  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 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,
+  AgentSessionDecisionConsequenceSchema,
+  AgentSessionDecisionRequestPortableSchema,
+  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

@@ -1,7 +1,7 @@
 import type { z } from 'zod/v4';
 import type { AgentAccountQuotaReset, AgentAccountQuotaSnapshot, AgentAccountQuotaWindow } from '../accountQuota/types.js';
 import type { AgentArtifactDescriptor } from '../artifacts/types.js';
-import type { AgentCapabilities } from '../capabilities/types.js';
+import type { AgentApprovalCapability, AgentCapabilities } from '../capabilities/types.js';
 import type { AgentCollaborationControlInput, AgentCollaborationNode, AgentCollaborationSpawnInput } from '../collaboration/types.js';
 import type { AgentCommandCatalog, AgentCommandDescriptor } from '../commands/types.js';
 import type { AgentConfigurationCatalog, AgentConfigurationSelectionInput } from '../configuration/types.js';
@@ -14,13 +14,14 @@ import type { AgentJsonValue, AgentProviderRefs } from '../foundation/types.js';
 import type { AgentIntegrationCatalog, AgentIntegrationDescriptor, AgentMcpIntegrationDescriptor } from '../integrations/types.js';
 import type { AgentManagedContentCatalog, AgentManagedContentDescriptor } from '../managedContent/types.js';
 import type { AgentOperationCatalog, AgentOperationDescriptor, AgentOperationInvocation, AgentOperationResult } from '../operations/types.js';
-import type { AgentRequest, AgentRequestResolution } from '../requests/types.js';
+import type { AgentApprovalConsequence, AgentRequest, AgentRequestResolution } from '../requests/types.js';
 import type { AgentGeneratedResourceDescriptor } from '../resources/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';
 import { AgentArtifactDescriptorSchema } from './artifacts.js';
-import { AgentCapabilitiesSchema } from './capabilities.js';
+import { AgentApprovalCapabilitySchema, AgentCapabilitiesSchema } from './capabilities.js';
 import { AgentCollaborationControlInputSchema, AgentCollaborationNodeSchema, AgentCollaborationSpawnInputSchema } from './collaboration.js';
 import { AgentCommandCatalogSchema, AgentCommandDescriptorSchema } from './commands.js';
 import { AgentConfigurationCatalogSchema, AgentConfigurationSelectionInputSchema } from './configuration.js';
@@ -33,13 +34,42 @@ import { AgentJsonValueSchema, AgentProviderRefsSchema } from './foundation.js';
 import { AgentIntegrationCatalogSchema, AgentIntegrationDescriptorSchema, AgentMcpIntegrationDescriptorSchema } from './integrations.js';
 import { AgentManagedContentCatalogSchema, AgentManagedContentDescriptorSchema } from './managedContent.js';
 import { AgentOperationCatalogSchema, AgentOperationDescriptorSchema, AgentOperationInvocationSchema, AgentOperationResultSchema } from './operations.js';
-import { AgentRequestResolutionSchema, AgentRequestSchema } from './requests.js';
+import { AgentApprovalConsequenceSchema, AgentRequestResolutionSchema, AgentRequestSchema } from './requests.js';
 import { AgentGeneratedResourceDescriptorSchema } from './resources.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;
 type Assert<Value extends true> = Value;
 export type AgentProtocolSchemaTypeAssertions = readonly [
+    Assert<Extends<z.output<typeof AgentSessionWorkspaceTargetSchema>, AgentSessionWorkspaceTarget>>,
+    Assert<Extends<AgentSessionWorkspaceTarget, z.output<typeof AgentSessionWorkspaceTargetSchema>>>,
+    Assert<Extends<z.output<typeof AgentSessionDecisionConsequenceSchema>, AgentSessionDecisionConsequence>>,
+    Assert<Extends<AgentSessionDecisionConsequence, z.output<typeof AgentSessionDecisionConsequenceSchema>>>,
+    Assert<Extends<z.output<typeof AgentSessionDecisionChoiceSchema>, AgentSessionDecisionChoice>>,
+    Assert<Extends<AgentSessionDecisionChoice, z.output<typeof AgentSessionDecisionChoiceSchema>>>,
+    Assert<Extends<z.output<typeof AgentSessionDecisionRequestSchema>, AgentSessionDecisionRequest>>,
+    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>>,
@@ -94,6 +124,10 @@ export type AgentProtocolSchemaTypeAssertions = readonly [
     Assert<Extends<AgentTurnInterruptionInput, z.output<typeof AgentTurnInterruptionInputSchema>>>,
     Assert<Extends<z.output<typeof AgentItemSnapshotSchema>, AgentItemSnapshot>>,
     Assert<Extends<AgentItemSnapshot, z.output<typeof AgentItemSnapshotSchema>>>,
+    Assert<Extends<z.output<typeof AgentApprovalConsequenceSchema>, AgentApprovalConsequence>>,
+    Assert<Extends<AgentApprovalConsequence, z.output<typeof AgentApprovalConsequenceSchema>>>,
+    Assert<Extends<z.output<typeof AgentApprovalCapabilitySchema>, AgentApprovalCapability>>,
+    Assert<Extends<AgentApprovalCapability, z.output<typeof AgentApprovalCapabilitySchema>>>,
     Assert<Extends<z.output<typeof AgentRequestSchema>, AgentRequest>>,
     Assert<Extends<AgentRequest, z.output<typeof AgentRequestSchema>>>,
     Assert<Extends<z.output<typeof AgentRequestResolutionSchema>, AgentRequestResolution>>,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agen-ai/agent-protocol",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "private": false,
   "description": "Provider-neutral sessions, turns, requests, capabilities, artifacts, and events for coding-agent runtimes.",
   "type": "module",
@@ -24,6 +24,10 @@
       "types": "./dist/public/sessions.d.ts",
       "import": "./dist/public/sessions.js"
     },
+    "./session-interactions": {
+      "types": "./dist/public/sessionInteractions.d.ts",
+      "import": "./dist/public/sessionInteractions.js"
+    },
     "./turns": {
       "types": "./dist/public/turns.d.ts",
       "import": "./dist/public/turns.js"
@@ -100,7 +104,7 @@
   },
   "dependencies": {
     "zod": "4.4.3",
-    "@agen-ai/validation": "^0.4.0"
+    "@agen-ai/validation": "^0.4.2"
   },
   "devDependencies": {
     "ajv": "8.17.1",