@securecoms/agent-bridge 0.23.0 → 0.24.0

package/dist/reply-intent.d.ts

@@ -0,0 +1,68 @@
+/** The body of one reply part, as the intent stores it (sealed at rest). */
+export type ReplyBody = {
+    kind: "text";
+    text: string;
+} | {
+    kind: "a2a";
+    a2a: {
+        a2a_version: string;
+        kind: "message" | "task" | "artifact";
+        object: Record<string, unknown>;
+    };
+};
+/** Where an intent lives: its scope (what it answers) and its part within it. */
+export interface ReplyIntentKey {
+    scope: string;
+    part: string;
+    inReplyTo: string | null;
+}
+/** Longest idempotency_key accepted (mirrors the in_reply_to bound). */
+export declare const MAX_IDEMPOTENCY_KEY_LENGTH = 200;
+/** The HMAC key for reply ids and body MACs, derived from the identity seed. */
+export declare function deriveReplyIdKey(identitySeed: Uint8Array): Buffer;
+/**
+ * The first 16 bytes of `digest` as an RFC 4122-shaped UUID (version nibble 4,
+ * variant 10). The backend parses message_id with `uuid.UUID()` and the
+ * envelope schema only requires `format: uuid`; this is the encoding the voice
+ * fast path's `fastReplyId` already ships with.
+ */
+export declare function uuidFromDigest(digest: Uint8Array): string;
+/**
+ * The deterministic message_id of one reply part. JSON array encoding keeps the
+ * input injective (no separator can be smuggled through a free-text key).
+ */
+export declare function replyMessageId(key: Uint8Array, identityId: string, channelId: string, intent: Pick<ReplyIntentKey, "scope" | "part">): string;
+/** Canonical bytes of a reply body (what is sealed and what is MACed). */
+export declare function encodeReplyBody(body: ReplyBody): Uint8Array;
+export declare function decodeReplyBody(bytes: Uint8Array): ReplyBody;
+/**
+ * Keyed MAC binding a body to its reply id and channel. Compares retries
+ * without storing a plain digest, and (PR #716 review LOW-6) makes a body moved
+ * to another row, or a row whose channel was edited, fail verification.
+ */
+export declare function replyBodyMac(key: Uint8Array, replyId: string, channelId: string, body: Uint8Array): string;
+/** The ordinal of an unkeyed reply part (`p:<n>`), or null for a keyed part. */
+export declare function partOrdinal(part: string): number | null;
+/**
+ * The intent key for a send. `in_reply_to` wins the scope; an explicit
+ * idempotency_key names the part (else the per-delivery ordinal does). An
+ * idempotency_key alone is its own scope with a single part.
+ */
+export declare function replyIntentKey(opts: {
+    inReplyTo?: string;
+    idempotencyKey?: string;
+    ordinal: () => number;
+}): ReplyIntentKey | null;
+/** A caller reused an explicit idempotency_key for a different body. */
+export declare class IdempotencyConflictError extends Error {
+    constructor();
+}
+/**
+ * PR #716 review LOW-6: a stored reply intent failed verification (its id does
+ * not derive from its own identity, channel, scope and part, its body does not
+ * match its MAC, or its cached envelope names another id or channel). It is
+ * dropped and never published.
+ */
+export declare class ReplyIntentIntegrityError extends Error {
+    constructor();
+}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const BRIDGE_VERSION = "0.23.0";
+export declare const BRIDGE_VERSION = "0.24.0";

package/dist/voice/fast-client.d.ts

@@ -1,13 +1,23 @@
 import type { FastPathConfig } from "./persona";
 import type { ChatMessage } from "./fast-prompt";
+/**
+ * SEC-06 (#12): the response body cap. A fast completion is at most 400
+ * tokens (a few KB of JSON), and the backend proxy enforces the same 64 KiB.
+ */
+export declare const FAST_LLM_MAX_RESPONSE_BYTES: number;
 export declare class FastLlmError extends Error {
-    readonly kind: "timeout" | "http" | "shape" | "network";
-    constructor(message: string, kind: "timeout" | "http" | "shape" | "network");
+    readonly kind: "timeout" | "http" | "shape" | "network" | "size";
+    constructor(message: string, kind: "timeout" | "http" | "shape" | "network" | "size");
 }
 export declare class FastLlmClient {
     private readonly cfg;
     private readonly fetchImpl;
     private readonly key;
     constructor(cfg: FastPathConfig, fetchImpl: typeof fetch);
+    /**
+     * One deadline (`cfg.timeoutMs`) covers the whole call: connect, headers
+     * AND the body. The timer stays armed until the body is read, so a peer that
+     * sends headers and then stalls or trickles cannot hold the voice turn.
+     */
     complete(messages: ChatMessage[]): Promise<string>;
 }

package/dist/ws-server.d.ts

@@ -16,12 +16,19 @@
  *     { "type":"error", error, message, detail? }   // canonical codes (see errors.ts):
  *                                                    // channel_pending | rate_limited |
  *                                                    // invalid_request | agent_paused |
- *                                                    // send_forbidden (the last two are
+ *                                                    // send_forbidden (those two are
  *                                                    // TERMINAL: the in_reply_to message
- *                                                    // is acked by the daemon, no retry)
+ *                                                    // is acked by the daemon, no retry) |
+ *                                                    // group_superseded (NOT terminal:
+ *                                                    // the reply is republished after
+ *                                                    // the agent rejoins)
  *   Agent → daemon:
  *     { "type":"send", channel_id, text?, a2a?, idempotency_key?,
- *       in_reply_to? }   // exactly one of text | a2a; correlation is metadata-only
+ *       in_reply_to? }   // exactly one of text | a2a. SEC-06 #18: in_reply_to
+ *                        // and/or idempotency_key make the send idempotent — a
+ *                        // deterministic keyed message_id and a durable reply
+ *                        // intent written before the publish, so a retry or a
+ *                        // redelivery republishes the SAME reply
  *     { "type":"status", channel_id, state, detail? }
  *     { "type":"ack", message_id }   // confirms a delivered `message` was consumed
  *     { "type":"nack", message_id, reason? }  // final-wave I1(b): THIS message's turn
@@ -38,7 +45,9 @@
  * Inbound delivery is at-least-once. A delivered `message` is held in-flight
  * until the agent sends a matching `ack`; if the socket drops first, the frame
  * is re-buffered and redelivered to the next consumer. The agent dedups by
- * message_id (a fresh UUID minted per send; server-side dedup is on replay_nonce).
+ * message_id. SEC-06 #18: a redelivered message whose reply already has a
+ * durable intent is NOT handed to the agent again; the daemon republishes that
+ * reply itself (same message_id), so the model does not run twice.
  *
  * Bounded work (Phase 3):
  *   - F2 ordering: at most ONE message per channel is in flight on a socket;

package/package.json

@@ -1,7 +1,10 @@
 {
   "name": "@securecoms/agent-bridge",
-  "version": "0.23.0",
+  "version": "0.24.0",
   "type": "module",
+  "engines": {
+    "node": ">=22.5.0"
+  },
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {