@tangle-network/agent-interface 5.7.0 → 5.8.0

package/dist/harness-capabilities.js

@@ -1,40 +1,49 @@
 import { REASONING_EFFORTS, } from "./agent-profile.js";
-/**
- * The unified harness capability layer — the single source of truth for:
- *   1. harness ↔ model compatibility (which models a harness can run),
- *   2. reasoning-effort support (which thinking levels a harness/model expresses), and
- *   3. system-prompt intents (whether a harness can replace its own prompt, add to it, or neither).
- *
- * All are facets of the same question — "what can this (harness, model) pair actually do" — and
- * apply to BOTH harness-backed systems (CLIs that speak a vendor wire, like claude-code, codex and kimi-code) AND
- * router-backed systems (opencode, cli-base: any model the router serves). Lifted here so the
- * cli-bridge backends, the sandbox UI pickers, and the router all read one truth instead of each
- * hand-rolling a divergent copy.
- *
- * Grounded in the native CLI controls (Codex is `minimal..ultra`, Kimi is binary on/off, Claude is
- * `low..max`, cli-base has no agent) — NOT a guessed matrix. The
- * per-MODEL reasoning capability (does this specific model reason at all) is dynamic catalog data the
- * caller supplies.
- */
+import { resolveHarnessType } from "./harness.js";
+/** Canonical harness/model, effort and prompt controls. Model-specific capability comes from the serving catalog. */
 /** low → high. `none` = thinking off; `ultracode` = max (claude-code mode). */
 export const reasoningLadder = REASONING_EFFORTS;
+export class SeatSpecError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "SeatSpecError";
+    }
+}
+/** Parse harness/model[@effort] without credentials, account selection or model substitution. */
+export function parseSeatSpec(value) {
+    const match = /^([^/\s@]+)\/([^/\s@][^\s@]*)(?:@([^\s@]+))?$/u.exec(value);
+    if (!match || /[\u0000-\u001f\u007f]/u.test(value) || match[2].split("/").some((part) => !part))
+        throw new SeatSpecError("SEAT_SYNTAX", "Expected harness/model[@effort]");
+    const [, name, model, effort] = match;
+    const harness = resolveHarnessType(name);
+    if (!harness)
+        throw new SeatSpecError("UNKNOWN_HARNESS", `Unknown harness '${name}'`);
+    if (effort !== undefined && !REASONING_EFFORTS.includes(effort))
+        throw new SeatSpecError("SEAT_SYNTAX", `Unknown reasoning effort '${effort}'; use ${REASONING_EFFORTS.join(", ")}`);
+    const reasoningEffort = effort;
+    if (reasoningEffort !== undefined && (!harnessHonorsEffort(harness) || !harnessReasoningEfforts(harness).includes(reasoningEffort)))
+        throw new SeatSpecError("SEAT_EFFORT_UNSUPPORTED", `Harness ${harness} cannot honor reasoning effort '${reasoningEffort}'`);
+    const support = harnessModelSupport(harness, model, { reasoningEffort });
+    if (!support.supported)
+        throw new SeatSpecError("MODEL_PROVIDER_MISMATCH", support.message);
+    return { harness, model, provider: support.provider, ...(reasoningEffort === undefined ? {} : { reasoningEffort }) };
+}
+/** Preserve the authored model and distinguish inherited effort from explicit none. */
+export function formatSeatSpec(seat) {
+    const value = `${seat.harness}/${seat.model}${seat.reasoningEffort === undefined ? "" : `@${seat.reasoningEffort}`}`;
+    parseSeatSpec(value);
+    return value;
+}
 // ── Harness ↔ model compatibility ────────────────────────────────────────────
 /**
- * Provider prefixes a harness is vendor-locked to (canonical-id prefix, e.g. `moonshot`). A harness
- * with no entry is router-backed: it runs any model, except the measured exclusions in
- * {@link harnessModelExclusions}.
- *
- * `claude-code` and `codex` are deliberately absent. Their CLIs speak a vendor wire (Anthropic
- * Messages, OpenAI Responses), but the Tangle Router passes only that vendor's own models through
- * natively and translates every other model on those wires to chat completions (text, images and
- * function tools, streamed or not; hosted tools are dropped), so both run any router-served model.
- * A caller's own vendor key or login still serves that vendor's models alone, which this table does
- * not see. Which harness a vendor's model adopts when the caller names none is
- * {@link vendorHarness}, a separate fact.
- *
- * `nanoclaw` is deliberately absent despite the "claw" name: its runner routes every provider through
- * the Tangle router (canonical model id straight to the gateway), so it is router-backed like
- * `opencode` — not Anthropic-locked.
+ * Vendor locks, before the measured {@link harnessModelExclusions}. Absent means router-backed.
+ * Claude Code and Codex run any Router model: their native vendor wire passes through for vendor
+ * models and translates others to chat completions (including images/tools; hosted tools drop).
+ * A caller's vendor key/login remains vendor-limited; this table does not know credentials.
+ * NanoClaw also routes every provider through the Router, so it has no Anthropic lock.
+ * {@link vendorHarness} chooses a default harness; it is not a provider restriction.
  */
 const harnessProviderLock = {
     "kimi-code": ["moonshot"],
@@ -256,19 +265,7 @@ export function snapHarnessToModel(harness, modelId) {
  *     emits `--thinking`, represented here by `high`.
  */
 const harnessReasoningEffortsOverride = {
-    codex: ["none", "minimal", "low", "medium", "high", "xhigh", "ultracode"],
     "claude-code": ["low", "medium", "high", "xhigh", "ultracode"],
-    pi: ["none", "minimal", "low", "medium", "high", "xhigh", "ultracode"],
-    prime: ["none", "minimal", "low", "medium", "high", "xhigh", "ultracode"],
-    openclaw: [
-        "none",
-        "minimal",
-        "low",
-        "medium",
-        "high",
-        "xhigh",
-        "ultracode",
-    ],
     "kimi-code": ["none", "high"],
 };
 /**

package/dist/harness.d.ts

@@ -12,22 +12,24 @@ import { z } from "zod";
  * assert protocol, model, profile-control or native-resume compatibility.
  */
 export declare const harnessTypeSchema: z.ZodEnum<{
-    acp: "acp";
-    amp: "amp";
     "claude-code": "claude-code";
-    "cli-base": "cli-base";
-    codex: "codex";
-    cursor: "cursor";
-    "factory-droids": "factory-droids";
-    forge: "forge";
-    gemini: "gemini";
-    hermes: "hermes";
-    "kimi-code": "kimi-code";
     nanoclaw: "nanoclaw";
-    openclaw: "openclaw";
+    codex: "codex";
     opencode: "opencode";
+    "kimi-code": "kimi-code";
     pi: "pi";
     prime: "prime";
+    gemini: "gemini";
+    hermes: "hermes";
+    openclaw: "openclaw";
+    amp: "amp";
+    "factory-droids": "factory-droids";
+    forge: "forge";
+    cursor: "cursor";
+    acp: "acp";
+    "cli-base": "cli-base";
 }>;
 /** One declaration owns runtime validation and the compile-time vocabulary. */
 export type HarnessType = z.infer<typeof harnessTypeSchema>;
+/** Command spellings resolve to canonical identities; authored profile schemas stay strict. */
+export declare function resolveHarnessType(value: string): HarnessType | null;

package/dist/harness.js

@@ -29,3 +29,8 @@ export const harnessTypeSchema = z.enum([
     "acp",
     "cli-base",
 ]);
+/** Command spellings resolve to canonical identities; authored profile schemas stay strict. */
+export function resolveHarnessType(value) {
+    const parsed = harnessTypeSchema.safeParse(value === "claude" ? "claude-code" : value === "kimi" ? "kimi-code" : value);
+    return parsed.success ? parsed.data : null;
+}

package/dist/interaction-envelope.d.ts

@@ -21,8 +21,8 @@ export declare const InteractionSubjectSchema: z.ZodDiscriminatedUnion<[z.ZodObj
 }, z.core.$strict>], "type">;
 export type InteractionSubject = z.infer<typeof InteractionSubjectSchema>;
 export declare const InteractionOutcomeSchema: z.ZodEnum<{
-    accepted: "accepted";
     cancelled: "cancelled";
+    accepted: "accepted";
     declined: "declined";
 }>;
 export type InteractionOutcome = z.infer<typeof InteractionOutcomeSchema>;
@@ -37,22 +37,22 @@ export declare const InteractionRequestBindingSchema: z.ZodObject<{
 export type InteractionRequestBinding = z.infer<typeof InteractionRequestBindingSchema>;
 /** Exact execution coordinates shared by every interaction from one provider turn. */
 export declare const InteractionExecutionBindingSchema: z.ZodObject<{
-    runId: z.ZodString;
     provider: z.ZodString;
+    executionId: z.ZodString;
+    runId: z.ZodString;
     environmentId: z.ZodString;
     sessionId: z.ZodString;
-    executionId: z.ZodString;
 }, z.core.$strict>;
 export type InteractionExecutionBinding = z.infer<typeof InteractionExecutionBindingSchema>;
 /** Binding carried by a response command and acknowledgement. */
 export declare const InteractionBindingSchema: z.ZodObject<{
+    requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
     runId: z.ZodString;
     provider: z.ZodString;
     environmentId: z.ZodString;
     sessionId: z.ZodString;
     executionId: z.ZodString;
     interactionId: z.ZodString;
-    requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
 }, z.core.$strict>;
 export type InteractionBinding = z.infer<typeof InteractionBindingSchema>;
 export interface InteractionRequestMaterial {
@@ -74,6 +74,7 @@ export interface InteractionRequest extends InteractionRequestMaterial {
 }
 export declare function interactionRequestDigest(request: InteractionRequestMaterial): Sha256Digest;
 export declare const InteractionRequestSchema: z.ZodObject<{
+    requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
     id: z.ZodString;
     kind: z.ZodString;
     title: z.ZodString;
@@ -95,32 +96,29 @@ export declare const InteractionRequestSchema: z.ZodObject<{
     }, z.core.$strict>], "type">>;
     answerSpec: z.ZodObject<{
         fields: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-            name: z.ZodString;
-            label: z.ZodString;
-            required: z.ZodOptional<z.ZodBoolean>;
             type: z.ZodLiteral<"text">;
             multiline: z.ZodOptional<z.ZodBoolean>;
             placeholder: z.ZodOptional<z.ZodString>;
             maxLength: z.ZodOptional<z.ZodNumber>;
             default: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>, z.ZodObject<{
             name: z.ZodString;
             label: z.ZodString;
             required: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>, z.ZodObject<{
             type: z.ZodLiteral<"number">;
             min: z.ZodOptional<z.ZodNumber>;
             max: z.ZodOptional<z.ZodNumber>;
             default: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strict>, z.ZodObject<{
             name: z.ZodString;
             label: z.ZodString;
             required: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>, z.ZodObject<{
             type: z.ZodLiteral<"boolean">;
             default: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strict>, z.ZodObject<{
             name: z.ZodString;
             label: z.ZodString;
             required: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>, z.ZodObject<{
             type: z.ZodLiteral<"select">;
             options: z.ZodArray<z.ZodObject<{
                 value: z.ZodString;
@@ -130,23 +128,26 @@ export declare const InteractionRequestSchema: z.ZodObject<{
             multi: z.ZodOptional<z.ZodBoolean>;
             allowCustom: z.ZodOptional<z.ZodBoolean>;
             default: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strict>, z.ZodObject<{
             name: z.ZodString;
             label: z.ZodString;
             required: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>, z.ZodObject<{
             type: z.ZodLiteral<"secret">;
             placeholder: z.ZodOptional<z.ZodString>;
             maxLength: z.ZodOptional<z.ZodNumber>;
+            name: z.ZodString;
+            label: z.ZodString;
+            required: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strict>], "type">>;
     }, z.core.$strict>;
     responseScopes: z.ZodOptional<z.ZodArray<z.ZodEnum<{
         interaction: "interaction";
-        persistent: "persistent";
         session: "session";
+        persistent: "persistent";
     }>>>;
     allowedOutcomes: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-        accepted: "accepted";
         cancelled: "cancelled";
+        accepted: "accepted";
         declined: "declined";
     }>>>;
     default: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -173,7 +174,6 @@ export declare const InteractionRequestSchema: z.ZodObject<{
         executionId: z.ZodString;
         interactionId: z.ZodString;
     }, z.core.$strict>;
-    requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
 }, z.core.$strict>;
 export declare const InteractionResponseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     id: z.ZodString;
@@ -199,13 +199,13 @@ export declare function interactionResponseCommandDigest(material: InteractionRe
 export declare const InteractionResponseCommandSchema: z.ZodObject<{
     operationId: z.ZodString;
     binding: z.ZodObject<{
+        requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
         runId: z.ZodString;
         provider: z.ZodString;
         environmentId: z.ZodString;
         sessionId: z.ZodString;
         executionId: z.ZodString;
         interactionId: z.ZodString;
-        requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
     }, z.core.$strict>;
     commandDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
     response: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -224,42 +224,42 @@ export declare const InteractionResponseCommandSchema: z.ZodObject<{
 }, z.core.$strict>;
 export type InteractionResponseCommand = z.infer<typeof InteractionResponseCommandSchema>;
 export declare const InteractionAcknowledgementStatusSchema: z.ZodEnum<{
+    cancelled: "cancelled";
+    expired: "expired";
     accepted: "accepted";
-    already_resolved_different: "already_resolved_different";
     already_resolved_same: "already_resolved_same";
+    already_resolved_different: "already_resolved_different";
+    unknown_interaction: "unknown_interaction";
+    unknown_run: "unknown_run";
     binding_mismatch: "binding_mismatch";
-    cancelled: "cancelled";
-    expired: "expired";
     invalid_response: "invalid_response";
     transport_failure: "transport_failure";
-    unknown_interaction: "unknown_interaction";
-    unknown_run: "unknown_run";
 }>;
 export type InteractionAcknowledgementStatus = z.infer<typeof InteractionAcknowledgementStatusSchema>;
 /** Durable result of one interaction response operation. */
 export declare const InteractionAcknowledgementSchema: z.ZodObject<{
     operationId: z.ZodString;
     binding: z.ZodObject<{
+        requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
         runId: z.ZodString;
         provider: z.ZodString;
         environmentId: z.ZodString;
         sessionId: z.ZodString;
         executionId: z.ZodString;
         interactionId: z.ZodString;
-        requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
     }, z.core.$strict>;
     commandDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
     status: z.ZodEnum<{
+        cancelled: "cancelled";
+        expired: "expired";
         accepted: "accepted";
-        already_resolved_different: "already_resolved_different";
         already_resolved_same: "already_resolved_same";
+        already_resolved_different: "already_resolved_different";
+        unknown_interaction: "unknown_interaction";
+        unknown_run: "unknown_run";
         binding_mismatch: "binding_mismatch";
-        cancelled: "cancelled";
-        expired: "expired";
         invalid_response: "invalid_response";
         transport_failure: "transport_failure";
-        unknown_interaction: "unknown_interaction";
-        unknown_run: "unknown_run";
     }>;
     message: z.ZodOptional<z.ZodString>;
     retryable: z.ZodOptional<z.ZodBoolean>;

package/dist/interaction-fields.d.ts

@@ -8,32 +8,29 @@ import { z } from "zod";
 export declare const RESERVED_INTERACTION_FIELD_NAMES: ReadonlySet<string>;
 export declare const InteractionFieldNameSchema: z.ZodString;
 export declare const InteractionFieldSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    name: z.ZodString;
-    label: z.ZodString;
-    required: z.ZodOptional<z.ZodBoolean>;
     type: z.ZodLiteral<"text">;
     multiline: z.ZodOptional<z.ZodBoolean>;
     placeholder: z.ZodOptional<z.ZodString>;
     maxLength: z.ZodOptional<z.ZodNumber>;
     default: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>, z.ZodObject<{
     name: z.ZodString;
     label: z.ZodString;
     required: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>, z.ZodObject<{
     type: z.ZodLiteral<"number">;
     min: z.ZodOptional<z.ZodNumber>;
     max: z.ZodOptional<z.ZodNumber>;
     default: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strict>, z.ZodObject<{
     name: z.ZodString;
     label: z.ZodString;
     required: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>, z.ZodObject<{
     type: z.ZodLiteral<"boolean">;
     default: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strict>, z.ZodObject<{
     name: z.ZodString;
     label: z.ZodString;
     required: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>, z.ZodObject<{
     type: z.ZodLiteral<"select">;
     options: z.ZodArray<z.ZodObject<{
         value: z.ZodString;
@@ -43,43 +40,43 @@ export declare const InteractionFieldSchema: z.ZodDiscriminatedUnion<[z.ZodObjec
     multi: z.ZodOptional<z.ZodBoolean>;
     allowCustom: z.ZodOptional<z.ZodBoolean>;
     default: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strict>, z.ZodObject<{
     name: z.ZodString;
     label: z.ZodString;
     required: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>, z.ZodObject<{
     type: z.ZodLiteral<"secret">;
     placeholder: z.ZodOptional<z.ZodString>;
     maxLength: z.ZodOptional<z.ZodNumber>;
+    name: z.ZodString;
+    label: z.ZodString;
+    required: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strict>], "type">;
 export type InteractionField = z.infer<typeof InteractionFieldSchema>;
 export declare const InteractionAnswerSpecSchema: z.ZodObject<{
     fields: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        name: z.ZodString;
-        label: z.ZodString;
-        required: z.ZodOptional<z.ZodBoolean>;
         type: z.ZodLiteral<"text">;
         multiline: z.ZodOptional<z.ZodBoolean>;
         placeholder: z.ZodOptional<z.ZodString>;
         maxLength: z.ZodOptional<z.ZodNumber>;
         default: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>, z.ZodObject<{
         name: z.ZodString;
         label: z.ZodString;
         required: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"number">;
         min: z.ZodOptional<z.ZodNumber>;
         max: z.ZodOptional<z.ZodNumber>;
         default: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strict>, z.ZodObject<{
         name: z.ZodString;
         label: z.ZodString;
         required: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"boolean">;
         default: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strict>, z.ZodObject<{
         name: z.ZodString;
         label: z.ZodString;
         required: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"select">;
         options: z.ZodArray<z.ZodObject<{
             value: z.ZodString;
@@ -89,44 +86,47 @@ export declare const InteractionAnswerSpecSchema: z.ZodObject<{
         multi: z.ZodOptional<z.ZodBoolean>;
         allowCustom: z.ZodOptional<z.ZodBoolean>;
         default: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>, z.ZodObject<{
         name: z.ZodString;
         label: z.ZodString;
         required: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"secret">;
         placeholder: z.ZodOptional<z.ZodString>;
         maxLength: z.ZodOptional<z.ZodNumber>;
+        name: z.ZodString;
+        label: z.ZodString;
+        required: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strict>], "type">>;
 }, z.core.$strict>;
 export type InteractionAnswerSpec = z.infer<typeof InteractionAnswerSpecSchema>;
 export declare const InteractionFieldTypeSchema: z.ZodEnum<{
-    boolean: "boolean";
     number: "number";
-    secret: "secret";
-    select: "select";
+    boolean: "boolean";
     text: "text";
+    select: "select";
+    secret: "secret";
 }>;
 /** Scope at which an accepted answer may be reused by an explicit policy. */
 export declare const InteractionResponseScopeSchema: z.ZodEnum<{
     interaction: "interaction";
-    persistent: "persistent";
     session: "session";
+    persistent: "persistent";
 }>;
 export type InteractionResponseScope = z.infer<typeof InteractionResponseScopeSchema>;
 /** Negotiated interaction behavior. Absence means interactions are unsupported. */
 export declare const InteractionCapabilitiesSchema: z.ZodObject<{
     kinds: z.ZodArray<z.ZodString>;
     answerFieldTypes: z.ZodArray<z.ZodEnum<{
-        boolean: "boolean";
         number: "number";
-        secret: "secret";
-        select: "select";
+        boolean: "boolean";
         text: "text";
+        select: "select";
+        secret: "secret";
     }>>;
     responseScopes: z.ZodArray<z.ZodEnum<{
         interaction: "interaction";
-        persistent: "persistent";
         session: "session";
+        persistent: "persistent";
     }>>;
     secretAnswers: z.ZodBoolean;
     concurrentRequests: z.ZodBoolean;

package/dist/interaction-permissions.d.ts

@@ -24,10 +24,10 @@ export declare const PERMISSION_GRANT_FIELD = "grant";
 export declare const PERMISSION_FEEDBACK_FIELD = "feedback";
 /** Graduated permission decision — the value of the `grant` field. */
 export declare const PermissionGrantSchema: z.ZodEnum<{
-    allow_always: "allow_always";
+    deny: "deny";
     allow_once: "allow_once";
     allow_session: "allow_session";
-    deny: "deny";
+    allow_always: "allow_always";
 }>;
 export type PermissionGrant = z.infer<typeof PermissionGrantSchema>;
 /** Build a permission answer spec that cannot offer a broader reusable grant. */