@agen-ai/agent-protocol 0.4.0 → 0.4.2

package/dist/sessionInteractions/types.d.ts

@@ -0,0 +1,162 @@
+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;
+}
+export type AgentSessionDecisionConsequence = Readonly<{
+    kind: 'grant';
+    scope: 'workspace';
+    persistence: Readonly<{
+        kind: 'provider_managed';
+        duration: 'persistent';
+        mayAffectOtherSessions: true;
+    }>;
+}> | Readonly<{
+    kind: 'decline';
+    configuration: 'remains_gated';
+}>;
+export interface AgentSessionDecisionChoice {
+    readonly choiceId: AgentSessionDecisionChoiceId;
+    readonly label: string;
+    readonly description: string;
+    readonly consequence: AgentSessionDecisionConsequence;
+}
+export interface AgentSessionDecisionRequest {
+    readonly kind: 'decision';
+    readonly requestId: AgentRequestId;
+    readonly sessionId: AgentSessionId;
+    readonly title: string;
+    readonly description?: string;
+    readonly target: AgentSessionWorkspaceTarget;
+    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;
+export declare const AGENT_SESSION_DECISION_DESCRIPTION_MAX_LENGTH = 4000;
+export declare const AGENT_SESSION_DECISION_CHOICE_DESCRIPTION_MAX_LENGTH = 1000;
+export declare const AGENT_SESSION_DECISION_WORKSPACE_PATH_BYTES_LIMIT = 4096;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/sessionInteractions/types.js

@@ -0,0 +1,34 @@
+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;
+const AGENT_SESSION_DECISION_DESCRIPTION_MAX_LENGTH = 4e3;
+const AGENT_SESSION_DECISION_CHOICE_DESCRIPTION_MAX_LENGTH = 1e3;
+const AGENT_SESSION_DECISION_WORKSPACE_PATH_BYTES_LIMIT = 4096;
+export {
+  AGENT_SESSION_DECISION_CHOICES_MAX_LENGTH,
+  AGENT_SESSION_DECISION_CHOICE_DESCRIPTION_MAX_LENGTH,
+  AGENT_SESSION_DECISION_CHOICE_ID_BYTES_LIMIT,
+  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,
+  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
+};

package/dist/zod/capabilities.d.ts

@@ -1,7 +1,39 @@
 import { z } from 'zod/v4';
 import { type AgentCapabilities } from '../capabilities/types.js';
-export declare const AgentApprovalCapabilitySchema: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+export declare const AgentApprovalCapabilitySchema: z.ZodUnion<readonly [z.ZodReadonly<z.ZodObject<{
     kind: z.ZodLiteral<"unsupported">;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"supported">;
+    modes: z.ZodReadonly<z.ZodTuple<[z.ZodReadonly<z.ZodObject<{
+        persistence: z.ZodEnum<{
+            session: "session";
+            once: "once";
+            workspace: "workspace";
+        }>;
+        scopeKinds: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+            exact_action: "exact_action";
+            command_pattern: "command_pattern";
+            domain: "domain";
+            tool: "tool";
+            server: "server";
+            all_edits: "all_edits";
+        }>>>;
+    }, z.core.$strict>>], z.ZodReadonly<z.ZodObject<{
+        persistence: z.ZodEnum<{
+            session: "session";
+            once: "once";
+            workspace: "workspace";
+        }>;
+        scopeKinds: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+            exact_action: "exact_action";
+            command_pattern: "command_pattern";
+            domain: "domain";
+            tool: "tool";
+            server: "server";
+            all_edits: "all_edits";
+        }>>>;
+    }, z.core.$strict>>>>;
+    providerManagedRemembrance: z.ZodLiteral<false>;
 }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
     kind: z.ZodLiteral<"supported">;
     modes: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
@@ -19,7 +51,8 @@ export declare const AgentApprovalCapabilitySchema: z.ZodDiscriminatedUnion<[z.Z
             all_edits: "all_edits";
         }>>>;
     }, z.core.$strict>>>>;
-}, z.core.$strict>>], "kind">;
+    providerManagedRemembrance: z.ZodLiteral<true>;
+}, z.core.$strict>>]>;
 export declare const AgentImageInputCapabilitySchema: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
     kind: z.ZodLiteral<"unsupported">;
 }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
@@ -106,7 +139,7 @@ export declare const AgentOperationInputCapabilitySchema: z.ZodReadonly<z.ZodObj
     }, z.core.$strict>>], "kind">;
 }, z.core.$strict>>;
 export declare const AgentCapabilitiesPortableSchema: z.ZodReadonly<z.ZodObject<{
-    protocolVersion: z.ZodLiteral<10>;
+    protocolVersion: z.ZodLiteral<12>;
     providerKey: z.ZodType<import("../index.js").AgentProviderKey, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentProviderKey, unknown>>;
     sessions: z.ZodReadonly<z.ZodObject<{
         create: z.ZodLiteral<true>;
@@ -174,8 +207,40 @@ export declare const AgentCapabilitiesPortableSchema: z.ZodReadonly<z.ZodObject<
         }, z.core.$strict>>], "kind">;
     }, z.core.$strict>>;
     requests: z.ZodReadonly<z.ZodObject<{
-        approval: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        approval: z.ZodUnion<readonly [z.ZodReadonly<z.ZodObject<{
             kind: z.ZodLiteral<"unsupported">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"supported">;
+            modes: z.ZodReadonly<z.ZodTuple<[z.ZodReadonly<z.ZodObject<{
+                persistence: z.ZodEnum<{
+                    session: "session";
+                    once: "once";
+                    workspace: "workspace";
+                }>;
+                scopeKinds: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                    exact_action: "exact_action";
+                    command_pattern: "command_pattern";
+                    domain: "domain";
+                    tool: "tool";
+                    server: "server";
+                    all_edits: "all_edits";
+                }>>>;
+            }, z.core.$strict>>], z.ZodReadonly<z.ZodObject<{
+                persistence: z.ZodEnum<{
+                    session: "session";
+                    once: "once";
+                    workspace: "workspace";
+                }>;
+                scopeKinds: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                    exact_action: "exact_action";
+                    command_pattern: "command_pattern";
+                    domain: "domain";
+                    tool: "tool";
+                    server: "server";
+                    all_edits: "all_edits";
+                }>>>;
+            }, z.core.$strict>>>>;
+            providerManagedRemembrance: z.ZodLiteral<false>;
         }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
             kind: z.ZodLiteral<"supported">;
             modes: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
@@ -193,7 +258,8 @@ export declare const AgentCapabilitiesPortableSchema: z.ZodReadonly<z.ZodObject<
                     all_edits: "all_edits";
                 }>>>;
             }, z.core.$strict>>>>;
-        }, z.core.$strict>>], "kind">;
+            providerManagedRemembrance: z.ZodLiteral<true>;
+        }, z.core.$strict>>]>;
         elicitation: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
             kind: z.ZodLiteral<"unsupported">;
         }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
@@ -296,9 +362,9 @@ export declare const AgentCapabilitiesPortableSchema: z.ZodReadonly<z.ZodObject<
         }>;
         artifactKinds: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
             file: "file";
-            image: "image";
             plan: "plan";
             other: "other";
+            image: "image";
             report: "report";
             diff: "diff";
             log: "log";

package/dist/zod/capabilities.js

@@ -80,39 +80,41 @@ const PositiveSafeIntegerSchema = z.number().int().positive().max(Number.MAX_SAF
 function boundedPositiveSafeInteger(maximum) {
   return z.number().int().positive().max(maximum);
 }
-const AgentApprovalCapabilitySchema = z.discriminatedUnion("kind", [
+const AgentApprovalCapabilityModeSchema = z.object({
+  persistence: z.enum(AGENT_APPROVAL_PERSISTENCES),
+  scopeKinds: z.array(z.enum(AGENT_APPROVAL_SCOPE_KINDS)).min(1).max(AGENT_APPROVAL_SCOPE_KINDS.length).meta({ uniqueItems: true }).readonly()
+}).strict().readonly();
+const AgentApprovalCapabilitySchema = z.union([
   z.object({ kind: z.literal("unsupported") }).strict().readonly(),
   z.object({
     kind: z.literal("supported"),
-    modes: z.array(
-      z.object({
-        persistence: z.enum(AGENT_APPROVAL_PERSISTENCES),
-        scopeKinds: z.array(z.enum(AGENT_APPROVAL_SCOPE_KINDS)).min(1).max(AGENT_APPROVAL_SCOPE_KINDS.length).meta({ uniqueItems: true }).readonly()
-      }).strict().readonly()
-    ).min(1).max(AGENT_APPROVAL_PERSISTENCES.length).readonly()
-  }).strict().superRefine((capability, context) => {
-    addCanonicalListIssues(
-      {
-        values: capability.modes.map((mode) => mode.persistence),
-        canonicalOrder: AGENT_APPROVAL_PERSISTENCES,
-        path: ["modes"],
-        label: "Approval persistence modes"
-      },
-      context
-    );
-    capability.modes.forEach((mode, index) => {
-      addCanonicalListIssues(
-        {
-          values: mode.scopeKinds,
-          canonicalOrder: AGENT_APPROVAL_SCOPE_KINDS,
-          path: ["modes", index, "scopeKinds"],
-          label: "Approval scope kinds"
-        },
-        context
-      );
-    });
-  }).readonly()
-]);
+    modes: z.tuple([AgentApprovalCapabilityModeSchema]).rest(AgentApprovalCapabilityModeSchema).refine((modes) => modes.length <= AGENT_APPROVAL_PERSISTENCES.length, {
+      message: "Approval modes must contain at most three precise persistences."
+    }).meta({ minItems: 1, maxItems: AGENT_APPROVAL_PERSISTENCES.length }).readonly(),
+    providerManagedRemembrance: z.literal(false)
+  }).strict().readonly(),
+  z.object({
+    kind: z.literal("supported"),
+    modes: z.array(AgentApprovalCapabilityModeSchema).max(AGENT_APPROVAL_PERSISTENCES.length).readonly(),
+    providerManagedRemembrance: z.literal(true)
+  }).strict().readonly()
+]).superRefine((capability, context) => {
+  if (capability.kind === "unsupported") return;
+  addCanonicalListIssues({
+    values: capability.modes.map((mode) => mode.persistence),
+    canonicalOrder: AGENT_APPROVAL_PERSISTENCES,
+    path: ["modes"],
+    label: "Approval persistence modes"
+  }, context);
+  capability.modes.forEach((mode, index) => {
+    addCanonicalListIssues({
+      values: mode.scopeKinds,
+      canonicalOrder: AGENT_APPROVAL_SCOPE_KINDS,
+      path: ["modes", index, "scopeKinds"],
+      label: "Approval scope kinds"
+    }, context);
+  });
+});
 const AgentContextUsageCapabilitySchema = z.discriminatedUnion("kind", [
   z.object({ kind: z.literal("unsupported") }).strict().readonly(),
   z.object({

package/dist/zod/collaboration.d.ts

@@ -12,9 +12,9 @@ export declare const AgentCollaborationNodePortableSchema: z.ZodReadonly<z.ZodOb
     }>;
     title: z.ZodString;
     status: z.ZodEnum<{
+        canceled: "canceled";
         completed: "completed";
         failed: "failed";
-        canceled: "canceled";
         running: "running";
         starting: "starting";
         queued: "queued";
@@ -40,11 +40,11 @@ export declare const AgentCollaborationNodePortableSchema: z.ZodReadonly<z.ZodOb
     }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
         kind: z.ZodLiteral<"canceled">;
         reason: z.ZodEnum<{
+            other: "other";
             user_requested: "user_requested";
             timeout: "timeout";
             shutdown: "shutdown";
             superseded: "superseded";
-            other: "other";
         }>;
     }, z.core.$strict>>], "kind">>;
     createdAt: z.ZodType<import("../index.js").AgentIsoDateTime, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIsoDateTime, unknown>>;