@securecoms/agent-bridge 0.21.0 → 0.23.0

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.21.0";
+export declare const BRIDGE_VERSION = "0.23.0";

package/dist/ws-server.d.ts

@@ -14,12 +14,21 @@
  *     { "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?,
  *       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" }
@@ -31,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.21.0",
+  "version": "0.23.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",