@agen-ai/agent-protocol 0.4.0 → 0.4.2

package/dist/public/index.d.ts

@@ -2,6 +2,7 @@ export * from '../foundation/index.js';
 export * from '../failures/index.js';
 export * from '../accountQuota/index.js';
 export * from '../sessions/index.js';
+export * from '../sessionInteractions/index.js';
 export * from '../turns/index.js';
 export * from '../requests/index.js';
 export * from '../operations/index.js';

package/dist/public/index.js

@@ -2,6 +2,7 @@ export * from "../foundation/index.js";
 export * from "../failures/index.js";
 export * from "../accountQuota/index.js";
 export * from "../sessions/index.js";
+export * from "../sessionInteractions/index.js";
 export * from "../turns/index.js";
 export * from "../requests/index.js";
 export * from "../operations/index.js";

package/dist/public/sessionInteractions.d.ts

@@ -0,0 +1,2 @@
+export * from '../sessionInteractions/index.js';
+//# sourceMappingURL=sessionInteractions.d.ts.map

package/dist/public/sessionInteractions.js

@@ -0,0 +1 @@
+export * from "../sessionInteractions/index.js";

package/dist/requests/elicitation.d.ts

@@ -0,0 +1,4 @@
+import type { ValidationIssue } from '@agen-ai/validation';
+import type { AgentElicitationAnswer, AgentElicitationField } from './types.js';
+export declare function elicitationResponseIssues(fieldsInput: readonly AgentElicitationField[], answers: readonly AgentElicitationAnswer[]): readonly ValidationIssue[];
+//# sourceMappingURL=elicitation.d.ts.map

package/dist/requests/elicitation.js

@@ -0,0 +1,107 @@
+function issue(path, message) {
+  return { code: "custom", path, message };
+}
+function singleSelectAnswerIssues(field, answer, answerIndex) {
+  const issues = [];
+  const allowedValues = new Set(field.options.map((option) => option.value));
+  if (answer.value !== void 0 && !allowedValues.has(answer.value)) {
+    issues.push(issue(
+      ["answers", answerIndex, "value"],
+      "Single-select answers must reference an option declared by the request."
+    ));
+  }
+  if (answer.other !== void 0 && !field.allowOther) {
+    issues.push(issue(
+      ["answers", answerIndex, "other"],
+      "This request field does not accept a custom choice."
+    ));
+  }
+  return issues;
+}
+function multiSelectAnswerIssues(field, answer, answerIndex) {
+  const issues = [];
+  const allowedValues = new Set(field.options.map((option) => option.value));
+  if (answer.values.some((value) => !allowedValues.has(value))) {
+    issues.push(issue(
+      ["answers", answerIndex, "values"],
+      "Multi-select answers must reference options declared by the request."
+    ));
+  }
+  if (answer.other !== void 0 && !field.allowOther) {
+    issues.push(issue(
+      ["answers", answerIndex, "other"],
+      "This request field does not accept a custom choice."
+    ));
+  }
+  const selectionCount = answer.values.length + (answer.other === void 0 ? 0 : 1);
+  if (field.required && selectionCount === 0) {
+    issues.push(issue(
+      ["answers", answerIndex],
+      "A required multi-select answer needs a declared option or a custom choice."
+    ));
+  }
+  if (selectionCount > field.maxSelections) {
+    issues.push(issue(
+      ["answers", answerIndex],
+      "This request field exceeds its maximum selection count."
+    ));
+  }
+  return issues;
+}
+function answerIssues(field, answer, answerIndex) {
+  if (field.kind !== answer.kind) {
+    return [issue(
+      ["answers", answerIndex, "kind"],
+      "Answer kind must match the corresponding request field."
+    )];
+  }
+  if (field.kind === "text" && answer.kind === "text") {
+    return answer.value.length <= field.maxLength ? [] : [issue(
+      ["answers", answerIndex, "value"],
+      "Text answer exceeds the field maximum length."
+    )];
+  }
+  if (field.kind === "single_select" && answer.kind === "single_select") {
+    return singleSelectAnswerIssues(field, answer, answerIndex);
+  }
+  if (field.kind === "multi_select" && answer.kind === "multi_select") {
+    return multiSelectAnswerIssues(field, answer, answerIndex);
+  }
+  return [];
+}
+function elicitationResponseIssues(fieldsInput, answers) {
+  const issues = [];
+  const fields = new Map(fieldsInput.map((field) => [field.fieldId, field]));
+  const answered = /* @__PURE__ */ new Set();
+  answers.forEach((answer, answerIndex) => {
+    if (answered.has(answer.fieldId)) {
+      issues.push(issue(
+        ["answers", answerIndex, "fieldId"],
+        "Each request field may be answered once."
+      ));
+      return;
+    }
+    answered.add(answer.fieldId);
+    const field = fields.get(answer.fieldId);
+    if (!field) {
+      issues.push(issue(
+        ["answers", answerIndex, "fieldId"],
+        "Answer fieldId must reference a field declared by the request."
+      ));
+      return;
+    }
+    issues.push(...answerIssues(field, answer, answerIndex));
+  });
+  for (const field of fieldsInput) {
+    if (field.required && !answered.has(field.fieldId)) {
+      issues.push(issue(
+        ["answers"],
+        `Required request field ${field.fieldId} is missing an answer.`
+      ));
+    }
+  }
+  return issues;
+}
+export {
+  elicitationResponseIssues
+};

package/dist/requests/parsers.js

@@ -2,6 +2,7 @@ import {
   AgentProtocolValidationError
 } from "../foundation/index.js";
 import { parseWithSchema, safeParseWithSchema } from "../internal/parsers.js";
+import { elicitationResponseIssues } from "./elicitation.js";
 import {
   AgentApprovalRequestSchema,
   AgentApprovalResolutionSchema,
@@ -35,77 +36,6 @@ function safeParseAgentApprovalResolution(input) {
 function issue(path, message) {
   return { code: "custom", path, message };
 }
-function fieldMap(request) {
-  return new Map(request.fields.map((field) => [field.fieldId, field]));
-}
-function singleSelectAnswerIssues(field, answer, answerIndex) {
-  const issues = [];
-  const allowedValues = new Set(field.options.map((option) => option.value));
-  if (answer.value !== void 0 && !allowedValues.has(answer.value)) {
-    issues.push(issue(
-      ["answers", answerIndex, "value"],
-      "Single-select answers must reference an option declared by the request."
-    ));
-  }
-  if (answer.other !== void 0 && !field.allowOther) {
-    issues.push(issue(
-      ["answers", answerIndex, "other"],
-      "This request field does not accept a custom choice."
-    ));
-  }
-  return issues;
-}
-function multiSelectAnswerIssues(field, answer, answerIndex) {
-  const issues = [];
-  const allowedValues = new Set(field.options.map((option) => option.value));
-  if (answer.values.some((value) => !allowedValues.has(value))) {
-    issues.push(issue(
-      ["answers", answerIndex, "values"],
-      "Multi-select answers must reference options declared by the request."
-    ));
-  }
-  if (answer.other !== void 0 && !field.allowOther) {
-    issues.push(issue(
-      ["answers", answerIndex, "other"],
-      "This request field does not accept a custom choice."
-    ));
-  }
-  const selectionCount = answer.values.length + (answer.other === void 0 ? 0 : 1);
-  if (field.required && selectionCount === 0) {
-    issues.push(issue(
-      ["answers", answerIndex],
-      "A required multi-select answer needs a declared option or a custom choice."
-    ));
-  }
-  if (selectionCount > field.maxSelections) {
-    issues.push(issue(
-      ["answers", answerIndex],
-      "This request field exceeds its maximum selection count."
-    ));
-  }
-  return issues;
-}
-function answerIssues(field, answer, answerIndex) {
-  if (field.kind !== answer.kind) {
-    return [issue(
-      ["answers", answerIndex, "kind"],
-      "Answer kind must match the corresponding request field."
-    )];
-  }
-  if (field.kind === "text" && answer.kind === "text") {
-    return answer.value.length <= field.maxLength ? [] : [issue(
-      ["answers", answerIndex, "value"],
-      "Text answer exceeds the field maximum length."
-    )];
-  }
-  if (field.kind === "single_select" && answer.kind === "single_select") {
-    return singleSelectAnswerIssues(field, answer, answerIndex);
-  }
-  if (field.kind === "multi_select" && answer.kind === "multi_select") {
-    return multiSelectAnswerIssues(field, answer, answerIndex);
-  }
-  return [];
-}
 function resolutionIssues(request, resolution) {
   const issues = [];
   if (request.requestKind !== resolution.requestKind) {
@@ -131,35 +61,7 @@ function resolutionIssues(request, resolution) {
   if (request.requestKind !== "elicitation" || resolution.requestKind !== "elicitation" || resolution.disposition !== "answered") {
     return issues;
   }
-  const fields = fieldMap(request);
-  const answered = /* @__PURE__ */ new Set();
-  resolution.answers.forEach((answer, answerIndex) => {
-    if (answered.has(answer.fieldId)) {
-      issues.push(issue(
-        ["answers", answerIndex, "fieldId"],
-        "Each request field may be answered once."
-      ));
-      return;
-    }
-    answered.add(answer.fieldId);
-    const field = fields.get(answer.fieldId);
-    if (!field) {
-      issues.push(issue(
-        ["answers", answerIndex, "fieldId"],
-        "Answer fieldId must reference a field declared by the request."
-      ));
-      return;
-    }
-    issues.push(...answerIssues(field, answer, answerIndex));
-  });
-  for (const field of request.fields) {
-    if (field.required && !answered.has(field.fieldId)) {
-      issues.push(issue(
-        ["answers"],
-        `Required request field ${field.fieldId} is missing an answer.`
-      ));
-    }
-  }
+  issues.push(...elicitationResponseIssues(request.fields, resolution.answers));
   return issues;
 }
 function safeParseAgentRequestResolutionFor(requestInput, resolutionInput) {

package/dist/requests/types.d.ts

@@ -22,15 +22,28 @@ export type AgentApprovalSubject = (AgentApprovalSubjectBase & Readonly<{
     kind: 'command' | 'file_change' | 'tool' | 'other';
     itemId: AgentItemId;
 }>);
+export type AgentApprovalConsequence = Readonly<{
+    kind: 'scoped';
+    persistence: AgentApprovalPersistence;
+    scope: Readonly<{
+        kind: AgentApprovalScopeKind;
+    }>;
+}> | Readonly<{
+    kind: 'provider_managed_remembrance';
+    duration: Readonly<{
+        kind: 'unknown';
+    }>;
+    applicability: Readonly<{
+        kind: 'unknown';
+    }>;
+    explanation: string;
+}>;
 export interface AgentApprovalOption {
     readonly optionId: AgentApprovalOptionId;
     readonly label: string;
     readonly description?: string;
     readonly decision: 'approved' | 'denied';
-    readonly persistence: AgentApprovalPersistence;
-    readonly scope: Readonly<{
-        kind: AgentApprovalScopeKind;
-    }>;
+    readonly consequence: AgentApprovalConsequence;
 }
 export interface AgentApprovalRequest {
     readonly requestKind: 'approval';

package/dist/sessionInteractions/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types.js';
+export * from './parsers.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/sessionInteractions/index.js

@@ -0,0 +1,2 @@
+export * from "./types.js";
+export * from "./parsers.js";

package/dist/sessionInteractions/parsers.d.ts

@@ -0,0 +1,37 @@
+import { type AgentProtocolParseResult } from '../foundation/index.js';
+import type { AgentSessionDecisionChoiceId, AgentSessionFormChoiceId, AgentSessionPlanReviewChoiceId, AgentSessionPlanId, AgentSessionPlanRevision, AgentSessionDecisionRequest, AgentSessionFormRequest, AgentSessionPlanReviewRequest, AgentSessionRequest, AgentSessionDecisionResponse, AgentSessionFormResponse, AgentSessionPlanReviewResponse, AgentSessionResponse } from './types.js';
+export declare function parseAgentSessionDecisionChoiceId(input: unknown): AgentSessionDecisionChoiceId;
+export declare function safeParseAgentSessionDecisionChoiceId(input: unknown): AgentProtocolParseResult<AgentSessionDecisionChoiceId>;
+export declare function parseAgentSessionFormChoiceId(input: unknown): AgentSessionFormChoiceId;
+export declare function safeParseAgentSessionFormChoiceId(input: unknown): AgentProtocolParseResult<AgentSessionFormChoiceId>;
+export declare function parseAgentSessionPlanReviewChoiceId(input: unknown): AgentSessionPlanReviewChoiceId;
+export declare function safeParseAgentSessionPlanReviewChoiceId(input: unknown): AgentProtocolParseResult<AgentSessionPlanReviewChoiceId>;
+export declare function parseAgentSessionPlanId(input: unknown): AgentSessionPlanId;
+export declare function safeParseAgentSessionPlanId(input: unknown): AgentProtocolParseResult<AgentSessionPlanId>;
+export declare function parseAgentSessionPlanRevision(input: unknown): AgentSessionPlanRevision;
+export declare function safeParseAgentSessionPlanRevision(input: unknown): AgentProtocolParseResult<AgentSessionPlanRevision>;
+export declare function parseAgentSessionDecisionRequest(input: unknown): AgentSessionDecisionRequest;
+export declare function safeParseAgentSessionDecisionRequest(input: unknown): AgentProtocolParseResult<AgentSessionDecisionRequest>;
+export declare function parseAgentSessionFormRequest(input: unknown): AgentSessionFormRequest;
+export declare function safeParseAgentSessionFormRequest(input: unknown): AgentProtocolParseResult<AgentSessionFormRequest>;
+export declare function parseAgentSessionPlanReviewRequest(input: unknown): AgentSessionPlanReviewRequest;
+export declare function safeParseAgentSessionPlanReviewRequest(input: unknown): AgentProtocolParseResult<AgentSessionPlanReviewRequest>;
+export declare function parseAgentSessionRequest(input: unknown): AgentSessionRequest;
+export declare function safeParseAgentSessionRequest(input: unknown): AgentProtocolParseResult<AgentSessionRequest>;
+export declare function parseAgentSessionDecisionResponse(input: unknown): AgentSessionDecisionResponse;
+export declare function safeParseAgentSessionDecisionResponse(input: unknown): AgentProtocolParseResult<AgentSessionDecisionResponse>;
+export declare function parseAgentSessionFormResponse(input: unknown): AgentSessionFormResponse;
+export declare function safeParseAgentSessionFormResponse(input: unknown): AgentProtocolParseResult<AgentSessionFormResponse>;
+export declare function parseAgentSessionPlanReviewResponse(input: unknown): AgentSessionPlanReviewResponse;
+export declare function safeParseAgentSessionPlanReviewResponse(input: unknown): AgentProtocolParseResult<AgentSessionPlanReviewResponse>;
+export declare function parseAgentSessionResponse(input: unknown): AgentSessionResponse;
+export declare function safeParseAgentSessionResponse(input: unknown): AgentProtocolParseResult<AgentSessionResponse>;
+export declare function safeParseAgentSessionDecisionResponseFor(requestInput: unknown, responseInput: unknown): AgentProtocolParseResult<AgentSessionDecisionResponse>;
+export declare function parseAgentSessionDecisionResponseFor(request: AgentSessionDecisionRequest, input: unknown): AgentSessionDecisionResponse;
+export declare function safeParseAgentSessionFormResponseFor(requestInput: unknown, responseInput: unknown): AgentProtocolParseResult<AgentSessionFormResponse>;
+export declare function parseAgentSessionFormResponseFor(request: AgentSessionFormRequest, input: unknown): AgentSessionFormResponse;
+export declare function safeParseAgentSessionPlanReviewResponseFor(requestInput: unknown, responseInput: unknown): AgentProtocolParseResult<AgentSessionPlanReviewResponse>;
+export declare function parseAgentSessionPlanReviewResponseFor(request: AgentSessionPlanReviewRequest, input: unknown): AgentSessionPlanReviewResponse;
+export declare function safeParseAgentSessionResponseFor(requestInput: unknown, responseInput: unknown): AgentProtocolParseResult<AgentSessionResponse>;
+export declare function parseAgentSessionResponseFor(request: AgentSessionRequest, input: unknown): AgentSessionResponse;
+//# sourceMappingURL=parsers.d.ts.map

package/dist/sessionInteractions/parsers.js

@@ -0,0 +1,201 @@
+import {
+  AgentProtocolValidationError
+} from "../foundation/index.js";
+import { parseWithSchema, safeParseWithSchema } from "../internal/parsers.js";
+import { elicitationResponseIssues } from "../requests/elicitation.js";
+import {
+  AgentSessionDecisionChoiceIdSchema,
+  AgentSessionFormChoiceIdSchema,
+  AgentSessionPlanReviewChoiceIdSchema,
+  AgentSessionPlanIdSchema,
+  AgentSessionPlanRevisionSchema,
+  AgentSessionDecisionRequestSchema,
+  AgentSessionFormRequestSchema,
+  AgentSessionPlanReviewRequestSchema,
+  AgentSessionRequestSchema,
+  AgentSessionDecisionResponseSchema,
+  AgentSessionFormResponseSchema,
+  AgentSessionPlanReviewResponseSchema,
+  AgentSessionResponseSchema
+} from "../zod/sessionInteractions.js";
+function parseAgentSessionDecisionChoiceId(input) {
+  return parseWithSchema(AgentSessionDecisionChoiceIdSchema, input);
+}
+function safeParseAgentSessionDecisionChoiceId(input) {
+  return safeParseWithSchema(AgentSessionDecisionChoiceIdSchema, input);
+}
+function parseAgentSessionFormChoiceId(input) {
+  return parseWithSchema(AgentSessionFormChoiceIdSchema, input);
+}
+function safeParseAgentSessionFormChoiceId(input) {
+  return safeParseWithSchema(AgentSessionFormChoiceIdSchema, input);
+}
+function parseAgentSessionPlanReviewChoiceId(input) {
+  return parseWithSchema(AgentSessionPlanReviewChoiceIdSchema, input);
+}
+function safeParseAgentSessionPlanReviewChoiceId(input) {
+  return safeParseWithSchema(AgentSessionPlanReviewChoiceIdSchema, input);
+}
+function parseAgentSessionPlanId(input) {
+  return parseWithSchema(AgentSessionPlanIdSchema, input);
+}
+function safeParseAgentSessionPlanId(input) {
+  return safeParseWithSchema(AgentSessionPlanIdSchema, input);
+}
+function parseAgentSessionPlanRevision(input) {
+  return parseWithSchema(AgentSessionPlanRevisionSchema, input);
+}
+function safeParseAgentSessionPlanRevision(input) {
+  return safeParseWithSchema(AgentSessionPlanRevisionSchema, input);
+}
+function parseAgentSessionDecisionRequest(input) {
+  return parseWithSchema(AgentSessionDecisionRequestSchema, input);
+}
+function safeParseAgentSessionDecisionRequest(input) {
+  return safeParseWithSchema(AgentSessionDecisionRequestSchema, input);
+}
+function parseAgentSessionFormRequest(input) {
+  return parseWithSchema(AgentSessionFormRequestSchema, input);
+}
+function safeParseAgentSessionFormRequest(input) {
+  return safeParseWithSchema(AgentSessionFormRequestSchema, input);
+}
+function parseAgentSessionPlanReviewRequest(input) {
+  return parseWithSchema(AgentSessionPlanReviewRequestSchema, input);
+}
+function safeParseAgentSessionPlanReviewRequest(input) {
+  return safeParseWithSchema(AgentSessionPlanReviewRequestSchema, input);
+}
+function parseAgentSessionRequest(input) {
+  return parseWithSchema(AgentSessionRequestSchema, input);
+}
+function safeParseAgentSessionRequest(input) {
+  return safeParseWithSchema(AgentSessionRequestSchema, input);
+}
+function parseAgentSessionDecisionResponse(input) {
+  return parseWithSchema(AgentSessionDecisionResponseSchema, input);
+}
+function safeParseAgentSessionDecisionResponse(input) {
+  return safeParseWithSchema(AgentSessionDecisionResponseSchema, input);
+}
+function parseAgentSessionFormResponse(input) {
+  return parseWithSchema(AgentSessionFormResponseSchema, input);
+}
+function safeParseAgentSessionFormResponse(input) {
+  return safeParseWithSchema(AgentSessionFormResponseSchema, input);
+}
+function parseAgentSessionPlanReviewResponse(input) {
+  return parseWithSchema(AgentSessionPlanReviewResponseSchema, input);
+}
+function safeParseAgentSessionPlanReviewResponse(input) {
+  return safeParseWithSchema(AgentSessionPlanReviewResponseSchema, input);
+}
+function parseAgentSessionResponse(input) {
+  return parseWithSchema(AgentSessionResponseSchema, input);
+}
+function safeParseAgentSessionResponse(input) {
+  return safeParseWithSchema(AgentSessionResponseSchema, input);
+}
+function issue(path, message) {
+  return { code: "custom", path, message };
+}
+function sessionResponseIssues(request, response) {
+  if (request.kind !== response.kind) {
+    return [issue(["kind"], "Session response kind must match the offered request.")];
+  }
+  const issues = [];
+  const choice = request.choices.find((offered) => offered.choiceId === response.choiceId);
+  if (!choice) {
+    issues.push(issue(["choiceId"], "The response must select a choice offered by this session request."));
+  } else if ("action" in choice && "action" in response && choice.action !== response.action) {
+    issues.push(issue(["action"], "The response action must match the selected offered choice."));
+  }
+  if (request.kind === "form" && response.kind === "form" && response.action === "submit") {
+    issues.push(...elicitationResponseIssues(request.fields, response.answers));
+  }
+  if (request.kind === "plan_review" && response.kind === "plan_review") {
+    if (request.plan.planId !== response.planId) {
+      issues.push(issue(["planId"], "The response must identify the exact offered plan."));
+    }
+    if (request.plan.revision !== response.revision) {
+      issues.push(issue(["revision"], "The response must identify the exact offered plan revision."));
+    }
+  }
+  return issues;
+}
+function safeParseSessionResponseFor(requestSchema, responseSchema, requestInput, responseInput) {
+  const request = safeParseWithSchema(requestSchema, requestInput);
+  if (!request.success) return request;
+  const response = safeParseWithSchema(responseSchema, responseInput);
+  if (!response.success) return response;
+  const issues = sessionResponseIssues(request.data, response.data);
+  return issues.length === 0 ? response : { success: false, issues };
+}
+function safeParseAgentSessionDecisionResponseFor(requestInput, responseInput) {
+  return safeParseSessionResponseFor(AgentSessionDecisionRequestSchema, AgentSessionDecisionResponseSchema, requestInput, responseInput);
+}
+function parseAgentSessionDecisionResponseFor(request, input) {
+  const parsed = safeParseAgentSessionDecisionResponseFor(request, input);
+  if (parsed.success) return parsed.data;
+  throw new AgentProtocolValidationError(parsed.issues);
+}
+function safeParseAgentSessionFormResponseFor(requestInput, responseInput) {
+  return safeParseSessionResponseFor(AgentSessionFormRequestSchema, AgentSessionFormResponseSchema, requestInput, responseInput);
+}
+function parseAgentSessionFormResponseFor(request, input) {
+  const parsed = safeParseAgentSessionFormResponseFor(request, input);
+  if (parsed.success) return parsed.data;
+  throw new AgentProtocolValidationError(parsed.issues);
+}
+function safeParseAgentSessionPlanReviewResponseFor(requestInput, responseInput) {
+  return safeParseSessionResponseFor(AgentSessionPlanReviewRequestSchema, AgentSessionPlanReviewResponseSchema, requestInput, responseInput);
+}
+function parseAgentSessionPlanReviewResponseFor(request, input) {
+  const parsed = safeParseAgentSessionPlanReviewResponseFor(request, input);
+  if (parsed.success) return parsed.data;
+  throw new AgentProtocolValidationError(parsed.issues);
+}
+function safeParseAgentSessionResponseFor(requestInput, responseInput) {
+  return safeParseSessionResponseFor(AgentSessionRequestSchema, AgentSessionResponseSchema, requestInput, responseInput);
+}
+function parseAgentSessionResponseFor(request, input) {
+  const parsed = safeParseAgentSessionResponseFor(request, input);
+  if (parsed.success) return parsed.data;
+  throw new AgentProtocolValidationError(parsed.issues);
+}
+export {
+  parseAgentSessionDecisionChoiceId,
+  parseAgentSessionDecisionRequest,
+  parseAgentSessionDecisionResponse,
+  parseAgentSessionDecisionResponseFor,
+  parseAgentSessionFormChoiceId,
+  parseAgentSessionFormRequest,
+  parseAgentSessionFormResponse,
+  parseAgentSessionFormResponseFor,
+  parseAgentSessionPlanId,
+  parseAgentSessionPlanReviewChoiceId,
+  parseAgentSessionPlanReviewRequest,
+  parseAgentSessionPlanReviewResponse,
+  parseAgentSessionPlanReviewResponseFor,
+  parseAgentSessionPlanRevision,
+  parseAgentSessionRequest,
+  parseAgentSessionResponse,
+  parseAgentSessionResponseFor,
+  safeParseAgentSessionDecisionChoiceId,
+  safeParseAgentSessionDecisionRequest,
+  safeParseAgentSessionDecisionResponse,
+  safeParseAgentSessionDecisionResponseFor,
+  safeParseAgentSessionFormChoiceId,
+  safeParseAgentSessionFormRequest,
+  safeParseAgentSessionFormResponse,
+  safeParseAgentSessionFormResponseFor,
+  safeParseAgentSessionPlanId,
+  safeParseAgentSessionPlanReviewChoiceId,
+  safeParseAgentSessionPlanReviewRequest,
+  safeParseAgentSessionPlanReviewResponse,
+  safeParseAgentSessionPlanReviewResponseFor,
+  safeParseAgentSessionPlanRevision,
+  safeParseAgentSessionRequest,
+  safeParseAgentSessionResponse,
+  safeParseAgentSessionResponseFor
+};