@securecoms/agent-bridge 0.11.2 → 0.15.0

package/dist/bridge-agent.d.ts

@@ -27,9 +27,13 @@ export type ChannelObservation = {
     last_decrypt_at: number | null;
     observed_at: number;
 };
+import { type OwnerAuthorityStore, type OwnerPin } from "@agentvault/connect-clients-core";
 import type { BridgeConfig } from "./config.js";
 import { LatencyRecorder } from "./latency.js";
 import type { AttachmentMeta } from "./attachments.js";
+import { type ChatMessage } from "./voice/fast-prompt.js";
+import { VOICE_CALL_START_MARKER } from "./voice/prompt-compiler.js";
+import { type VaultListNode } from "./vault.js";
 import type { AgentActionNodeType, AgentActionNodeStatus, AgentActionNodeDetail } from "@agentvault/connect-core";
 export interface BridgeMessage {
     channel_id: string;
@@ -56,7 +60,86 @@ export interface BridgeMessage {
      * Undefined for plain `text` messages.
      */
     attachments?: AttachmentMeta[];
+    /**
+     * Task 4 (voice-mode carrier): true when the InboxEntry that produced this
+     * buffered message had `voiceMode` set by the server (the agent device's
+     * row for a live 2-member agent call). This is a metadata flag ONLY — it
+     * never drives playback or any connect-web behavior. Undefined/false for
+     * every ordinary text turn.
+     */
+    voice?: boolean;
+    /**
+     * Task 4: compiled-in reply guidance selected by `voice`, exposed here at
+     * the buffer-drain seam so the connector handing context to the agent host
+     * can surface it. Set ONLY when `voice` is true; never transmitted over the
+     * wire — the constant lives in this process, selected by the server-set
+     * flag alone.
+     */
+    guidance?: string;
+    /**
+     * Task 2 (I2 safety, per-speaker attribution): set ONLY when the decrypted
+     * body parsed with `relay: true` and both `speaker_identity_id` and
+     * `speaker_display_name` as strings (the exact shape `sendTurn` in
+     * connect-room-relay stamps on a relayed human turn — see turns.ts:71-78).
+     * This is DATA describing who spoke; it is never merged into `guidance` or
+     * any other instruction text, so one speaker's identity can never ride
+     * into another agent's context as an instruction.
+     */
+    speaker?: {
+        identityId: string;
+        displayName: string;
+    };
 }
+/**
+ * Task 4 (voice-mode carrier): the one-sentence reply guidance compiled in
+ * for voice-flagged turns. Selected by `InboxEntry.voiceMode` in the entry
+ * loop below — never transmitted, never a playback trigger.
+ */
+export declare const VOICE_MODE_GUIDANCE = "Reply immediately and conversationally, one short sentence per message; never bundle multiple points into one message.";
+/**
+ * Task 2 (room voice guidance): compiled reply guidance for a voice-flagged
+ * turn in a GROUP call (bridge's freshMeta says `is_dm === false`), used
+ * INSTEAD of VOICE_MODE_GUIDANCE. Two static variants — chosen only by the
+ * entry's SERVER-set `voiceDefaultResponder` flag (never by anything in the
+ * message body; see the entry loop's attribution parsing, which reads
+ * speaker fields only and never a body-supplied responder/voiceMode claim).
+ * No string interpolation of peer data — these are fixed, compiled-in
+ * sentences.
+ */
+/**
+ * Task 4 (self-hosted fast voice): appended to the runtime-facing guidance
+ * (never sent anywhere) ONLY on turns where the fast path already fired a
+ * spoken acknowledgement ahead of the full agent reply. Compiled-in constant,
+ * concatenated only with the other compiled-in guidance strings above — never
+ * with peer/body data (I2).
+ */
+/** Posted by the web client once the call row confirms (CallPanel GREETING_MARKER). */
+export { VOICE_CALL_START_MARKER };
+/**
+ * The fast path's "user turn" for a call-start marker. The caller's first
+ * name (when the roster knows it) rides in the Speaker line of the prompt,
+ * so this only has to say what a good greeting is. Data region label keeps
+ * it I2-safe like every other injected line.
+ *
+ * Delegates to `greetingTurnFor` with the default voice settings (whose
+ * `greetingStyle` is "continue"), so the wording stays byte-equal to the
+ * pre-Task-6 behaviour for callers/tests that only know a bare caller name.
+ */
+export declare function greetingTurn(callerName?: string): string;
+export declare const FAST_PATH_SPOKEN_GUIDANCE = "A one-sentence spoken acknowledgement has already been sent for this turn. Reply only with information it did not contain, in one or two short sentences; if there is nothing to add, send nothing.";
+export declare const ROOM_VOICE_GUIDANCE_MENTION_ONLY = "You are in a group voice room. Reply ONLY when a message @mentions your display name. Keep replies to one short sentence. When you should not reply, send nothing.";
+export declare const ROOM_VOICE_GUIDANCE_WITH_RESPONDER = "You are in a group voice room. Reply ONLY when a message @mentions your display name, or when you are the designated default responder and no other agent is mentioned. Keep replies to one short sentence. When you should not reply, send nothing.";
+/**
+ * Task 2: selects the compiled voice guidance for a buffered entry.
+ * `isDm` is `freshMeta(channelId)?.is_dm`. `undefined` (unknown channel
+ * meta — e.g. a cold-start miss) and `true` both take the conservative DM
+ * branch: VOICE_MODE_GUIDANCE is one short sentence, harmless to attach even
+ * if the channel later turns out to be a group, whereas misclassifying a DM
+ * as a room would wrongly suppress the agent's replies. Only an explicit
+ * `is_dm === false` selects a room variant, gated on the entry's SERVER-set
+ * `voiceDefaultResponder` (never a body-supplied claim).
+ */
+export declare function selectVoiceGuidance(isDm: boolean | undefined, voiceDefaultResponder: boolean | undefined): string;
 export interface BridgeAgentDeps {
     transport?: any;
     backend?: any;
@@ -102,6 +185,22 @@ export interface BridgeAgentDeps {
      * timer delays.
      */
     rng?: () => number;
+    /**
+     * Task 4 (self-hosted fast voice): test seam for the fast-path LLM client.
+     * Defaults to `new FastLlmClient(cfg.voice.fastPath, fetchImpl)` when
+     * `cfg.voice?.fastPath.enabled` is true; left undefined (fast path off)
+     * otherwise. Overriding this in a test bypasses real HTTP.
+     */
+    fastLlm?: {
+        complete(messages: ChatMessage[]): Promise<string>;
+    };
+    /**
+     * B7 (FileSafe vault): persistence for the vault kekset's owner-pin TOFU
+     * state. Defaults to a {@link FileOwnerAuthorityStore} at
+     * `join(dirname(cfg.storePath), "vault-owner-pins.json")`. Override in
+     * tests to avoid real file IO / assert pin persistence directly.
+     */
+    vaultOwnerStore?: OwnerAuthorityStore;
 }
 /** Default inbound-buffer cap (messages) when deps.maxBuffer is unset. */
 export declare const DEFAULT_MAX_BUFFER = 1000;
@@ -143,6 +242,32 @@ export declare class InvalidMessageIdError extends Error {
     readonly messageId: string;
     constructor(messageId: string);
 }
+/**
+ * Deterministic message id for the voice fast-path reply to inbound turn
+ * `messageId`: SHA-256 of `fast:<messageId>`, first 16 bytes, RFC 4122
+ * version/variant nibbles set. Live finding 2026-09-06: the previous
+ * `fast-<messageId>` string failed `resolveMessageId` ("message_id must be a
+ * UUID") on every turn, so the fast path never sent once. Same input → same
+ * UUID, so the idempotency argument in `runFastPath`'s doc still holds.
+ */
+export declare function fastReplyId(messageId: string): string;
+/**
+ * B7 (FileSafe vault): a file-backed {@link OwnerAuthorityStore} for the
+ * daemon's owner-pin TOFU state (mirrors B4b's browser-side store, which
+ * persists to IndexedDB — the daemon has no IndexedDB, so this persists one
+ * JSON blob alongside the SQLite MLS store). This is the security-load-
+ * bearing half of the kekset open (kekset.ts's `openKekset` pins the header
+ * signer to `pinnedOwnerCred`; THIS is where that pin survives restarts) —
+ * without persistence, every restart would TOFU-trust whatever "owner" the
+ * server presents on the next open, defeating the pin entirely.
+ */
+export declare class FileOwnerAuthorityStore implements OwnerAuthorityStore {
+    private readonly path;
+    constructor(path: string);
+    private readAll;
+    load(enclaveId: string): Promise<OwnerPin | null>;
+    save(enclaveId: string, pin: OwnerPin): Promise<void>;
+}
 /**
  * Per-room agent pause toggle (daemon side): the backend rejected a publish
  * with `403 {detail:{error:"agent_paused"}}`, which the SDK's `RestTransport`
@@ -274,6 +399,46 @@ export declare class BridgeAgent {
      * counter is incremented. Surfaced on health()/metrics().
      */
     private failedAttachments;
+    /**
+     * Task 4 (self-hosted fast voice): test/deploy seam for the fast-path LLM
+     * client. Undefined whenever `cfg.voice?.fastPath.enabled` is not true —
+     * the text-branch push checks this field (not cfg) so a disabled/missing
+     * voice config is a single falsy check.
+     */
+    private fastLlm?;
+    /** Plan 2026-09-06 (agent voice settings): true when the constructor deps
+     *  injected a fastLlm (tests, or a real deploy seam) — refetchVoiceSettings
+     *  must never overwrite an injected client with one built from the backend
+     *  row's proxy config. */
+    private readonly injectedFastLlm;
+    /** Controller ruling (PR B review, fix round 1): the credential's ORIGINAL
+     *  `voice` block, captured once at construction before `cfg.voice` is ever
+     *  mutated by a refetch. `GET .../voice-settings` returning `version: 0`
+     *  means "no row configured for this agent" — a hand-tuned file persona
+     *  (e.g. Cortina011) must win over that all-defaults row rather than being
+     *  blanked by it. Undefined when the credential had no `voice` block. */
+    private readonly fileVoiceConfig?;
+    /** Plan 2026-09-06: the loaded voice settings row (backend or none). Undefined
+     *  until a successful `refetchVoiceSettings()` — the file `voice.persona`
+     *  block (if any) is used for the prompt/greeting until then. */
+    private voiceSettings;
+    /** Plan 2026-09-06: version of the last successfully loaded backend row, or
+     *  null when no backend row has ever loaded (file or none source). Surfaced
+     *  on health(). */
+    private voiceSettingsVersion;
+    /** Plan 2026-09-06: where the active voice config came from. "backend" wins
+     *  over "file" the moment a fetch succeeds; a later failed refetch keeps the
+     *  last good "backend" row rather than falling back. Surfaced on health(). */
+    private voiceSettingsSource;
+    /** Task 4: messageIds already sent through the fast path (capped FIFO, so a redelivered/duplicate entry never double-sends). */
+    private readonly fastPathSeen;
+    private static readonly FAST_PATH_SEEN_CAP;
+    /** Cumulative count of fast-path replies actually sent (surfaced on health()/metrics()). */
+    private fastPathSent;
+    /** Cumulative count of fast-path attempts that errored (LLM timeout/http/network/shape, or send failure) — surfaced on health()/metrics(). */
+    private fastPathFailed;
+    /** Cumulative count of fast-path turns skipped in a room channel because the shared send-floor bucket lacked headroom for both the ack and the runtime's own reply (controller ruling) — surfaced on health()/metrics(). */
+    private fastPathSkipped;
     /**
      * Task 8: count of live AUTHENTICATED /v1/ws sessions, so a later `status`
      * verb can tell "bridge process up" (the app's green dot, which only
@@ -444,7 +609,39 @@ export declare class BridgeAgent {
     private readonly uploadBlobImpl;
     /** Track 5: directory where received attachments are saved. */
     private readonly attachmentsDirImpl;
+    /** B7: persistence for the vault kekset's owner-pin TOFU state. */
+    private readonly vaultOwnerStoreImpl;
+    /** B7: last-seen kekset generation per enclave, enforced monotonic across
+     *  calls for the daemon's lifetime (mirrors useVault's `currentGenRef` —
+     *  openKekset rejects a generation <= this, catching a server that tries
+     *  to roll a joiner back to a superseded kekset). */
+    private readonly vaultLastSeenGeneration;
     constructor(cfg: BridgeConfig, deps?: BridgeAgentDeps);
+    /**
+     * Plan 2026-09-06 (agent voice settings, Task 7): pull this agent's voice
+     * settings row from the backend and hot-swap the fast-path prompt/config in
+     * place. Backend settings win over the credential's `voice` file block the
+     * moment a REAL row loads (spec §5 fallback order backend -> file -> none);
+     * on a failed fetch AFTER a previously successful one, keep the last good
+     * row rather than falling back — only the source's own health fields move.
+     *
+     * Controller ruling (PR B review, fix round 1): `version: 0` means "no row
+     * configured for this agent" — the endpoint returns the all-defaults shape
+     * (blank persona) rather than 404. Installing this on a daemon whose
+     * credential carries a hand-tuned `voice` file block (e.g. Cortina011) must
+     * NOT blank that persona. So a `version: 0` response with a file block
+     * present keeps the file persona/displayName/quirks, adopts only the
+     * proxy's `fastPath` (so the SecureComs proxy is still used for the LLM
+     * call), and reports source "file" / version 0 — exactly the file-only
+     * state, just routed through the proxy. Only `version >= 1` (a REAL row)
+     * makes the backend persona win. A `version: 0` response with NO file block
+     * has nothing to prefer, so it behaves as before: the (empty-persona)
+     * defaults row via the proxy, source "backend".
+     *
+     * Safe to call any time (start(), or the receive pump on a
+     * `voice_settings_changed` ping); never throws.
+     */
+    refetchVoiceSettings(): Promise<void>;
     /**
      * Enforce the inbound-buffer cap with a DROP-OLDEST policy.
      *
@@ -650,12 +847,105 @@ export declare class BridgeAgent {
         message_id: string;
         status: "sent";
     }>;
+    private vaultRoot;
+    private vaultAuthHeaders;
+    /** M6 (Task 11): idempotent get-or-create resolve of the enclave's hidden
+     *  vault channel id — used as the fallback when a caller omits
+     *  vaultChannelId. Mirrors connect-web's filesafe-api.ts resolveVaultChannel
+     *  exactly (same endpoint, same caller_identity_id convention). */
+    private vaultResolveChannel;
+    /** Resolves the effective vault channel id: the caller-supplied value when
+     *  present (unchanged behavior), else the M6 resolver (best-effort). */
+    private resolveVaultChannelId;
+    private vaultCid;
+    private vaultGetKekset;
+    private vaultCreateNode;
+    private vaultCommitNode;
+    /** Multipart POST the ciphertext to the presigned POST target — mirrors
+     *  useVault.uploadFile's FormData construction (B6) exactly. */
+    private vaultPutBlob;
+    private vaultGetNodeForDownload;
+    private vaultGetBlob;
+    private vaultListNodesRest;
+    private vaultDeleteNodeRest;
+    /**
+     * Join the vault channel (if not already), resolve its live epoch, derive
+     * the MLS exporter secret at that epoch, and open the sealed kekset —
+     * verifying the header signer against the PERSISTED owner pin (TOFU-seeded
+     * on first open) and rejecting a generation rollback. Returns a
+     * generation→KEK lookup plus the CURRENT generation, exactly the shape
+     * vault.ts's `*Deps.exporterKekForGeneration`/`currentGeneration` want.
+     *
+     * Every kekset-open-time failure (signer not the pinned owner, bad
+     * signature, generation <= last seen) is re-thrown as
+     * {@link VaultIntegrityError} — same taxonomy as vault.ts's read-time
+     * checks, so the HTTP boundary maps ALL vault trust failures to one code.
+     */
+    private getVaultSession;
+    /** Read `path` off local disk, encrypt + wrap its DEK under the vault's
+     *  current KEK generation, and create+upload+commit it as a new vault
+     *  file node named `name` (which may differ from `path`'s basename). */
+    vaultWrite(enclaveId: string, vaultChannelId: string | null | undefined, path: string, name: string): Promise<{
+        node_id: string;
+    }>;
+    /** Download + verify + decrypt a vault file node. Returns the plaintext
+     *  base64-encoded (the loopback boundary is JSON-only, mirroring how
+     *  useVault.downloadFile returns `{name, bytes}` in-memory — here the
+     *  caller already supplies nodeId so we return bytes, not a re-resolved
+     *  name the bridge has no cached listing to look up). */
+    vaultRead(enclaveId: string, vaultChannelId: string | null | undefined, nodeId: string): Promise<{
+        bytes_b64: string;
+    }>;
+    /** List + decrypt names for the vault nodes under `parentId` (null = root). */
+    vaultList(enclaveId: string, vaultChannelId: string | null | undefined, parentId: string | null): Promise<{
+        nodes: VaultListNode[];
+    }>;
+    /** Delete a vault node. No crypto involved — the server drops an opaque
+     *  row — but still requires the caller to have joined the vault channel
+     *  (consistency with write/read/list; also surfaces channel_pending the
+     *  same way if the vault channel Welcome hasn't landed yet). */
+    vaultDelete(enclaveId: string, vaultChannelId: string | null | undefined, nodeId: string): Promise<{
+        deleted: string;
+        bytes_freed: number;
+    }>;
     /** Task 3: delegates to the configured MemoryProvider (SecureComsLocal | Null). */
     recordMemory(input: import("@agentvault/connect-mls-store").MemoryRecordInput): Promise<{
         seq: number;
         deduped: boolean;
     }>;
     memoryContext(conversationId: string, limit?: number): Promise<import("@agentvault/connect-mls-store").MemoryContextResult>;
+    /**
+     * Task 4 (self-hosted fast voice): instant persona-voiced acknowledgement
+     * for a live voice turn, sent ahead of the full agent reply — fired from
+     * the ingestOnce text branch as `void this.runFastPath(...)`.
+     *
+     * MUST NEVER throw into ingestOnce: every failure path (memory lookup, the
+     * LLM call, normalization, or the send itself) is caught internally, counted
+     * in `fastPathFailed`, and logged at most once — WITHOUT the turn text or
+     * the model's reply (only the channel/message id, never conversation
+     * content, reaches stderr).
+     *
+     * Dedupe: `fastPathSeen` is keyed by messageId so a redelivered/duplicate
+     * InboxEntry (e.g. after an ack race) never fires the fast LLM — and never
+     * double-sends — twice for the same turn. The `fastReplyId(messageId)` send
+     * id is itself also deterministic, so even a duplicate call that slipped past the
+     * in-memory dedupe (e.g. a process restart) resolves to the same envelope
+     * message id rather than a second spoken reply.
+     *
+     * Room token reservation (controller ruling): `send()` charges the shared
+     * `room:<channelId>` bucket (see `enforceRateFloor`) for any non-DM
+     * channel. A fast-path ack spent from the SAME bucket could starve the
+     * runtime's own reply moments later, so the CALL SITE (the ingestOnce text
+     * branch) only calls `runFastPath` at all when the bucket has at least 2
+     * tokens available — one earmarked for this ack, one reserved for the
+     * runtime's reply — and, critically, decides the buffered turn's guidance
+     * text using that SAME decision. That decision must not be re-made (and
+     * cannot silently diverge) here: `runFastPath` itself no longer touches the
+     * room bucket at all, it only handles messageId dedupe and the LLM/send
+     * mechanics. See the call site's `fastPathRoomBlocked` for the skip +
+     * `fastPathSkipped` counting.
+     */
+    private runFastPath;
     /**
      * List channels in one enclave (default: the daemon's own home enclave).
      * Task 3: called per-*known* enclave by refreshChannelMeta so a
@@ -836,6 +1126,33 @@ export declare class BridgeAgent {
      * (settled, always exactly once).
      */
     private sendActionFrame;
+    /**
+     * Task 13: the daemon's half of the `summarize` request (spec §3.5/§4.5).
+     * Runs bounded (runSummarize's 60 s internal timeout) and, on success, sends
+     * exactly one `call_summary`. On timeout or failure it posts nothing — the
+     * client's own wait already renders "Summary unavailable" — so there is
+     * nothing to catch here besides the send itself.
+     */
+    private handleSummarize;
+    /**
+     * A thin adapter over the daemon's one-shot completion seam. Voice-enabled
+     * agents already have `this.fastLlm` (the self-hosted fast-path LLM); reuse
+     * it here with the fixed summary prompt as a single user message. An agent
+     * with no fast-path configured has no one-shot completion route at all in
+     * this daemon (the full runtime only ever answers via the buffered
+     * `send`/`drain` seam, which `summarize` deliberately bypasses — see the
+     * dispatch arm above) — a runtime-backed variant is a follow-up. Per spec
+     * §4.5/§5, a missing runtime is a FAILURE, not a fabricated answer: reject
+     * so `runSummarize` logs and returns null and `handleSummarize` posts
+     * nothing (identical to a genuine timeout from the client's point of view).
+     */
+    private completeForSummary;
+    /** call_summary rides a system_event envelope with a body-level type, the
+     *  same shape sendActionFrame uses for agent_action. */
+    private sendSummary;
+    /** Minimal stderr logger for non-fatal daemon events (mirrors the ad hoc
+     *  `process.stderr.write` calls elsewhere in this file). */
+    private log;
     /**
      * The coalescing throttle (review H4 / Global Constraint: ~1/sec per run).
      * If the run has no dirty nodes, no-op. If the per-run bucket has no token,
@@ -927,6 +1244,20 @@ export declare class BridgeAgent {
         retired_drained: number;
         /** Track 5: cumulative artifact_share messages where download/decrypt/digest failed (fail-soft — acked, no redeliver). */
         failed_attachments: number;
+        /** Task 4 (self-hosted fast voice): cumulative fast-path replies actually sent. */
+        fast_path_sent: number;
+        /** Task 4 (self-hosted fast voice): cumulative fast-path attempts that errored (LLM call, normalization, or send) — fail-soft, never blocks the buffered turn. */
+        fast_path_failed: number;
+        /** Task 4 (self-hosted fast voice): cumulative fast-path turns skipped in a room because the send-floor bucket lacked headroom for both the ack and the runtime's reply. */
+        fast_path_skipped: number;
+        /** Plan 2026-09-06 (agent voice settings): version of the loaded backend
+         *  voice-settings row, or null when no backend row has ever loaded
+         *  (source is "file" or "none"). */
+        voice_settings_version: number | null;
+        /** Plan 2026-09-06: where the active voice config came from — "backend"
+         *  once a fetch has ever succeeded (sticky even if a later refetch
+         *  fails), else "file" (credential's voice block) or "none". */
+        voice_settings_source: "backend" | "file" | "none";
         /** 2026-07-03 latency triage: delivery pings received on the WS stream.
          *  0 while messages flow = push is dead; inbound rides the 25s floor. */
         delivery_pings: number;

package/dist/config.d.ts

@@ -1,3 +1,4 @@
+import { type VoiceConfig } from "./voice/persona.js";
 export interface BridgeConfig {
     apiKey: string;
     identityId: string;
@@ -27,6 +28,8 @@ export interface BridgeConfig {
     memoryWorkspaceDir?: string;
     /** For memoryProvider="openclaw": total facts cap in UTF-16 code units. 0 = facts kill switch (preserved via ?? downstream, never ||). Absent/junk → provider default 8000. */
     memoryFactsCharBudget?: number;
+    /** Optional voice persona + fast-path LLM config (self-hosted fast voice reply). Undefined when the credential has no `voice` block. */
+    voice?: VoiceConfig;
 }
 export declare const REQUIRED: readonly ["api_key", "identity_id", "device_id", "signing_private_key", "enclave_id", "api_base"];
 export declare function loadConfig(opts: {

package/dist/errors.d.ts

@@ -6,7 +6,7 @@
  * WebSocket returns `{type:"error", error, message, detail?}`. A client gets the
  * same `error` code regardless of which transport it used. (A2A §9.5/§10.6 pattern.)
  */
-export type BridgeErrorCode = "unauthorized" | "forbidden_origin" | "not_found" | "invalid_request" | "invalid_json" | "body_too_large" | "channel_pending" | "rate_limited" | "unknown_action_run" | "internal";
+export type BridgeErrorCode = "unauthorized" | "forbidden_origin" | "not_found" | "invalid_request" | "invalid_json" | "body_too_large" | "channel_pending" | "rate_limited" | "unknown_action_run" | "vault_integrity_failed" | "internal";
 export interface BridgeErrorSpec {
     /** HTTP status this code maps to (the WS binding ignores it). */
     http: number;

package/dist/http-server.d.ts

@@ -37,7 +37,7 @@ export declare const memoryRecordSchema: z.ZodEffects<z.ZodObject<{
     role: "agent" | "peer";
     text: string;
     conversation_id: string;
-    modality: "text" | "voice";
+    modality: "voice" | "text";
     message_id?: string | undefined;
     idempotency_key?: string | undefined;
     peer_id?: string | undefined;
@@ -45,7 +45,7 @@ export declare const memoryRecordSchema: z.ZodEffects<z.ZodObject<{
     role: "agent" | "peer";
     text: string;
     conversation_id: string;
-    modality: "text" | "voice";
+    modality: "voice" | "text";
     message_id?: string | undefined;
     idempotency_key?: string | undefined;
     peer_id?: string | undefined;
@@ -53,7 +53,7 @@ export declare const memoryRecordSchema: z.ZodEffects<z.ZodObject<{
     role: "agent" | "peer";
     text: string;
     conversation_id: string;
-    modality: "text" | "voice";
+    modality: "voice" | "text";
     message_id?: string | undefined;
     idempotency_key?: string | undefined;
     peer_id?: string | undefined;
@@ -61,7 +61,7 @@ export declare const memoryRecordSchema: z.ZodEffects<z.ZodObject<{
     role: "agent" | "peer";
     text: string;
     conversation_id: string;
-    modality: "text" | "voice";
+    modality: "voice" | "text";
     message_id?: string | undefined;
     idempotency_key?: string | undefined;
     peer_id?: string | undefined;