@securecoms/agent-bridge 0.20.0 → 0.23.0

package/dist/reply-receipts.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Content-free proof that an attached runtime published a reply for a specific
+ * inbound message.
+ *
+ * The ledger is process-local, bearer-gated by the HTTP surface, short-lived,
+ * and bounded. It stores identifiers and timestamps only: never prompt or
+ * reply plaintext. A receipt is recorded only after BridgeAgent.send()
+ * succeeds, so a caller cannot turn a model result that failed to publish into
+ * a healthy synthetic verdict.
+ */
+export interface RuntimeReplyReceipt {
+    in_reply_to: string;
+    reply_message_id: string;
+    channel_id: string;
+    replied_at: number;
+}
+export declare class RuntimeReplyReceiptLedger {
+    private readonly receipts;
+    private readonly ttlMs;
+    private readonly capacity;
+    private readonly now;
+    constructor(opts?: {
+        ttlMs?: number;
+        capacity?: number;
+        now?: () => number;
+    });
+    record(inReplyTo: string, channelId: string, replyMessageId: string): RuntimeReplyReceipt;
+    get(inReplyTo: string): RuntimeReplyReceipt | null;
+    private prune;
+}

package/dist/service/runtime-config-dir.d.ts

@@ -34,8 +34,42 @@ export interface LocalReport {
     persona: Record<string, string>;
     has_search_key: boolean;
     has_llm_key: boolean;
+    legacy_memory: LegacyMemoryReport[];
+}
+export type LegacyMemoryKind = "global-memory" | "conversation-history" | "captured-memory";
+export declare const LEGACY_MEMORY_FACT_MAX_BYTES = 1024;
+export declare const LEGACY_MEMORY_FACT_DECISION_MAX = 500;
+export interface LegacyMemoryReport {
+    id: string;
+    kind: LegacyMemoryKind;
+    channel_id?: string;
+    content: string | null;
+    bytes: number;
+    exportable: boolean;
+}
+export interface LegacyMemoryFactDecision {
+    source_id: string;
+    fact_hash: string;
+    action: "assign" | "delete";
+    channel_id?: string;
 }
 export declare function readLocalReport(home: string, identityId: string): LocalReport | null;
+/** Delete only sources whose opaque id still matches the current regular-file
+ * bytes in the runtime-owned local report. A stale or tampered action deletes
+ * nothing and will be retried against the next report. */
+export declare function deleteLegacyMemorySources(home: string, identityId: string, ids: string[]): number;
+/**
+ * Apply a COMPLETE owner disposition for a quarantined global-memory source.
+ * Every nonblank line in the exact current source must have exactly one
+ * decision. Assigned facts are recorded first through the caller's protected,
+ * idempotent store; only after every write succeeds is the exact source
+ * revalidated and unlinked. Partial, stale, conflicting, oversized, or
+ * malformed batches are no-ops, so they cannot discard unreviewed data.
+ */
+export declare function applyLegacyMemoryFactDecisions(home: string, identityId: string, rawDecisions: unknown, recordFact: (channelId: string, fact: string, assignmentKey: string) => Promise<void>): Promise<{
+    sourcesDeleted: number;
+    factsAssigned: number;
+}>;
 export declare function readManagedMemory(home: string, identityId: string): string | null;
 /**
  * Remove exactly the named lines. Line-level, never a whole-file replace: the

package/dist/service-log.d.ts

@@ -0,0 +1,7 @@
+export type ServiceLogLevel = "debug" | "info" | "warn" | "error";
+export type ServiceLogFields = Readonly<Record<string, number | boolean>>;
+export type ServiceLog = (level: ServiceLogLevel, event: string, fields?: ServiceLogFields, error?: unknown) => void;
+/** Reduce a thrown value without reading its message, stack, or string form. */
+export declare function errorClass(error: unknown): string;
+export declare function formatServiceLog(level: ServiceLogLevel, event: string, fields?: ServiceLogFields, error?: unknown): string;
+export declare function writeServiceLog(level: ServiceLogLevel, event: string, fields?: ServiceLogFields, error?: unknown): void;

package/dist/summarize.d.ts

@@ -1,3 +1,4 @@
+import type { ServiceLog } from "./service-log.js";
 export declare const SUMMARY_PROMPT: string;
 export interface WireTranscriptTurn {
     t: number;
@@ -29,7 +30,7 @@ export interface SummarizeRequest {
     requestedBy: string;
     transcript: WireTranscript;
 }
-export declare function parseSummarizeBody(parsed: unknown, selfIdentityId: string, log?: (message: string) => void): SummarizeRequest | null;
+export declare function parseSummarizeBody(parsed: unknown, selfIdentityId: string, log?: ServiceLog): SummarizeRequest | null;
 export declare function transcriptToPrompt(transcript: WireTranscript): string;
 export declare function parseSummaryOutput(text: string): {
     paragraph: string;
@@ -50,5 +51,5 @@ export declare function runSummarize(opts: {
     }) => Promise<string>;
     timeoutMs?: number;
     now?: () => Date;
-    log: (message: string) => void;
+    log: ServiceLog;
 }): Promise<Record<string, unknown> | null>;

package/dist/version.d.ts

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

package/dist/ws-server.d.ts

@@ -9,15 +9,26 @@
  *
  * Protocol (all frames are JSON text):
  *   Daemon → agent:
- *     { "type":"message", channel_id, message_id, sender_id, text, ts }  // inbound, decrypted
+ *     { "type":"message", channel_id, message_id, sender_id, text, ts,
+ *       authorization:{version,audience,sender_membership,tool_grants} } // inbound, decrypted
  *     { "type":"sent", message_id }                                      // ack of a send
  *     { "type":"ok" }                                                    // ack of a status report
  *     { "type":"error", error, message, detail? }   // canonical codes (see errors.ts):
- *                                                    // channel_pending | invalid_request
+ *                                                    // channel_pending | rate_limited |
+ *                                                    // invalid_request | agent_paused |
+ *                                                    // send_forbidden (the last two are
+ *                                                    // TERMINAL: the in_reply_to message
+ *                                                    // is acked by the daemon, no retry)
  *   Agent → daemon:
- *     { "type":"send", channel_id, text?, a2a?, idempotency_key? }   // exactly one of text | a2a
+ *     { "type":"send", channel_id, text?, a2a?, idempotency_key?,
+ *       in_reply_to? }   // exactly one of text | a2a; correlation is metadata-only
  *     { "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
+ *                                    // failed — requeued behind a backoff; the
+ *                                    // socket and other channels' turns stay up
+ *     { "type":"hello", features? }  // → { "type":"hello", features:["nack"] }; a
+ *                                    // runtime nacks only after seeing "nack" here
  *     { "type":"action_begin", channel_id }                                   // → { "type":"action_begun", run_id }
  *     { "type":"action_start", run_id, node_type, title, parent_id? }         // → { "type":"action_started", node_id }
  *     { "type":"action_update", run_id, node_id, status?, detail? }           // → { "type":"ok" }
@@ -29,6 +40,22 @@
  * 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).
  *
+ * Bounded work (Phase 3):
+ *   - F2 ordering: at most ONE message per channel is in flight on a socket;
+ *     the next message for that channel is sent only after the previous one is
+ *     acked (or retired). A backlog replays in order instead of flooding the
+ *     runtime, which used to answer the overflow with a "busy" reply and ack it.
+ *   - F1 attempt cap: every delivery is counted durably; a message that
+ *     reaches the cap is dead-lettered (content-free log + ack + one
+ *     content-free notice to the channel per hour) rather than redelivered
+ *     forever, and a channel where the agent is paused is not delivered at
+ *     all (no model call).
+ *   - Final-wave I1: a FAILED delivery (a `nack`, or the socket closing with
+ *     it in flight — older runtimes close on any failed turn) is requeued
+ *     behind a 2^attempts × 5 s backoff. A nack fails only its own message.
+ *     Messages never handed over (mid-flush close, a failed frame write) go
+ *     back without that penalty.
+ *
  * Single consumer: the daemon serves one agent per process. A new `/v1/ws`
  * connection replaces the prior one (newest wins, mirroring the SSE path); the
  * replaced socket's un-acked in-flight messages are re-buffered.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@securecoms/agent-bridge",
-  "version": "0.20.0",
+  "version": "0.23.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -49,6 +49,6 @@
     "@types/ws": "^8.18.1",
     "esbuild": "0.24.0",
     "typescript": "^5.4.0",
-    "vitest": "^2.0.0"
+    "vitest": "^3.2.6"
   }
 }