@canonmsg/agent-sdk 12.0.0 → 12.2.0

package/dist/internal/backend-contracts/mlsDevInteraction.d.ts

@@ -0,0 +1,159 @@
+import { type MlsDevInteractionBinding, type MlsDevInteractionKind, type MlsDevItemPayload, type MlsDevTextPayload } from './mlsDevApplication.js';
+import { type MlsDevGroupHead } from './mlsDevGroup.js';
+/**
+ * Encrypted approvals and questions in `canon.mls.dev-text.v2` rooms (docs/design/encrypted-interactions.md §2.3–§2.4).
+ * The MLS plaintext is a closed union on `kind`; every variant carries the text payload's shared ids. These parsers run
+ * in the sender's endpoint before encryption and in every recipient after decryption. Native custody treats an
+ * interaction body as canonical JSON and checks only the shared ids, kind and size.
+ */
+export declare const MLS_DEV_INTERACTION_LIMITS: Readonly<{
+    title: 200;
+    details: 8000;
+    options: 10;
+    optionLabel: 120;
+    text: 4000;
+}>;
+/** RFC 9180 base mode, DHKEM(X25519, HKDF-SHA256), HKDF-SHA256, AES-128-GCM: MLS suite 1's primitives. */
+export declare const MLS_DEV_SECRET_ANSWER_SUITE: "x25519-hkdf-sha256-aes128gcm";
+/** UTF-8 of at most 4,000 code points (4 bytes each) plus the AES-GCM tag. */
+export declare const MLS_DEV_SECRET_ANSWER_MAX_BYTES: number;
+export declare const MLS_DEV_INTERACTION_WITHDRAW_REASONS: readonly ["stopped", "turn_ended", "expired", "restart"];
+export type MlsDevInteractionWithdrawReason = typeof MLS_DEV_INTERACTION_WITHDRAW_REASONS[number];
+export interface MlsDevInteractionOption {
+    readonly id: string;
+    readonly label: string;
+}
+export interface MlsDevInteractionRequestBody {
+    readonly requestId: string;
+    readonly kind: MlsDevInteractionKind;
+    readonly title: string;
+    readonly details?: string;
+    readonly options?: readonly MlsDevInteractionOption[];
+    readonly multiple?: boolean;
+    readonly risk?: 'normal' | 'destructive';
+    readonly allowSession?: boolean;
+    readonly scopeKey?: string;
+    readonly responderIds: readonly [string];
+    readonly expiresAtMs: number;
+    /** A secret request's one-time HPKE recipient key, generated and held by the requesting device's custody (§2.5). */
+    readonly secretKey?: {
+        readonly kem: 'x25519';
+        readonly publicKey: string;
+    };
+}
+export type MlsDevInteractionAnswer = {
+    readonly decision: 'allow' | 'deny';
+    readonly scope: 'once' | 'session';
+} | {
+    readonly choices: readonly string[];
+} | {
+    readonly text: string;
+} | {
+    readonly sealed: {
+        readonly enc: string;
+        readonly ciphertext: string;
+    };
+}
+/** The responder's Cancel/Skip on a question or secret card (review of #1081). */
+ | {
+    readonly cancelled: true;
+};
+export interface MlsDevInteractionResponseBody {
+    readonly requestId: string;
+    readonly agentId: string;
+    readonly answer: MlsDevInteractionAnswer;
+}
+export interface MlsDevInteractionWithdrawBody {
+    readonly requestId: string;
+    readonly reason: MlsDevInteractionWithdrawReason;
+}
+interface MlsDevApplicationPayloadIds {
+    readonly version: 1;
+    readonly conversationId: string;
+    readonly groupId: string;
+    readonly messageId: string;
+    readonly operationId: string;
+    readonly senderDeviceId: string;
+}
+export type MlsDevInteractionPayload = (MlsDevApplicationPayloadIds & {
+    readonly kind: 'interaction.request';
+    readonly interaction: MlsDevInteractionRequestBody;
+}) | (MlsDevApplicationPayloadIds & {
+    readonly kind: 'interaction.response';
+    readonly interaction: MlsDevInteractionResponseBody;
+}) | (MlsDevApplicationPayloadIds & {
+    readonly kind: 'interaction.withdraw';
+    readonly interaction: MlsDevInteractionWithdrawBody;
+});
+export type MlsDevApplicationPayload = MlsDevTextPayload | MlsDevItemPayload | MlsDevInteractionPayload;
+export type MlsDevInteractionPayloadKind = MlsDevInteractionPayload['kind'];
+export declare const MLS_DEV_INTERACTION_PAYLOAD_KINDS: readonly ["interaction.request", "interaction.response", "interaction.withdraw"];
+/** The server's metadata-only record (§2.4): no title, options, decision, scope or answer. */
+export interface MlsDevInteractionRecord {
+    readonly version: 1;
+    readonly conversationId: string;
+    readonly agentId: string;
+    readonly requesterDeviceId: string;
+    readonly requestId: string;
+    readonly kind: MlsDevInteractionKind;
+    readonly responderIds: readonly [string];
+    readonly expiresAtMs: number;
+    readonly status: 'pending' | 'answered' | 'withdrawn';
+    readonly binding: {
+        readonly groupId: string;
+        readonly head: MlsDevGroupHead;
+        readonly membershipRevision: number;
+        readonly requestMessageId: string;
+        readonly requestOrdinal: number;
+    };
+    readonly answer?: {
+        readonly responderId: string;
+        readonly responderDeviceId: string;
+        readonly messageId: string;
+        readonly ordinal: number;
+        readonly acceptedAtMs: number;
+    };
+    readonly withdrawal?: {
+        readonly messageId: string;
+        readonly ordinal: number;
+        readonly acceptedAtMs: number;
+    };
+    readonly createdAtMs: number;
+}
+export interface MlsDevInteractionsQuery {
+    readonly version: 1;
+    readonly conversationId?: string;
+}
+/** The caller's answerable pending requests, for badges and web's content-free waiting notice. */
+export interface MlsDevInteractionsResult {
+    readonly version: 1;
+    readonly interactions: readonly {
+        readonly conversationId: string;
+        readonly agentId: string;
+        readonly requestId: string;
+        readonly kind: MlsDevInteractionKind;
+        readonly expiresAtMs: number;
+    }[];
+}
+export declare const MLS_DEV_INTERACTIONS_QUERY_MAX = 50;
+export declare class MlsDevInteractionValidationError extends Error {
+    readonly code = "INVALID_MLS_DEV_INTERACTION";
+    constructor();
+}
+export declare function parseMlsDevInteractionRequestBody(value: unknown): MlsDevInteractionRequestBody;
+export declare function parseMlsDevInteractionAnswer(value: unknown): MlsDevInteractionAnswer;
+export declare function parseMlsDevInteractionResponseBody(value: unknown): MlsDevInteractionResponseBody;
+export declare function parseMlsDevInteractionWithdrawBody(value: unknown): MlsDevInteractionWithdrawBody;
+/** The closed v2 plaintext union. A v1 room accepts only `kind: 'text'` (`parseMlsDevTextPayload`). */
+export declare function parseMlsDevApplicationPayload(value: unknown): MlsDevApplicationPayload;
+/** Receipt-time check (`applyApplication`): the encrypted payload repeats exactly what its public binding announced. */
+export declare function assertMlsDevInteractionPayloadBinding(payload: MlsDevApplicationPayload, binding: MlsDevInteractionBinding | undefined): void;
+/**
+ * Whether an answer has the shape its request allows. A session-scoped decision needs a request that offered a session
+ * rule (`allowSession`; a destructive action never does, §3); the runner also counts one only from the agent's owner.
+ */
+export declare function isMlsDevInteractionAnswerAllowed(request: MlsDevInteractionRequestBody, answer: MlsDevInteractionAnswer): boolean;
+export declare function parseMlsDevInteractionRecord(value: unknown): MlsDevInteractionRecord;
+export declare function parseMlsDevInteractionsQuery(value: unknown): MlsDevInteractionsQuery;
+export declare function parseMlsDevInteractionsResult(value: unknown): MlsDevInteractionsResult;
+export {};

package/dist/internal/backend-contracts/mlsEnvironment.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Each environment's MLS identity: the values signed into its credentials, group controls and application AAD. A
+ * production device, credential or group can never verify as Dev (or the reverse) because these differ. Dev's values
+ * are today's literals, so Dev bytes are unchanged. A declared profile only defines the wire; whether an environment
+ * runs MLS is decided by its deployment (Functions gates, configuration, native builds), never here.
+ */
+export declare const MLS_ENVIRONMENT_PROFILES: Readonly<{
+    readonly 'canon-dev-v1': Readonly<{
+        issuer: "canon-mls-dev-v1";
+        credentialType: "canon-mls-dev-credential+jws";
+        issuerKeyPath: "projects/canonmail-dev/locations/europe-west1/keyRings/canon-mls/cryptoKeys/device-issuer";
+        receiptKeyPath: "projects/canonmail-dev/locations/europe-west1/keyRings/canon-mls/cryptoKeys/feed-receipt";
+    }>;
+    readonly 'canon-prod-v1': Readonly<{
+        issuer: "canon-mls-prod-v1";
+        credentialType: "canon-mls-prod-credential+jws";
+        issuerKeyPath: "projects/canonmail-prod/locations/europe-west1/keyRings/canon-mls/cryptoKeys/device-issuer";
+        receiptKeyPath: "projects/canonmail-prod/locations/europe-west1/keyRings/canon-mls/cryptoKeys/feed-receipt";
+    }>;
+}>;
+export type MlsEnvironmentId = keyof typeof MLS_ENVIRONMENT_PROFILES;
+export type MlsEnvironmentProfile = (typeof MLS_ENVIRONMENT_PROFILES)[MlsEnvironmentId];
+export type MlsIssuerId = MlsEnvironmentProfile['issuer'];
+/**
+ * Exact match only: no trimming or case folding, so an alias never reaches signed bytes. Throws the shared internal
+ * parser error, which each public boundary replaces with its own.
+ */
+export declare function requireMlsEnvironmentId(value: unknown): MlsEnvironmentId;
+/** The same exact match as a predicate, for callers that refuse with their own error. */
+export declare function isMlsEnvironmentId(value: unknown): value is MlsEnvironmentId;
+export declare function mlsEnvironmentProfile(environmentId: MlsEnvironmentId): MlsEnvironmentProfile;
+/** The environment whose issuer key a KMS key-version path names, or undefined for any other path. */
+export declare function mlsEnvironmentOfIssuerKeyVersion(value: string): MlsEnvironmentId | undefined;
+/** The environment whose feed-receipt key (mls-signed-acceptance.md) a KMS key-version path names, or undefined. */
+export declare function mlsEnvironmentOfReceiptKeyVersion(value: string): MlsEnvironmentId | undefined;

package/dist/internal/backend-contracts/mlsPrincipalAlias.d.ts

@@ -0,0 +1,26 @@
+import { type MlsEnvironmentId } from './mlsEnvironment.js';
+export declare const MLS_PRINCIPAL_ALIAS_PREFIX = "mlsa_";
+export interface MlsPrincipalOpening {
+    readonly type: 'human' | 'ai_agent';
+    readonly accountId: string;
+    /** 32 random bytes, canonical base64url. */
+    readonly salt: string;
+}
+/** An alias's shape; whether it opens to an account needs its opening. Account IDs never have it. */
+export declare function isMlsPrincipalAlias(value: unknown): value is string;
+/** An account ID (a Firebase uid, an agent's document ID): an MLS principal ID that is also exactly one document ID, so
+ * never containing `/` and never `.` or `..`. */
+export declare function isMlsAccountId(value: unknown): value is string;
+export declare function parseMlsPrincipalOpening(value: unknown): MlsPrincipalOpening;
+/**
+ * SHA-256 over the domain above, LP environment, u8 type (human 0/agent 1), LP account ID and the raw 32-byte salt,
+ * where LP is a u32 big-endian byte length followed by UTF-8, as in the enrollment proof.
+ */
+export declare function encodeMlsPrincipalAliasInput(environmentId: MlsEnvironmentId, opening: MlsPrincipalOpening): Uint8Array;
+export declare function mlsPrincipalAlias(environmentId: MlsEnvironmentId, opening: MlsPrincipalOpening): Promise<string>;
+/** Whether `opening` opens `alias` in this environment. A malformed opening opens nothing. */
+export declare function opensMlsPrincipalAlias(environmentId: MlsEnvironmentId, alias: string, opening: unknown): Promise<boolean>;
+/** A fresh opening for an account: Canon's server makes one the first time the account needs an alias. */
+export declare function createMlsPrincipalOpening(type: MlsPrincipalOpening['type'], id: string): MlsPrincipalOpening;
+/** A room's openings, `{[alias]: opening}`: the shape only. Readers still check each opening against its alias. */
+export declare function parseMlsRoomIdentities(value: unknown): Readonly<Record<string, MlsPrincipalOpening>>;

package/dist/internal/backend-contracts/runtimeCardFields.d.ts

@@ -2,10 +2,6 @@
  * Canonical `canon.card.v1` action-field type vocabulary. The runtime array is
  * the single source of truth and the type is derived from it, so a value and a
  * type cannot drift.
- *
- * ORDER IS LOAD-BEARING: scripts/generate-skill-bundles.mjs renders this list
- * verbatim (via @canonmsg/rich-cards) into two committed SKILL.md files, and
- * `npm run check:skill-bundles` fails on a byte change.
  */
 export declare const RUNTIME_CARD_FIELD_TYPES: readonly ["text", "textarea", "select", "multiSelect", "boolean", "date", "number", "currency", "searchSelect", "lineItems"];
 export type RuntimeCardFieldType = (typeof RUNTIME_CARD_FIELD_TYPES)[number];

package/dist/internal/backend-contracts/upload-mime-types.d.ts

@@ -0,0 +1,17 @@
+/** The media types Canon accepts for an upload, resolved the same way on a device and on the server. */
+export type AllowedUploadKind = 'image' | 'audio' | 'video' | 'file';
+export declare const SAFE_IMAGE_MIME_TYPES: Set<string>;
+export declare const SAFE_AUDIO_MIME_TYPES: Set<string>;
+export declare const SAFE_VIDEO_MIME_TYPES: Set<string>;
+export declare const SAFE_FILE_MIME_TYPES: Set<string>;
+export declare function normalizeMimeType(value: unknown): string | null;
+export declare function classifyAllowedUploadMimeType(value: unknown): AllowedUploadKind | null;
+export declare function normalizeAllowedUploadMimeType(value: unknown): string | null;
+export declare function resolveAllowedUploadMimeType(input: {
+    mimeType?: unknown;
+    fileName?: unknown;
+}): string | null;
+export declare function getAllowedUploadExtension(input: {
+    mimeType: string;
+    fileName?: unknown;
+}): string;

package/dist/internal/backend-contracts/verbContract.d.ts

@@ -4,14 +4,14 @@
  * (v1 scope: messaging, HITL interactions, contact sharing, and the read
  * verbs bindings need alongside them).
  *
- * One verb = one intent-level action. Each runtime binding (Hermes native
- * tool, MCP server, codex dynamicTools, agent-sdk method, CLI) projects these
- * verbs into its native tool surface; the names, argument shapes, limits, and
- * result vocabularies defined here are the single source of truth. JSON
+ * One verb = one intent-level action. Each runtime binding (MCP server, codex
+ * dynamicTools, agent-sdk method, CLI) projects these verbs into its native
+ * tool surface; the names, argument shapes, limits, and result vocabularies
+ * defined here are the single source of truth. JSON
  * Schemas for each verb live in `verbSchemas.ts` and are also emitted as a
  * plain JSON artifact at build time (`dist/canon-verbs.schema.json`) so
- * non-TypeScript consumers (the Python hermes plugin, external integrators)
- * can consume the identical contract.
+ * non-TypeScript consumers (external integrators) can consume the identical
+ * contract.
  *
  * Deliberately NOT verbs: replying in the active conversation, streaming
  * partials, typing, and read receipts stay host-mediated — the model talks
@@ -51,8 +51,7 @@ export declare const CANON_VERB_NAMESPACE = "canon";
 /**
  * $id of the canonical canon.card.v1 document schema
  * (@canonmsg/rich-cards RUNTIME_CARD_JSON_SCHEMA_V1). The verbs bundle only
- * validates the card ENVELOPE; compose the full document schema into card
- * verbs via `getVerbInputSchema(verb, { cardSchema })`.
+ * validates the card ENVELOPE.
  */
 export declare const CANON_CARD_SCHEMA_ID = "https://canonmsg.com/schemas/canon.card.v1.json";
 /**
@@ -100,9 +99,7 @@ export declare const VERB_LIMITS: {
     readonly externalSourceLabelChars: 80;
     /**
      * Contact-request note. Values longer than this are truncated by senders
-     * (slice(0,497)+'...') — the truncation is currently triplicated in
-     * functions/src/api/sendContextualMessage.ts, packages/core/src/reach-out.ts
-     * and the hermes plugin; this constant is the canonical figure.
+     * (slice(0,497)+'...'); this constant is the canonical figure.
      */
     readonly contactRequestNoteChars: 500;
     /** Group membership cap incl. creator (functions/src/utils/conversations.ts MAX_GROUP_MEMBERS). */
@@ -308,14 +305,23 @@ export type SendToResult = {
     created?: boolean;
     reused?: boolean;
     sessionSelection?: string;
+}
+/** The room is encrypted, so Canon stored no opening text: the sender sends it encrypted under `messageId`. */
+ | {
+    status: 'opened';
+    conversationId: string;
+    messageId: string;
+    openingText: 'deferred';
+    created?: boolean;
+    reused?: boolean;
 } | {
-    status: 'requested';
-    requestId: string | null;
-    deferredIntentId?: string | null;
-} | {
-    status: 'pending';
+    status: 'requested' | 'pending';
     requestId: string | null;
     deferredIntentId?: string | null;
+    /** An encrypted room stores no opener: the sender sends it into `conversationId` under `messageId`. */
+    conversationId?: string;
+    messageId?: string;
+    openingText?: 'deferred';
 } | {
     status: 'setup_required';
     reason: string;
@@ -752,9 +758,7 @@ export declare const CANON_VERB_LIMITS_ARTIFACT: {
         readonly externalSourceLabelChars: 80;
         /**
          * Contact-request note. Values longer than this are truncated by senders
-         * (slice(0,497)+'...') — the truncation is currently triplicated in
-         * functions/src/api/sendContextualMessage.ts, packages/core/src/reach-out.ts
-         * and the hermes plugin; this constant is the canonical figure.
+         * (slice(0,497)+'...'); this constant is the canonical figure.
          */
         readonly contactRequestNoteChars: 500;
         /** Group membership cap incl. creator (functions/src/utils/conversations.ts MAX_GROUP_MEMBERS). */

package/dist/internal/backend-contracts/verbSchemas.d.ts

@@ -5,9 +5,8 @@
  * `<verb>_result` definition per verb under `$defs` plus shared shapes. The
  * document is emitted verbatim to `dist/canon-verbs.schema.json` at build
  * time (see scripts/emit-verb-schemas.mjs) so non-TypeScript bindings can
- * consume the byte-identical contract instead of hand-porting it (the Python
- * hermes plugin adopts it in a follow-up PR; external integrators and
- * generated CLIs read it from the npm package).
+ * consume the byte-identical contract instead of hand-porting it (external
+ * integrators and generated CLIs read it from the npm package).
  *
  * Conventions:
  * - Verb INPUT schemas are strict (`additionalProperties: false`) — a binding
@@ -686,7 +685,7 @@ export declare const CANON_VERBS_JSON_SCHEMA: {
             }];
         };
         readonly send_to_result: {
-            readonly description: string;
+            readonly description: "Canonical outcome vocabulary.";
             readonly oneOf: readonly [{
                 readonly type: "object";
                 readonly required: readonly ["status", "conversationId"];
@@ -714,6 +713,31 @@ export declare const CANON_VERBS_JSON_SCHEMA: {
                         readonly type: "string";
                     };
                 };
+            }, {
+                readonly type: "object";
+                readonly required: readonly ["status", "conversationId", "messageId", "openingText"];
+                readonly additionalProperties: true;
+                readonly description: "The room is encrypted, so Canon stored no opening text: the sender sends it encrypted under messageId.";
+                readonly properties: {
+                    readonly status: {
+                        readonly const: "opened";
+                    };
+                    readonly conversationId: {
+                        readonly type: "string";
+                    };
+                    readonly messageId: {
+                        readonly type: "string";
+                    };
+                    readonly openingText: {
+                        readonly const: "deferred";
+                    };
+                    readonly created: {
+                        readonly type: "boolean";
+                    };
+                    readonly reused: {
+                        readonly type: "boolean";
+                    };
+                };
             }, {
                 readonly type: "object";
                 readonly required: readonly ["status", "requestId"];
@@ -729,6 +753,16 @@ export declare const CANON_VERBS_JSON_SCHEMA: {
                         readonly type: readonly ["string", "null"];
                         readonly description: "Present when the send is deferred until the contact request resolves.";
                     };
+                    readonly conversationId: {
+                        readonly type: "string";
+                    };
+                    readonly messageId: {
+                        readonly type: "string";
+                    };
+                    readonly openingText: {
+                        readonly const: "deferred";
+                        readonly description: "The room is encrypted, so Canon stored no opening text: the sender sends it encrypted under messageId.";
+                    };
                 };
             }, {
                 readonly type: "object";
@@ -1678,30 +1712,5 @@ export interface CanonVerbSchemaRefs {
 export declare const CANON_VERB_SCHEMA_REFS: Record<CanonVerbName, CanonVerbSchemaRefs>;
 /** A verb subschema extracted from the bundle, self-contained for embedding. */
 export type CanonVerbJsonSchema = Record<string, unknown>;
-export interface GetVerbSchemaOptions {
-    /**
-     * The full canon.card.v1 document schema (@canonmsg/rich-cards
-     * RUNTIME_CARD_JSON_SCHEMA_V1) to compose into card-carrying verbs. When
-     * provided, the envelope-only `runtimeCard` definition is replaced so block
-     * structures validate too. backend-contracts deliberately does not depend
-     * on rich-cards (build-order/dependency direction), so the binding supplies
-     * the schema.
-     *
-     * The card schema is REBASED, not nested: its own `$defs` are merged into
-     * the verb schema's `$defs` under `card__`-prefixed names and every
-     * internal `#/$defs/...` ref (including `<card $id>#/$defs/...` forms) is
-     * rewritten accordingly. The result is a single self-contained schema
-     * resource with plain internal refs — no embedded `$id` — so it compiles
-     * on naive validators and never conflicts with a separately registered
-     * canon.card.v1 resource on the same Ajv instance.
-     *
-     * Ajv note: the real card schema uses spec-valid union types
-     * (min/max: number | date-string), so compile composed schemas with
-     * `{ strict: true, allowUnionTypes: true }`.
-     */
-    cardSchema?: Record<string, unknown>;
-}
-/** Self-contained input schema for a verb (for embedding into tool definitions). */
-export declare function getVerbInputSchema(verb: CanonVerbName, options?: GetVerbSchemaOptions): CanonVerbJsonSchema;
 /** Self-contained result schema for a verb. */
 export declare function getVerbResultSchema(verb: CanonVerbName): CanonVerbJsonSchema;

package/dist/internal/core/agent-profiles.d.ts

@@ -1,10 +1,8 @@
 /**
  * Shared agent profile management — loading, locking, and resolution.
- * Used by both host.ts and server.ts.
  */
 import type { CanonEnvironmentId } from '../backend-contracts/index.js';
 import type { AgentClientType } from './types.js';
-import { type CanonRuntimeConnectionOptions } from './runtime-endpoints.js';
 export interface AgentProfileInput {
     apiKey: string;
     agentId: string;
@@ -64,6 +62,4 @@ export interface PendingRegistration {
 }
 export declare function loadPendingRegistrations(): Record<string, PendingRegistration>;
 export declare function savePendingRegistrations(pending: Record<string, PendingRegistration>): void;
-export declare function getOrCreatePendingRegistration(profile: string, clientType?: AgentClientType, connectionOptions?: CanonRuntimeConnectionOptions): PendingRegistration;
-export declare function updatePendingRegistration(profile: string, patch: Partial<Pick<PendingRegistration, 'requestId' | 'pollToken' | 'clientType'>>): PendingRegistration;
 export declare function clearPendingRegistration(profile: string): void;

package/dist/internal/core/approval-format.d.ts

@@ -1,4 +1,4 @@
-import type { ApprovalRequestCategory, ApprovalRequestDetail, ApprovalRequestMetadata, ApprovalNativeRequestMetadata, ApprovalRisk, ApprovalReplyMetadata, SessionRule } from './approval-types.js';
+import type { ApprovalRequestCategory, ApprovalRequestDetail, ApprovalRequestMetadata, ApprovalNativeRequestMetadata, ApprovalRisk } from './approval-types.js';
 import type { CanonUnifiedDiff } from './types.js';
 export declare function generateApprovalId(): string;
 export declare function redactSecrets(text: string, patterns: string[]): string;
@@ -19,8 +19,4 @@ export declare function buildApprovalRequest(approvalId: string, toolName: strin
     text: string;
     metadata: ApprovalRequestMetadata;
 };
-export declare function buildApprovalReply(approvalId: string, decision: 'allow' | 'deny', sessionRule?: SessionRule): {
-    text: string;
-    metadata: ApprovalReplyMetadata;
-};
 export declare function buildApprovalOutcome(approvalId: string, toolName: string, toolSummary: string, decision: 'allow' | 'deny', reason: 'replied' | 'timeout' | 'session-rule'): string;

package/dist/internal/core/approval-types.d.ts

@@ -1,4 +1,4 @@
-import { type VerbNativeMetadata } from '../backend-contracts/index.js';
+import type { VerbNativeMetadata } from '../backend-contracts/index.js';
 import type { CanonUnifiedDiff } from './types.js';
 export interface ApprovalRequestMetadata {
     type: 'approval_request';
@@ -71,4 +71,3 @@ export interface ApprovalConfig {
 export declare const DEFAULT_APPROVAL_CONFIG: ApprovalConfig;
 export declare function parseSessionRule(value: unknown): SessionRule | null;
 export declare function parseApprovalReplyMetadata(value: unknown): ApprovalReplyMetadata | null;
-export declare function parseApprovalRequestMetadata(value: unknown): ApprovalRequestMetadata | null;