@agen-ai/agent-protocol 0.3.1 → 0.4.1

package/dist/public/index.d.ts

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

package/dist/public/index.js

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

package/dist/public/sessionInteractions.d.ts

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

package/dist/public/sessionInteractions.js

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

package/dist/requests/types.d.ts

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

package/dist/sessionInteractions/index.d.ts

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

package/dist/sessionInteractions/index.js

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

package/dist/sessionInteractions/parsers.d.ts

@@ -0,0 +1,10 @@
+import { type AgentProtocolParseResult } from '../foundation/index.js';
+import type { AgentSessionDecisionChoiceId, AgentSessionDecisionRequest, AgentSessionDecisionResponse } from './types.js';
+export declare function parseAgentSessionDecisionChoiceId(input: unknown): AgentSessionDecisionChoiceId;
+export declare function safeParseAgentSessionDecisionChoiceId(input: unknown): AgentProtocolParseResult<AgentSessionDecisionChoiceId>;
+export declare function parseAgentSessionDecisionRequest(input: unknown): AgentSessionDecisionRequest;
+export declare function safeParseAgentSessionDecisionRequest(input: unknown): AgentProtocolParseResult<AgentSessionDecisionRequest>;
+export declare function parseAgentSessionDecisionResponse(input: unknown): AgentSessionDecisionResponse;
+export declare function safeParseAgentSessionDecisionResponse(input: unknown): AgentProtocolParseResult<AgentSessionDecisionResponse>;
+export declare function parseAgentSessionDecisionResponseFor(request: AgentSessionDecisionRequest, input: unknown): AgentSessionDecisionResponse;
+//# sourceMappingURL=parsers.d.ts.map

package/dist/sessionInteractions/parsers.js

@@ -0,0 +1,48 @@
+import {
+  AgentProtocolValidationError
+} from "../foundation/index.js";
+import { parseWithSchema, safeParseWithSchema } from "../internal/parsers.js";
+import {
+  AgentSessionDecisionChoiceIdSchema,
+  AgentSessionDecisionRequestSchema,
+  AgentSessionDecisionResponseSchema
+} from "../zod/sessionInteractions.js";
+function parseAgentSessionDecisionChoiceId(input) {
+  return parseWithSchema(AgentSessionDecisionChoiceIdSchema, input);
+}
+function safeParseAgentSessionDecisionChoiceId(input) {
+  return safeParseWithSchema(AgentSessionDecisionChoiceIdSchema, input);
+}
+function parseAgentSessionDecisionRequest(input) {
+  return parseWithSchema(AgentSessionDecisionRequestSchema, input);
+}
+function safeParseAgentSessionDecisionRequest(input) {
+  return safeParseWithSchema(AgentSessionDecisionRequestSchema, 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."
+    }]);
+  }
+  return response;
+}
+export {
+  parseAgentSessionDecisionChoiceId,
+  parseAgentSessionDecisionRequest,
+  parseAgentSessionDecisionResponse,
+  parseAgentSessionDecisionResponseFor,
+  safeParseAgentSessionDecisionChoiceId,
+  safeParseAgentSessionDecisionRequest,
+  safeParseAgentSessionDecisionResponse
+};

package/dist/sessionInteractions/types.d.ts

@@ -0,0 +1,50 @@
+import type { AgentIsoDateTime, AgentRequestId, AgentSessionId } from '../foundation/index.js';
+declare const agentSessionDecisionChoiceIdBrand: unique symbol;
+export type AgentSessionDecisionChoiceId = string & {
+    readonly [agentSessionDecisionChoiceIdBrand]: 'AgentSessionDecisionChoiceId';
+};
+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 choiceId: AgentSessionDecisionChoiceId;
+}
+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_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,18 @@
+const AGENT_SESSION_DECISION_REQUEST_BYTES_LIMIT = 65536;
+const AGENT_SESSION_DECISION_RESPONSE_BYTES_LIMIT = 1024;
+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
+};

package/dist/zod/accountQuota.d.ts

@@ -58,6 +58,14 @@ export declare const AgentAccountQuotaMeasurementSchema: z.ZodDiscriminatedUnion
     remainingMinorUnits: z.ZodOptional<z.ZodNumber>;
     usedPercent: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>>], "kind">;
+export declare const AgentAccountQuotaResetSchema: z.ZodReadonly<z.ZodObject<{
+    at: z.ZodType<import("../index.js").AgentIsoDateTime, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIsoDateTime, unknown>>;
+    precision: z.ZodEnum<{
+        reported: "reported";
+        estimated: "estimated";
+    }>;
+    observedAt: z.ZodType<import("../index.js").AgentIsoDateTime, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIsoDateTime, unknown>>;
+}, z.core.$strict>>;
 export declare const AgentAccountQuotaWindowPortableSchema: z.ZodReadonly<z.ZodObject<{
     poolId: z.ZodString;
     windowId: z.ZodString;

package/dist/zod/accountQuota.js

@@ -61,6 +61,11 @@ const AgentAccountQuotaMeasurementSchema = z.discriminatedUnion("kind", [
     usedPercent: NonnegativeQuantitySchema.optional()
   }).strict().readonly()
 ]);
+const AgentAccountQuotaResetSchema = z.object({
+  at: AgentIsoDateTimeSchema,
+  precision: z.enum(["reported", "estimated"]),
+  observedAt: AgentIsoDateTimeSchema
+}).strict().readonly();
 const AgentAccountQuotaWindowPortableSchema = z.object({
   poolId: AgentCanonicalIdValueSchema,
   windowId: AgentCanonicalIdValueSchema,
@@ -71,11 +76,7 @@ const AgentAccountQuotaWindowPortableSchema = z.object({
   measurement: AgentAccountQuotaMeasurementSchema,
   observedAt: AgentIsoDateTimeSchema,
   startsAt: AgentIsoDateTimeSchema.optional(),
-  reset: z.object({
-    at: AgentIsoDateTimeSchema,
-    precision: z.enum(["reported", "estimated"]),
-    observedAt: AgentIsoDateTimeSchema
-  }).strict().readonly().optional()
+  reset: AgentAccountQuotaResetSchema.optional()
 }).strict().readonly();
 function validateWindow(window, context, prefix = []) {
   if (window.applicability.kind === "models" && new Set(window.applicability.modelIds).size !== window.applicability.modelIds.length) {
@@ -148,6 +149,7 @@ export {
   AgentAccountQuotaApplicabilitySchema,
   AgentAccountQuotaMeasurementSchema,
   AgentAccountQuotaPeriodSchema,
+  AgentAccountQuotaResetSchema,
   AgentAccountQuotaSnapshotPortableSchema,
   AgentAccountQuotaSnapshotSchema,
   AgentAccountQuotaWindowPortableSchema,

package/dist/zod/capabilities.d.ts

@@ -1,14 +1,28 @@
 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.ZodArray<z.ZodReadonly<z.ZodObject<{
+    modes: z.ZodReadonly<z.ZodTuple<[z.ZodReadonly<z.ZodObject<{
         persistence: z.ZodEnum<{
             session: "session";
+            workspace: "workspace";
             once: "once";
+        }>;
+        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";
             workspace: "workspace";
+            once: "once";
         }>;
         scopeKinds: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
             exact_action: "exact_action";
@@ -19,7 +33,26 @@ export declare const AgentApprovalCapabilitySchema: z.ZodDiscriminatedUnion<[z.Z
             all_edits: "all_edits";
         }>>>;
     }, z.core.$strict>>>>;
-}, z.core.$strict>>], "kind">;
+    providerManagedRemembrance: z.ZodLiteral<false>;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"supported">;
+    modes: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        persistence: z.ZodEnum<{
+            session: "session";
+            workspace: "workspace";
+            once: "once";
+        }>;
+        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<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<9>;
+    protocolVersion: z.ZodLiteral<11>;
     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,15 +207,47 @@ 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.ZodArray<z.ZodReadonly<z.ZodObject<{
+            modes: z.ZodReadonly<z.ZodTuple<[z.ZodReadonly<z.ZodObject<{
+                persistence: z.ZodEnum<{
+                    session: "session";
+                    workspace: "workspace";
+                    once: "once";
+                }>;
+                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";
+                    workspace: "workspace";
                     once: "once";
+                }>;
+                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<{
+                persistence: z.ZodEnum<{
+                    session: "session";
                     workspace: "workspace";
+                    once: "once";
                 }>;
                 scopeKinds: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
                     exact_action: "exact_action";
@@ -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<{
@@ -234,10 +300,10 @@ export declare const AgentCapabilitiesPortableSchema: z.ZodReadonly<z.ZodObject<
             kind: z.ZodLiteral<"supported">;
             triggers: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
                 unknown: "unknown";
-                automatic: "automatic";
-                manual: "manual";
                 context_limit: "context_limit";
                 recovery: "recovery";
+                automatic: "automatic";
+                manual: "manual";
             }>>>;
             sameSessionContinuation: z.ZodBoolean;
         }, z.core.$strict>>], "kind">;

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

@@ -1,4 +1,5 @@
 import { z } from "zod/v4";
+import { AgentErrorSchema } from "./failures.js";
 import { compareStringsByUnicodeCodePoint } from "../foundation/ordering.js";
 import {
   AGENT_COLLABORATION_OBJECTIVE_MAX_LENGTH,
@@ -13,7 +14,6 @@ import {
 import {
   AgentArtifactIdSchema,
   AgentCollaborationIdSchema,
-  AgentErrorSchema,
   AgentGeneratedResourceIdSchema,
   AgentIsoDateTimeSchema,
   createAgentCanonicalNonBlankStringSchema