@agen-ai/agent-protocol 0.3.1 → 0.4.1

package/dist/zod/operations.d.ts

@@ -163,16 +163,16 @@ declare const AgentOperationDescriptorPortableSchema: z.ZodReadonly<z.ZodObject<
         }>;
     }, z.core.$strict>>], "fieldKind">>>;
     confirmation: z.ZodEnum<{
-        required: "required";
         none: "none";
+        required: "required";
     }>;
     idempotency: z.ZodEnum<{
         required: "required";
         not_required: "not_required";
     }>;
     resultKind: z.ZodEnum<{
-        resource: "resource";
         none: "none";
+        resource: "resource";
         canonical_output: "canonical_output";
         artifact: "artifact";
     }>;
@@ -277,16 +277,16 @@ export declare const AgentOperationCatalogPortableSchema: z.ZodReadonly<z.ZodObj
             }>;
         }, z.core.$strict>>], "fieldKind">>>;
         confirmation: z.ZodEnum<{
-            required: "required";
             none: "none";
+            required: "required";
         }>;
         idempotency: z.ZodEnum<{
             required: "required";
             not_required: "not_required";
         }>;
         resultKind: z.ZodEnum<{
-            resource: "resource";
             none: "none";
+            resource: "resource";
             canonical_output: "canonical_output";
             artifact: "artifact";
         }>;

package/dist/zod/operations.js

@@ -1,4 +1,5 @@
 import { z } from "zod/v4";
+import { AgentErrorSchema } from "./failures.js";
 import { compareStringsByUnicodeCodePoint } from "../foundation/ordering.js";
 import {
   AGENT_OPERATION_CATALOG_MAX_LENGTH,
@@ -19,7 +20,6 @@ import {
 import {
   AgentArtifactIdSchema,
   AgentCanonicalIdValueSchema,
-  AgentErrorSchema,
   AgentGeneratedResourceIdSchema,
   AgentOperationIdSchema,
   AgentOperationInvocationIdSchema,

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/resources.js

@@ -1,4 +1,5 @@
 import { z } from "zod/v4";
+import { AgentErrorSchema } from "./failures.js";
 import { AGENT_ARTIFACT_BYTE_SIZE_MAX } from "../artifacts/types.js";
 import {
   AGENT_GENERATED_RESOURCE_DISPLAY_NAME_MAX_LENGTH,
@@ -9,7 +10,6 @@ import {
 import {
   AgentArtifactIdSchema,
   AgentCollaborationIdSchema,
-  AgentErrorSchema,
   AgentGeneratedResourceIdSchema,
   AgentIsoDateTimeSchema,
   AgentOperationInvocationIdSchema,

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/turns.js

@@ -1,4 +1,5 @@
 import { z } from "zod/v4";
+import { AgentErrorSchema } from "./failures.js";
 import {
   AGENT_PROTOCOL_COLLECTION_MAX_LENGTH,
   AGENT_PROTOCOL_SUMMARY_MAX_LENGTH,
@@ -21,7 +22,6 @@ import {
 } from "../turns/types.js";
 import {
   AgentCanonicalIdValueSchema,
-  AgentErrorSchema,
   AgentEnvironmentIdSchema,
   AgentEffectiveContentIdSchema,
   AgentIsoDateTimeSchema,

package/dist/zod/typeEquality.generated.d.ts

@@ -1,7 +1,7 @@
 import type { z } from 'zod/v4';
-import type { AgentAccountQuotaSnapshot, AgentAccountQuotaWindow } from '../accountQuota/types.js';
+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';
@@ -9,17 +9,19 @@ import type { AgentEffectiveContentCatalog, AgentEffectiveContentDescriptor } fr
 import type { AgentEnvironmentCapability, AgentEnvironmentInvalidation, AgentEnvironmentSnapshot } from '../environment/types.js';
 import type { AgentEvent } from '../events/types.js';
 import type { AgentExtensionCatalog, AgentExtensionDescriptor } from '../extensions/types.js';
-import type { AgentError, AgentJsonValue, AgentProviderRefs } from '../foundation/types.js';
+import type { AgentError, AgentErrorContext, AgentFailureCategory, AgentFailureQuotaReference, AgentRecoveryHint } from '../failures/types.js';
+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 { AgentAccountQuotaSnapshotSchema, AgentAccountQuotaWindowSchema } from './accountQuota.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';
@@ -27,17 +29,29 @@ import { AgentEffectiveContentCatalogSchema, AgentEffectiveContentDescriptorSche
 import { AgentEnvironmentCapabilitySchema, AgentEnvironmentInvalidationSchema, AgentEnvironmentSnapshotSchema } from './environment.js';
 import { AgentEventSchema } from './events.js';
 import { AgentExtensionCatalogSchema, AgentExtensionDescriptorSchema } from './extensions.js';
-import { AgentErrorSchema, AgentJsonValueSchema, AgentProviderRefsSchema } from './foundation.js';
+import { AgentErrorContextSchema, AgentErrorSchema, AgentFailureCategorySchema, AgentFailureQuotaReferenceSchema, AgentRecoveryHintSchema } from './failures.js';
+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>>,
@@ -62,12 +76,22 @@ export type AgentProtocolSchemaTypeAssertions = readonly [
     Assert<Extends<AgentAccountQuotaSnapshot, z.output<typeof AgentAccountQuotaSnapshotSchema>>>,
     Assert<Extends<z.output<typeof AgentAccountQuotaWindowSchema>, AgentAccountQuotaWindow>>,
     Assert<Extends<AgentAccountQuotaWindow, z.output<typeof AgentAccountQuotaWindowSchema>>>,
+    Assert<Extends<z.output<typeof AgentAccountQuotaResetSchema>, AgentAccountQuotaReset>>,
+    Assert<Extends<AgentAccountQuotaReset, z.output<typeof AgentAccountQuotaResetSchema>>>,
     Assert<Extends<z.output<typeof AgentJsonValueSchema>, AgentJsonValue>>,
     Assert<Extends<AgentJsonValue, z.output<typeof AgentJsonValueSchema>>>,
     Assert<Extends<z.output<typeof AgentProviderRefsSchema>, AgentProviderRefs>>,
     Assert<Extends<AgentProviderRefs, z.output<typeof AgentProviderRefsSchema>>>,
     Assert<Extends<z.output<typeof AgentErrorSchema>, AgentError>>,
     Assert<Extends<AgentError, z.output<typeof AgentErrorSchema>>>,
+    Assert<Extends<z.output<typeof AgentErrorContextSchema>, AgentErrorContext>>,
+    Assert<Extends<AgentErrorContext, z.output<typeof AgentErrorContextSchema>>>,
+    Assert<Extends<z.output<typeof AgentFailureCategorySchema>, AgentFailureCategory>>,
+    Assert<Extends<AgentFailureCategory, z.output<typeof AgentFailureCategorySchema>>>,
+    Assert<Extends<z.output<typeof AgentFailureQuotaReferenceSchema>, AgentFailureQuotaReference>>,
+    Assert<Extends<AgentFailureQuotaReference, z.output<typeof AgentFailureQuotaReferenceSchema>>>,
+    Assert<Extends<z.output<typeof AgentRecoveryHintSchema>, AgentRecoveryHint>>,
+    Assert<Extends<AgentRecoveryHint, z.output<typeof AgentRecoveryHintSchema>>>,
     Assert<Extends<z.output<typeof AgentSessionBindingSchema>, AgentSessionBinding>>,
     Assert<Extends<AgentSessionBinding, z.output<typeof AgentSessionBindingSchema>>>,
     Assert<Extends<z.output<typeof AgentSessionConfigurationSchema>, AgentSessionConfiguration>>,
@@ -82,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.3.1",
+  "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.3.1"
+    "@agen-ai/validation": "^0.4.1"
   },
   "devDependencies": {
     "ajv": "8.17.1",