@agen-ai/agent-protocol 0.4.0 → 0.4.1

package/dist/zod/foundation.d.ts

@@ -38,6 +38,7 @@ export declare const AgentJsonObjectKeySchema: z.ZodString;
 interface ProtocolInputPreflightOptions {
     readonly maxDepth?: number;
     readonly maxCollectionLength?: number;
+    readonly requireJsonData?: boolean;
 }
 export declare function withAcyclicProtocolInput<Output>(schema: z.ZodType<Output>, options?: ProtocolInputPreflightOptions): z.ZodType<Output>;
 export declare const AgentJsonValuePortableSchema: z.ZodType<AgentJsonValue>;

package/dist/zod/foundation.js

@@ -86,7 +86,10 @@ function passesProtocolInputPreflight(input, options) {
     if (options.maxDepth !== void 0 && current.depth > options.maxDepth) {
       return false;
     }
-    if (current.value === null || typeof current.value !== "object") continue;
+    if (current.value === null || typeof current.value !== "object") {
+      if (options.requireJsonData && current.value !== null && typeof current.value !== "string" && typeof current.value !== "boolean" && !(typeof current.value === "number" && Number.isFinite(current.value))) return false;
+      continue;
+    }
     if (activeObjects.has(current.value)) return false;
     activeObjects.add(current.value);
     pending.push({ operation: "leave", value: current.value });
@@ -103,12 +106,17 @@ function passesProtocolInputPreflight(input, options) {
     }
     let propertyKeys;
     try {
+      if (options.requireJsonData) {
+        const prototype = Object.getPrototypeOf(current.value);
+        if (prototype !== (Array.isArray(current.value) ? Array.prototype : Object.prototype) && prototype !== null) return false;
+      }
       propertyKeys = Reflect.ownKeys(current.value);
     } catch {
       return false;
     }
     let collectionLength = 0;
     for (const propertyKey of propertyKeys) {
+      if (options.requireJsonData && typeof propertyKey !== "string") return false;
       if (typeof propertyKey === "string" && !AGENT_JSON_OBJECT_KEY_PATTERN.test(propertyKey)) {
         return false;
       }
@@ -118,7 +126,12 @@ function passesProtocolInputPreflight(input, options) {
       } catch {
         return false;
       }
-      if (!descriptor?.enumerable) continue;
+      if (options.requireJsonData && (!descriptor || !("value" in descriptor))) return false;
+      if (!descriptor?.enumerable) {
+        if (options.requireJsonData && !(Array.isArray(current.value) && propertyKey === "length")) return false;
+        continue;
+      }
+      if (options.requireJsonData && Array.isArray(current.value) && (typeof propertyKey !== "string" || !/^(?:0|[1-9][0-9]*)$/u.test(propertyKey))) return false;
       if (!("value" in descriptor)) return false;
       collectionLength += 1;
       if (options.maxCollectionLength !== void 0 && collectionLength > options.maxCollectionLength) {

package/dist/zod/index.d.ts

@@ -1,8 +1,9 @@
 export { AgentApprovalOptionIdSchema, AgentArtifactIdSchema, AgentCollaborationIdSchema, AgentConfigurationRevisionIdSchema, AgentInstanceIdSchema, AgentIntegrationIdSchema, AgentIntegrationResourceIdSchema, AgentIntegrationServerIdSchema, AgentIntegrationToolIdSchema, AgentIsoDateTimeSchema, AgentItemIdSchema, AgentJsonValueSchema, AgentManagedContentIdSchema, AgentEnvironmentIdSchema, AgentEffectiveContentIdSchema, AgentCommandIdSchema, AgentExtensionIdSchema, AgentOperationIdSchema, AgentOperationInvocationIdSchema, AgentProviderConversationIdSchema, AgentProviderHistoryAnchorSchema, AgentProviderItemRefSchema, AgentProviderKeySchema, AgentProviderRefsSchema, AgentProviderRequestRefSchema, AgentProviderTurnRefSchema, AgentRequestFieldIdSchema, AgentRequestIdSchema, AgentSessionIdSchema, AgentGeneratedResourceIdSchema, AgentTurnIdSchema, } from './foundation.js';
 export { AgentErrorContextSchema, AgentErrorSchema, AgentFailureCategorySchema, AgentFailureQuotaReferenceSchema, AgentRecoveryHintSchema, } from './failures.js';
 export { AgentSessionBindingSchema, AgentSessionBranchSourceSchema, AgentSessionBranchInputSchema, AgentSessionConfigurationSchema, AgentSessionCreateInputSchema, AgentSessionOpenInputSchema, AgentSessionResumeInputSchema, } from './sessions.js';
+export { AgentSessionDecisionChoiceIdSchema, AgentSessionWorkspaceTargetSchema, AgentSessionDecisionConsequenceSchema, AgentSessionDecisionChoiceSchema, AgentSessionDecisionRequestPortableSchema, AgentSessionDecisionRequestSchema, AgentSessionDecisionResponseSchema, } from './sessionInteractions.js';
 export { AgentBrowserActionDetailsSchema, AgentCollaborationToolCallDetailsSchema, AgentCommandExecutionDetailsSchema, AgentComputerActionDetailsSchema, AgentContentStreamKindSchema, AgentContextCompactionDetailsSchema, AgentDiffSummarySchema, AgentDynamicToolCallDetailsSchema, AgentFileChangeDetailsSchema, AgentFileChangeSchema, AgentImageViewDetailsSchema, AgentItemSnapshotSchema, AgentMcpToolCallDetailsSchema, AgentPlanStepSchema, AgentReviewDetailsSchema, AgentTurnCompletedPayloadSchema, AgentTurnInputContentCompositionSchema, AgentTurnInputContentSchema, AgentTurnInteractionModeSchema, AgentTurnInputPartSchema, AgentContentReferenceInputPartSchema, AgentTurnInterruptionInputSchema, AgentTurnRunInputSchema, AgentWebSearchDetailsSchema, } from './turns.js';
-export { AgentApprovalRequestSchema, AgentApprovalResolutionSchema, AgentElicitationRequestSchema, AgentRequestResolutionSchema, AgentRequestSchema, } from './requests.js';
+export { AgentApprovalConsequenceSchema, AgentApprovalRequestSchema, AgentApprovalResolutionSchema, AgentElicitationRequestSchema, AgentRequestResolutionSchema, AgentRequestSchema, } from './requests.js';
 export { AgentOperationCatalogSchema, AgentOperationDescriptorSchema, AgentOperationFieldSchema, AgentOperationInvocationSchema, AgentOperationResultSchema, } from './operations.js';
 export { AgentManagedContentCatalogSchema, AgentManagedContentDescriptorSchema, } from './managedContent.js';
 export { AgentConfigurationCatalogSchema, AgentConfigurationFieldPortableSchema, AgentConfigurationSelectionInputSchema, AgentConfigurationValueSchema, } from './configuration.js';

package/dist/zod/index.js

@@ -47,6 +47,15 @@ import {
   AgentSessionOpenInputSchema,
   AgentSessionResumeInputSchema
 } from "./sessions.js";
+import {
+  AgentSessionDecisionChoiceIdSchema,
+  AgentSessionWorkspaceTargetSchema,
+  AgentSessionDecisionConsequenceSchema,
+  AgentSessionDecisionChoiceSchema,
+  AgentSessionDecisionRequestPortableSchema,
+  AgentSessionDecisionRequestSchema,
+  AgentSessionDecisionResponseSchema
+} from "./sessionInteractions.js";
 import {
   AgentBrowserActionDetailsSchema,
   AgentCollaborationToolCallDetailsSchema,
@@ -74,6 +83,7 @@ import {
   AgentWebSearchDetailsSchema
 } from "./turns.js";
 import {
+  AgentApprovalConsequenceSchema,
   AgentApprovalRequestSchema,
   AgentApprovalResolutionSchema,
   AgentElicitationRequestSchema,
@@ -123,6 +133,7 @@ export * from "./extensions.js";
 export * from "./environment.js";
 export {
   AgentApprovalCapabilitySchema,
+  AgentApprovalConsequenceSchema,
   AgentApprovalOptionIdSchema,
   AgentApprovalRequestSchema,
   AgentApprovalResolutionSchema,
@@ -206,9 +217,16 @@ export {
   AgentSessionBranchSourceSchema,
   AgentSessionConfigurationSchema,
   AgentSessionCreateInputSchema,
+  AgentSessionDecisionChoiceIdSchema,
+  AgentSessionDecisionChoiceSchema,
+  AgentSessionDecisionConsequenceSchema,
+  AgentSessionDecisionRequestPortableSchema,
+  AgentSessionDecisionRequestSchema,
+  AgentSessionDecisionResponseSchema,
   AgentSessionIdSchema,
   AgentSessionOpenInputSchema,
   AgentSessionResumeInputSchema,
+  AgentSessionWorkspaceTargetSchema,
   AgentTurnCompletedPayloadSchema,
   AgentTurnIdSchema,
   AgentTurnInputContentCompositionSchema,

package/dist/zod/requests.d.ts

@@ -1,5 +1,32 @@
 import { z } from 'zod/v4';
 import type { AgentApprovalRequest, AgentApprovalResolution, AgentElicitationRequest, AgentRequest, AgentRequestResolution } from '../requests/types.js';
+export declare const AgentApprovalConsequenceSchema: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"scoped">;
+    persistence: z.ZodEnum<{
+        session: "session";
+        workspace: "workspace";
+        once: "once";
+    }>;
+    scope: z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodEnum<{
+            exact_action: "exact_action";
+            command_pattern: "command_pattern";
+            domain: "domain";
+            tool: "tool";
+            server: "server";
+            all_edits: "all_edits";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"provider_managed_remembrance">;
+    duration: z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"unknown">;
+    }, z.core.$strict>>;
+    applicability: z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"unknown">;
+    }, z.core.$strict>>;
+    explanation: z.ZodString;
+}, z.core.$strict>>], "kind">;
 export declare const AgentApprovalRequestPortableSchema: z.ZodReadonly<z.ZodObject<{
     requestKind: z.ZodLiteral<"approval">;
     requestId: z.ZodType<import("../index.js").AgentRequestId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestId, unknown>>;
@@ -28,21 +55,33 @@ export declare const AgentApprovalRequestPortableSchema: z.ZodReadonly<z.ZodObje
             approved: "approved";
             denied: "denied";
         }>;
-        persistence: z.ZodEnum<{
-            session: "session";
-            once: "once";
-            workspace: "workspace";
-        }>;
-        scope: z.ZodReadonly<z.ZodObject<{
-            kind: z.ZodEnum<{
-                exact_action: "exact_action";
-                command_pattern: "command_pattern";
-                domain: "domain";
-                tool: "tool";
-                server: "server";
-                all_edits: "all_edits";
+        consequence: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"scoped">;
+            persistence: z.ZodEnum<{
+                session: "session";
+                workspace: "workspace";
+                once: "once";
             }>;
-        }, z.core.$strict>>;
+            scope: z.ZodReadonly<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    exact_action: "exact_action";
+                    command_pattern: "command_pattern";
+                    domain: "domain";
+                    tool: "tool";
+                    server: "server";
+                    all_edits: "all_edits";
+                }>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"provider_managed_remembrance">;
+            duration: z.ZodReadonly<z.ZodObject<{
+                kind: z.ZodLiteral<"unknown">;
+            }, z.core.$strict>>;
+            applicability: z.ZodReadonly<z.ZodObject<{
+                kind: z.ZodLiteral<"unknown">;
+            }, z.core.$strict>>;
+            explanation: z.ZodString;
+        }, z.core.$strict>>], "kind">;
     }, z.core.$strict>>>>;
     expiresAt: z.ZodOptional<z.ZodType<import("../index.js").AgentIsoDateTime, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIsoDateTime, unknown>>>;
 }, z.core.$strict>>;
@@ -149,21 +188,33 @@ export declare const AgentRequestPortableSchema: z.ZodDiscriminatedUnion<[z.ZodR
             approved: "approved";
             denied: "denied";
         }>;
-        persistence: z.ZodEnum<{
-            session: "session";
-            once: "once";
-            workspace: "workspace";
-        }>;
-        scope: z.ZodReadonly<z.ZodObject<{
-            kind: z.ZodEnum<{
-                exact_action: "exact_action";
-                command_pattern: "command_pattern";
-                domain: "domain";
-                tool: "tool";
-                server: "server";
-                all_edits: "all_edits";
+        consequence: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"scoped">;
+            persistence: z.ZodEnum<{
+                session: "session";
+                workspace: "workspace";
+                once: "once";
             }>;
-        }, z.core.$strict>>;
+            scope: z.ZodReadonly<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    exact_action: "exact_action";
+                    command_pattern: "command_pattern";
+                    domain: "domain";
+                    tool: "tool";
+                    server: "server";
+                    all_edits: "all_edits";
+                }>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"provider_managed_remembrance">;
+            duration: z.ZodReadonly<z.ZodObject<{
+                kind: z.ZodLiteral<"unknown">;
+            }, z.core.$strict>>;
+            applicability: z.ZodReadonly<z.ZodObject<{
+                kind: z.ZodLiteral<"unknown">;
+            }, z.core.$strict>>;
+            explanation: z.ZodString;
+        }, z.core.$strict>>], "kind">;
     }, z.core.$strict>>>>;
     expiresAt: z.ZodOptional<z.ZodType<import("../index.js").AgentIsoDateTime, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIsoDateTime, unknown>>>;
 }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{

package/dist/zod/requests.js

@@ -25,13 +25,25 @@ import {
 const AgentApprovalLabelSchema = z.string().min(1).max(AGENT_APPROVAL_LABEL_MAX_LENGTH).regex(/^(?:\S|\S[\s\S]*\S)$/u);
 const AgentApprovalDescriptionSchema = z.string().min(1).max(AGENT_APPROVAL_DESCRIPTION_MAX_LENGTH).regex(/^(?:\S|\S[\s\S]*\S)$/u);
 const AgentApprovalPromptSchema = z.string().min(1).max(AGENT_PROTOCOL_TEXT_MAX_LENGTH).regex(/^(?:\S|\S[\s\S]*\S)$/u);
+const AgentApprovalConsequenceSchema = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("scoped"),
+    persistence: z.enum(AGENT_APPROVAL_PERSISTENCES),
+    scope: z.object({ kind: z.enum(AGENT_APPROVAL_SCOPE_KINDS) }).strict().readonly()
+  }).strict().readonly(),
+  z.object({
+    kind: z.literal("provider_managed_remembrance"),
+    duration: z.object({ kind: z.literal("unknown") }).strict().readonly(),
+    applicability: z.object({ kind: z.literal("unknown") }).strict().readonly(),
+    explanation: AgentApprovalDescriptionSchema
+  }).strict().readonly()
+]);
 const AgentApprovalOptionSchema = z.object({
   optionId: AgentApprovalOptionIdSchema,
   label: AgentApprovalLabelSchema,
   description: AgentApprovalDescriptionSchema.optional(),
   decision: z.enum(["approved", "denied"]),
-  persistence: z.enum(AGENT_APPROVAL_PERSISTENCES),
-  scope: z.object({ kind: z.enum(AGENT_APPROVAL_SCOPE_KINDS) }).strict().readonly()
+  consequence: AgentApprovalConsequenceSchema
 }).strict().readonly();
 const AgentApprovalRequestPortableSchema = z.object({
   requestKind: z.literal("approval"),
@@ -248,6 +260,7 @@ const AgentRequestResolutionSchema = AgentRequestResolutionPortableSchema.superR
   });
 });
 export {
+  AgentApprovalConsequenceSchema,
   AgentApprovalRequestPortableSchema,
   AgentApprovalRequestSchema,
   AgentApprovalResolutionSchema,

package/dist/zod/sessionInteractions.d.ts

@@ -0,0 +1,55 @@
+import { z } from 'zod/v4';
+import { type AgentSessionDecisionChoiceId, type AgentSessionDecisionRequest, type AgentSessionDecisionResponse } from '../sessionInteractions/types.js';
+export declare const AgentSessionDecisionChoiceIdSchema: z.ZodType<AgentSessionDecisionChoiceId>;
+export declare const AgentSessionWorkspaceTargetSchema: z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"workspace">;
+    path: z.ZodString;
+}, z.core.$strict>>;
+export declare const AgentSessionDecisionConsequenceSchema: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"grant">;
+    scope: z.ZodLiteral<"workspace">;
+    persistence: z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"provider_managed">;
+        duration: z.ZodLiteral<"persistent">;
+        mayAffectOtherSessions: z.ZodLiteral<true>;
+    }, z.core.$strict>>;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"decline">;
+    configuration: z.ZodLiteral<"remains_gated">;
+}, z.core.$strict>>], "kind">;
+export declare const AgentSessionDecisionChoiceSchema: z.ZodReadonly<z.ZodObject<{
+    choiceId: z.ZodType<AgentSessionDecisionChoiceId, unknown, z.core.$ZodTypeInternals<AgentSessionDecisionChoiceId, unknown>>;
+    label: z.ZodString;
+    description: z.ZodString;
+    consequence: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"grant">;
+        scope: z.ZodLiteral<"workspace">;
+        persistence: z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"provider_managed">;
+            duration: z.ZodLiteral<"persistent">;
+            mayAffectOtherSessions: z.ZodLiteral<true>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"decline">;
+        configuration: z.ZodLiteral<"remains_gated">;
+    }, z.core.$strict>>], "kind">;
+}, z.core.$strict>>;
+export declare const AgentSessionDecisionRequestPortableSchema: z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"decision">;
+    requestId: z.ZodType<import("../index.js").AgentRequestId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestId, unknown>>;
+    sessionId: z.ZodType<import("../index.js").AgentSessionId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentSessionId, unknown>>;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    target: z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"workspace">;
+        path: z.ZodString;
+    }, z.core.$strict>>;
+    expiresAt: z.ZodType<import("../index.js").AgentIsoDateTime, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIsoDateTime, unknown>>;
+    choices: z.ZodType<readonly [import("../index.js").AgentSessionDecisionChoice, ...import("../index.js").AgentSessionDecisionChoice[]], unknown, z.core.$ZodTypeInternals<readonly [import("../index.js").AgentSessionDecisionChoice, ...import("../index.js").AgentSessionDecisionChoice[]], unknown>>;
+}, z.core.$strict>>;
+export declare const AgentSessionDecisionRequestSchema: z.ZodType<AgentSessionDecisionRequest>;
+export declare const AgentSessionDecisionResponsePortableSchema: z.ZodReadonly<z.ZodObject<{
+    choiceId: z.ZodType<AgentSessionDecisionChoiceId, unknown, z.core.$ZodTypeInternals<AgentSessionDecisionChoiceId, unknown>>;
+}, z.core.$strict>>;
+export declare const AgentSessionDecisionResponseSchema: z.ZodType<AgentSessionDecisionResponse>;
+//# sourceMappingURL=sessionInteractions.d.ts.map

package/dist/zod/sessionInteractions.js

@@ -0,0 +1,114 @@
+import { z } from "zod/v4";
+import {
+  AGENT_PROTOCOL_JSON_DEPTH_LIMIT,
+  agentProtocolSerializedJsonBytes
+} from "../foundation/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_REQUEST_BYTES_LIMIT,
+  AGENT_SESSION_DECISION_RESPONSE_BYTES_LIMIT,
+  AGENT_SESSION_DECISION_TITLE_MAX_LENGTH,
+  AGENT_SESSION_DECISION_WORKSPACE_PATH_BYTES_LIMIT
+} from "../sessionInteractions/types.js";
+import {
+  AgentIsoDateTimeSchema,
+  AgentRequestIdSchema,
+  AgentSessionIdSchema,
+  createAgentCanonicalNonBlankStringSchema,
+  createAgentCanonicalOpaqueStringSchema,
+  withAcyclicProtocolInput
+} from "./foundation.js";
+const encoder = new TextEncoder();
+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);
+}
+const AgentSessionDecisionChoiceIdSchema = createAgentCanonicalOpaqueStringSchema(
+  AGENT_SESSION_DECISION_CHOICE_ID_BYTES_LIMIT,
+  "Session decision choice IDs must be canonical and contain no control characters."
+).refine(
+  (value) => encoder.encode(value).byteLength <= AGENT_SESSION_DECISION_CHOICE_ID_BYTES_LIMIT,
+  "Session decision choice ID exceeds its UTF-8 byte 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 ChoicesSchema = z.array(AgentSessionDecisionChoiceSchema).min(1).max(AGENT_SESSION_DECISION_CHOICES_MAX_LENGTH).readonly();
+const AgentSessionDecisionRequestPortableSchema = z.object({
+  kind: z.literal("decision"),
+  requestId: AgentRequestIdSchema,
+  sessionId: AgentSessionIdSchema,
+  title: SingleLineTextSchema,
+  description: descriptionSchema(AGENT_SESSION_DECISION_DESCRIPTION_MAX_LENGTH).optional(),
+  target: AgentSessionWorkspaceTargetSchema,
+  expiresAt: AgentIsoDateTimeSchema,
+  choices: ChoicesSchema
+}).strict().readonly();
+const inputBounds = {
+  maxDepth: AGENT_PROTOCOL_JSON_DEPTH_LIMIT,
+  maxCollectionLength: AGENT_SESSION_DECISION_CHOICES_MAX_LENGTH,
+  requireJsonData: true
+};
+const AgentSessionDecisionRequestSchema = withAcyclicProtocolInput(AgentSessionDecisionRequestPortableSchema, inputBounds).superRefine((request, context) => {
+  if (agentProtocolSerializedJsonBytes(request) > AGENT_SESSION_DECISION_REQUEST_BYTES_LIMIT) {
+    context.addIssue({ code: "custom", message: "Session decision exceeds its serialized UTF-8 byte limit." });
+  }
+  const seen = /* @__PURE__ */ new Set();
+  request.choices.forEach((choice, index) => {
+    if (seen.has(choice.choiceId)) {
+      context.addIssue({
+        code: "custom",
+        path: ["choices", index, "choiceId"],
+        message: "Session decision choices must have unique IDs."
+      });
+    }
+    seen.add(choice.choiceId);
+  });
+});
+const AgentSessionDecisionResponsePortableSchema = z.object({
+  choiceId: AgentSessionDecisionChoiceIdSchema
+}).strict().readonly();
+const AgentSessionDecisionResponseSchema = withAcyclicProtocolInput(AgentSessionDecisionResponsePortableSchema, inputBounds).refine(
+  (response) => agentProtocolSerializedJsonBytes(response) <= AGENT_SESSION_DECISION_RESPONSE_BYTES_LIMIT,
+  "Session decision response exceeds its serialized UTF-8 byte limit."
+);
+export {
+  AgentSessionDecisionChoiceIdSchema,
+  AgentSessionDecisionChoiceSchema,
+  AgentSessionDecisionConsequenceSchema,
+  AgentSessionDecisionRequestPortableSchema,
+  AgentSessionDecisionRequestSchema,
+  AgentSessionDecisionResponsePortableSchema,
+  AgentSessionDecisionResponseSchema,
+  AgentSessionWorkspaceTargetSchema
+};

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, 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,24 @@ 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, 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 AgentEffectiveContentCatalogSchema>, AgentEffectiveContentCatalog>>,
     Assert<Extends<AgentEffectiveContentCatalog, z.output<typeof AgentEffectiveContentCatalogSchema>>>,
     Assert<Extends<z.output<typeof AgentEffectiveContentDescriptorSchema>, AgentEffectiveContentDescriptor>>,
@@ -94,6 +106,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.1",
   "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.1"
   },
   "devDependencies": {
     "ajv": "8.17.1",