@agen-ai/agent-protocol 0.4.1 → 0.4.2

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/sessionInteractions/parsers.d.ts

@@ -1,10 +1,37 @@
 import { type AgentProtocolParseResult } from '../foundation/index.js';
-import type { AgentSessionDecisionChoiceId, AgentSessionDecisionRequest, AgentSessionDecisionResponse } from './types.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

@@ -2,10 +2,21 @@ 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,
-  AgentSessionDecisionResponseSchema
+  AgentSessionFormRequestSchema,
+  AgentSessionPlanReviewRequestSchema,
+  AgentSessionRequestSchema,
+  AgentSessionDecisionResponseSchema,
+  AgentSessionFormResponseSchema,
+  AgentSessionPlanReviewResponseSchema,
+  AgentSessionResponseSchema
 } from "../zod/sessionInteractions.js";
 function parseAgentSessionDecisionChoiceId(input) {
   return parseWithSchema(AgentSessionDecisionChoiceIdSchema, input);
@@ -13,36 +24,178 @@ function parseAgentSessionDecisionChoiceId(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 parseAgentSessionDecisionResponseFor(request, input) {
-  const parsedRequest = parseAgentSessionDecisionRequest(request);
-  const response = parseAgentSessionDecisionResponse(input);
-  if (!parsedRequest.choices.some((choice) => choice.choiceId === response.choiceId)) {
-    throw new AgentProtocolValidationError([{
-      code: "custom",
-      path: ["choiceId"],
-      message: "The response must select a choice offered by this session decision."
-    }]);
+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."));
   }
-  return response;
+  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
+  safeParseAgentSessionDecisionResponse,
+  safeParseAgentSessionDecisionResponseFor,
+  safeParseAgentSessionFormChoiceId,
+  safeParseAgentSessionFormRequest,
+  safeParseAgentSessionFormResponse,
+  safeParseAgentSessionFormResponseFor,
+  safeParseAgentSessionPlanId,
+  safeParseAgentSessionPlanReviewChoiceId,
+  safeParseAgentSessionPlanReviewRequest,
+  safeParseAgentSessionPlanReviewResponse,
+  safeParseAgentSessionPlanReviewResponseFor,
+  safeParseAgentSessionPlanRevision,
+  safeParseAgentSessionRequest,
+  safeParseAgentSessionResponse,
+  safeParseAgentSessionResponseFor
 };

package/dist/sessionInteractions/types.d.ts

@@ -1,8 +1,26 @@
 import type { AgentIsoDateTime, AgentRequestId, AgentSessionId } from '../foundation/index.js';
+import type { AgentElicitationAnswer, AgentElicitationField } from '../requests/types.js';
 declare const agentSessionDecisionChoiceIdBrand: unique symbol;
+declare const agentSessionFormChoiceIdBrand: unique symbol;
+declare const agentSessionPlanReviewChoiceIdBrand: unique symbol;
+declare const agentSessionPlanIdBrand: unique symbol;
+declare const agentSessionPlanRevisionBrand: unique symbol;
+export type AgentSessionRequestKind = 'decision' | 'form' | 'plan_review';
 export type AgentSessionDecisionChoiceId = string & {
     readonly [agentSessionDecisionChoiceIdBrand]: 'AgentSessionDecisionChoiceId';
 };
+export type AgentSessionFormChoiceId = string & {
+    readonly [agentSessionFormChoiceIdBrand]: 'AgentSessionFormChoiceId';
+};
+export type AgentSessionPlanReviewChoiceId = string & {
+    readonly [agentSessionPlanReviewChoiceIdBrand]: 'AgentSessionPlanReviewChoiceId';
+};
+export type AgentSessionPlanId = string & {
+    readonly [agentSessionPlanIdBrand]: 'AgentSessionPlanId';
+};
+export type AgentSessionPlanRevision = string & {
+    readonly [agentSessionPlanRevisionBrand]: 'AgentSessionPlanRevision';
+};
 export interface AgentSessionWorkspaceTarget {
     readonly kind: 'workspace';
     readonly path: string;
@@ -32,14 +50,108 @@ export interface AgentSessionDecisionRequest {
     readonly title: string;
     readonly description?: string;
     readonly target: AgentSessionWorkspaceTarget;
-    readonly expiresAt: AgentIsoDateTime;
+    readonly expiresAt?: AgentIsoDateTime;
     readonly choices: readonly [AgentSessionDecisionChoice, ...AgentSessionDecisionChoice[]];
 }
 export interface AgentSessionDecisionResponse {
+    readonly kind: 'decision';
     readonly choiceId: AgentSessionDecisionChoiceId;
 }
+export type AgentSessionFormChoice = Readonly<{
+    choiceId: AgentSessionFormChoiceId;
+    action: 'submit';
+    label: string;
+    description?: string;
+}> | Readonly<{
+    choiceId: AgentSessionFormChoiceId;
+    action: 'cancel';
+    label: string;
+    description?: string;
+}>;
+export interface AgentSessionFormRequest {
+    readonly kind: 'form';
+    readonly requestId: AgentRequestId;
+    readonly sessionId: AgentSessionId;
+    readonly title: string;
+    readonly description?: string;
+    readonly fields: readonly [AgentElicitationField, ...AgentElicitationField[]];
+    readonly choices: readonly [AgentSessionFormChoice, ...AgentSessionFormChoice[]];
+    readonly expiresAt?: AgentIsoDateTime;
+}
+export type AgentSessionPlanReviewAction = 'approve' | 'revise' | 'abandon';
+export interface AgentSessionPlanSnapshot {
+    readonly planId: AgentSessionPlanId;
+    readonly revision: AgentSessionPlanRevision;
+    readonly title: string;
+    readonly content: Readonly<{
+        kind: 'text';
+        format: 'plain_text' | 'markdown';
+        text: string;
+    }>;
+}
+export interface AgentSessionPlanReviewChoice {
+    readonly choiceId: AgentSessionPlanReviewChoiceId;
+    readonly action: AgentSessionPlanReviewAction;
+    readonly label: string;
+    readonly description?: string;
+}
+export interface AgentSessionPlanReviewRequest {
+    readonly kind: 'plan_review';
+    readonly requestId: AgentRequestId;
+    readonly sessionId: AgentSessionId;
+    readonly title: string;
+    readonly description?: string;
+    readonly plan: AgentSessionPlanSnapshot;
+    readonly choices: readonly [AgentSessionPlanReviewChoice, ...AgentSessionPlanReviewChoice[]];
+    readonly expiresAt?: AgentIsoDateTime;
+}
+export type AgentSessionRequest = AgentSessionDecisionRequest | AgentSessionFormRequest | AgentSessionPlanReviewRequest;
+export type AgentSessionFormResponse = Readonly<{
+    kind: 'form';
+    action: 'submit';
+    choiceId: AgentSessionFormChoiceId;
+    answers: readonly AgentElicitationAnswer[];
+}> | Readonly<{
+    kind: 'form';
+    action: 'cancel';
+    choiceId: AgentSessionFormChoiceId;
+}>;
+export type AgentSessionPlanReviewResponse = Readonly<{
+    kind: 'plan_review';
+    action: 'approve' | 'abandon';
+    choiceId: AgentSessionPlanReviewChoiceId;
+    planId: AgentSessionPlanId;
+    revision: AgentSessionPlanRevision;
+}> | Readonly<{
+    kind: 'plan_review';
+    action: 'revise';
+    choiceId: AgentSessionPlanReviewChoiceId;
+    planId: AgentSessionPlanId;
+    revision: AgentSessionPlanRevision;
+    feedback: string;
+}>;
+export type AgentSessionResponse = AgentSessionDecisionResponse | AgentSessionFormResponse | AgentSessionPlanReviewResponse;
+export type AgentSessionAcceptedResponse = AgentSessionDecisionResponse | Readonly<{
+    kind: 'form';
+    action: 'submit' | 'cancel';
+    choiceId: AgentSessionFormChoiceId;
+}> | Readonly<{
+    kind: 'plan_review';
+    action: AgentSessionPlanReviewAction;
+    choiceId: AgentSessionPlanReviewChoiceId;
+    planId: AgentSessionPlanId;
+    revision: AgentSessionPlanRevision;
+}>;
+export declare const AGENT_SESSION_REQUEST_BYTES_LIMIT = 65536;
 export declare const AGENT_SESSION_DECISION_REQUEST_BYTES_LIMIT = 65536;
 export declare const AGENT_SESSION_DECISION_RESPONSE_BYTES_LIMIT = 1024;
+export declare const AGENT_SESSION_FORM_RESPONSE_BYTES_LIMIT = 65536;
+export declare const AGENT_SESSION_PLAN_REVIEW_RESPONSE_BYTES_LIMIT = 65536;
+export declare const AGENT_SESSION_PLAN_TEXT_BYTES_LIMIT = 49152;
+export declare const AGENT_SESSION_PLAN_ID_BYTES_LIMIT = 128;
+export declare const AGENT_SESSION_PLAN_REVISION_BYTES_LIMIT = 128;
+export declare const AGENT_SESSION_PLAN_REVIEW_FEEDBACK_MAX_LENGTH = 4000;
+export declare const AGENT_SESSION_PLAN_REVIEW_FEEDBACK_BYTES_LIMIT = 16384;
 export declare const AGENT_SESSION_DECISION_CHOICES_MAX_LENGTH = 16;
 export declare const AGENT_SESSION_DECISION_CHOICE_ID_BYTES_LIMIT = 128;
 export declare const AGENT_SESSION_DECISION_TITLE_MAX_LENGTH = 120;

package/dist/sessionInteractions/types.js

@@ -1,5 +1,13 @@
-const AGENT_SESSION_DECISION_REQUEST_BYTES_LIMIT = 65536;
+const AGENT_SESSION_REQUEST_BYTES_LIMIT = 65536;
+const AGENT_SESSION_DECISION_REQUEST_BYTES_LIMIT = AGENT_SESSION_REQUEST_BYTES_LIMIT;
 const AGENT_SESSION_DECISION_RESPONSE_BYTES_LIMIT = 1024;
+const AGENT_SESSION_FORM_RESPONSE_BYTES_LIMIT = 65536;
+const AGENT_SESSION_PLAN_REVIEW_RESPONSE_BYTES_LIMIT = 65536;
+const AGENT_SESSION_PLAN_TEXT_BYTES_LIMIT = 49152;
+const AGENT_SESSION_PLAN_ID_BYTES_LIMIT = 128;
+const AGENT_SESSION_PLAN_REVISION_BYTES_LIMIT = 128;
+const AGENT_SESSION_PLAN_REVIEW_FEEDBACK_MAX_LENGTH = 4e3;
+const AGENT_SESSION_PLAN_REVIEW_FEEDBACK_BYTES_LIMIT = 16384;
 const AGENT_SESSION_DECISION_CHOICES_MAX_LENGTH = 16;
 const AGENT_SESSION_DECISION_CHOICE_ID_BYTES_LIMIT = 128;
 const AGENT_SESSION_DECISION_TITLE_MAX_LENGTH = 120;
@@ -14,5 +22,13 @@ export {
   AGENT_SESSION_DECISION_REQUEST_BYTES_LIMIT,
   AGENT_SESSION_DECISION_RESPONSE_BYTES_LIMIT,
   AGENT_SESSION_DECISION_TITLE_MAX_LENGTH,
-  AGENT_SESSION_DECISION_WORKSPACE_PATH_BYTES_LIMIT
+  AGENT_SESSION_DECISION_WORKSPACE_PATH_BYTES_LIMIT,
+  AGENT_SESSION_FORM_RESPONSE_BYTES_LIMIT,
+  AGENT_SESSION_PLAN_ID_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_REVISION_BYTES_LIMIT,
+  AGENT_SESSION_PLAN_TEXT_BYTES_LIMIT,
+  AGENT_SESSION_REQUEST_BYTES_LIMIT
 };