@forwardimpact/libbridge 0.1.5 → 0.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forwardimpact/libbridge",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Threaded-channel bridge primitives — relay messages between human channels (GitHub Discussions, Microsoft Teams) and the Kata agent team.",
   "keywords": [
     "bridge",
@@ -41,6 +41,7 @@
   },
   "dependencies": {
     "@forwardimpact/libtype": "^0.1.0",
+    "@forwardimpact/libutil": "^0.1.84",
     "@hono/node-server": "^2.0.4",
     "hono": "^4.12.23"
   },

package/src/callback-handler.js

@@ -1,3 +1,5 @@
+import { createDefaultClock } from "@forwardimpact/libutil/runtime";
+
 import { validateCallbackPayload } from "./callback-payload.js";
 
 /**
@@ -44,6 +46,7 @@ export class CallbackHandlerError extends Error {
  * @param {(meta: object) => string} options.loadDiscussionId
  * @param {(meta: object) => unknown} [options.ackFinishTarget]
  * @param {(ctx: object, payload: object, meta: object) => Promise<void>} options.handleReply
+ * @param {import("@forwardimpact/libutil/runtime").Runtime["clock"]} [options.clock]
  * @returns {(c: object) => Promise<Response>}
  */
 export function createCallbackHandler({
@@ -57,6 +60,7 @@ export function createCallbackHandler({
   loadDiscussionId,
   ackFinishTarget,
   handleReply,
+  clock = createDefaultClock(),
 }) {
   if (!channel) throw new Error("channel is required");
   if (!callbacks) throw new Error("callbacks is required");
@@ -72,20 +76,64 @@ export function createCallbackHandler({
     throw new Error("handleReply is required");
   }
 
+  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: session-aware callback handler branches on kind
   return async (c) => {
-    const prelude = await resolveContext(c, {
-      callbacks,
-      ack,
-      store,
-      channel,
-      logger,
-      loadDiscussionId,
-      ackFinishTarget,
-    });
-    if (prelude.error) return c.json({ error: prelude.error }, prelude.status);
+    let body;
+    try {
+      body = await c.req.json();
+    } catch {
+      return c.json({ error: "Invalid JSON" }, 400);
+    }
+    const payload = validateCallbackPayload(body);
+    if (!payload) return c.json({ error: "Invalid payload" }, 400);
+
+    const token = c.req.param("token");
+    const isTerminal = payload.kind === "terminal";
+    const meta = isTerminal ? callbacks.consume(token) : callbacks.peek(token);
+    if (!meta) {
+      logger.debug?.("callback", "unknown token");
+      return c.json({ error: "Unknown callback token" }, 404);
+    }
+
+    if (isTerminal) {
+      await ack.finish(
+        token,
+        ackFinishTarget ? ackFinishTarget(meta) : undefined,
+      );
+    }
+    if (payload.correlation_id !== meta.correlationId) {
+      return c.json({ error: "Correlation ID mismatch" }, 400);
+    }
+
+    const discussionId = loadDiscussionId(meta);
+    const ctx = await store.loadByChannel(channel, discussionId);
+    if (!ctx) {
+      logger.error?.("callback", "context missing", {
+        discussion_id: discussionId,
+      });
+      return c.json({ error: "Discussion context missing" }, 410);
+    }
+
+    if (
+      !isTerminal &&
+      payload.seq >= 0 &&
+      payload.seq <= (ctx.last_posted_seq ?? -1)
+    ) {
+      return c.json({ ok: true, dedupe: true }, 200);
+    }
+
+    if (!isTerminal) {
+      payload.replies = payload.body
+        ? [{ body: payload.body, agent: payload.agent }]
+        : [];
+      payload.verdict = null;
+    }
+
+    if (isTerminal) {
+      delete ctx.pending_callbacks[token];
+      ctx.active_requester = null;
+    }
 
-    const { token, ctx, meta, payload } = prelude;
-    delete ctx.pending_callbacks[token];
     return runHandleReply(c, {
       ctx,
       meta,
@@ -95,45 +143,16 @@ export function createCallbackHandler({
       logger,
       tracer,
       spanName,
+      clock,
+      postReply() {
+        if (!isTerminal) {
+          ctx.last_posted_seq = payload.seq;
+        }
+      },
     });
   };
 }
 
-async function resolveContext(
-  c,
-  { callbacks, ack, store, channel, logger, loadDiscussionId, ackFinishTarget },
-) {
-  const token = c.req.param("token");
-  const meta = callbacks.consume(token);
-  if (!meta) {
-    logger.debug?.("callback", "unknown token");
-    return { status: 404, error: "Unknown callback token" };
-  }
-  await ack.finish(token, ackFinishTarget ? ackFinishTarget(meta) : undefined);
-
-  let body;
-  try {
-    body = await c.req.json();
-  } catch {
-    return { status: 400, error: "Invalid JSON" };
-  }
-  const payload = validateCallbackPayload(body);
-  if (!payload) return { status: 400, error: "Invalid payload" };
-  if (payload.correlation_id !== meta.correlationId) {
-    return { status: 400, error: "Correlation ID mismatch" };
-  }
-
-  const discussionId = loadDiscussionId(meta);
-  const ctx = await store.loadByChannel(channel, discussionId);
-  if (!ctx) {
-    logger.error?.("callback", "context missing", {
-      discussion_id: discussionId,
-    });
-    return { status: 410, error: "Discussion context missing" };
-  }
-  return { token, ctx, meta, payload };
-}
-
 const STATUS_MESSAGES = {
   400: "Bad request",
   404: "Not found",
@@ -149,7 +168,18 @@ function sanitizeErrorMessage(status) {
 
 async function runHandleReply(
   c,
-  { ctx, meta, payload, handleReply, store, logger, tracer, spanName },
+  {
+    ctx,
+    meta,
+    payload,
+    handleReply,
+    store,
+    logger,
+    tracer,
+    spanName,
+    clock,
+    postReply,
+  },
 ) {
   const span = tracer.startSpan(spanName, {
     kind: "SERVER",
@@ -157,7 +187,8 @@ async function runHandleReply(
   });
   try {
     await handleReply(ctx, payload, meta);
-    ctx.last_active_at = Date.now();
+    if (postReply) postReply();
+    ctx.last_active_at = clock.now();
     await store.add(ctx);
     await store.flush();
     span.addEvent("reply_delivered", { verdict: payload.verdict });

package/src/callback-payload.js

@@ -1,3 +1,5 @@
+import { createDefaultClock } from "@forwardimpact/libutil/runtime";
+
 export const MAX_FIELD_LENGTH = 2000;
 export const MAX_REPLY_COUNT = 50;
 
@@ -11,6 +13,7 @@ export const MAX_REPLY_COUNT = 50;
  * @param {unknown} body
  * @returns {object | null}
  */
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: lenient validator with per-field type checks
 export function validateCallbackPayload(body) {
   if (!body || typeof body !== "object") return null;
   const cid = body.correlation_id;
@@ -37,8 +40,22 @@ export function validateCallbackPayload(body) {
   const trigger = validateTrigger(body.trigger);
   const runUrl = typeof body.run_url === "string" ? body.run_url : undefined;
 
+  const kind = typeof body.kind === "string" ? body.kind : "terminal";
+  const seq = typeof body.seq === "number" ? body.seq : -1;
+  const eventBody =
+    typeof body.body === "string" ? body.body.slice(0, MAX_FIELD_LENGTH) : "";
+  const agent =
+    typeof body.agent === "string" ? body.agent.slice(0, MAX_FIELD_LENGTH) : "";
+  const lastActedSeq =
+    typeof body.last_acted_seq === "number" ? body.last_acted_seq : -1;
+
   return {
     correlation_id: cid,
+    kind,
+    seq,
+    body: eventBody,
+    agent,
+    last_acted_seq: lastActedSeq,
     verdict,
     summary,
     replies,
@@ -105,9 +122,15 @@ export function normalizeBaseUrl(url) {
  * @param {string} args.channel
  * @param {string} args.discussionId
  * @param {object} args.participant
+ * @param {import("@forwardimpact/libutil/runtime").Runtime["clock"]} [args.clock]
  * @returns {object}
  */
-export function newDiscussionContext({ channel, discussionId, participant }) {
+export function newDiscussionContext({
+  channel,
+  discussionId,
+  participant,
+  clock = createDefaultClock(),
+}) {
   return {
     id: `${channel}:${discussionId}`,
     channel,
@@ -118,6 +141,8 @@ export function newDiscussionContext({ channel, discussionId, participant }) {
     lead: "release-engineer",
     pending_callbacks: {},
     dispatches: [],
-    last_active_at: Date.now(),
+    last_active_at: clock.now(),
+    active_requester: null,
+    last_posted_seq: -1,
   };
 }

package/src/callback-registry.js

@@ -1,5 +1,7 @@
 import { randomUUID } from "node:crypto";
 
+import { createDefaultClock } from "@forwardimpact/libutil/runtime";
+
 const DEFAULT_TTL_MS = 2 * 60 * 60 * 1000;
 
 /**
@@ -10,14 +12,17 @@ const DEFAULT_TTL_MS = 2 * 60 * 60 * 1000;
  */
 export class CallbackRegistry {
   #ttlMs;
+  #clock;
   #entries = new Map();
 
   /**
    * @param {object} [options]
    * @param {number} [options.ttlMs] - Time-to-live in ms (default: 2h)
+   * @param {import("@forwardimpact/libutil/runtime").Runtime["clock"]} [options.clock]
    */
-  constructor({ ttlMs = DEFAULT_TTL_MS } = {}) {
+  constructor({ ttlMs = DEFAULT_TTL_MS, clock = createDefaultClock() } = {}) {
     this.#ttlMs = ttlMs;
+    this.#clock = clock;
   }
 
   /** @returns {number} */
@@ -38,7 +43,7 @@ export class CallbackRegistry {
     this.#entries.set(token, {
       correlationId,
       meta,
-      createdAt: Date.now(),
+      createdAt: this.#clock.now(),
     });
     return token;
   }
@@ -75,7 +80,7 @@ export class CallbackRegistry {
    * @param {number} [now]
    * @returns {number} Number of entries evicted
    */
-  sweep(now = Date.now()) {
+  sweep(now = this.#clock.now()) {
     let evicted = 0;
     for (const [token, entry] of this.#entries) {
       if (now - entry.createdAt > this.#ttlMs) {

package/src/dispatch.js

@@ -16,6 +16,7 @@
  * @param {string} params.prompt - The facilitator prompt
  * @param {string} params.callbackUrl - Where the workflow posts the reply
  * @param {string} params.correlationId - UUID linking dispatch → callback
+ * @param {string} [params.inboxUrl] - Long-poll URL for injecting messages into a live run
  * @param {string} [params.discussionId] - For trace linkage in libeval
  * @param {string} [params.resumeContext] - JSON string carried across resumes
  * @returns {Promise<void>}
@@ -28,6 +29,7 @@ export async function dispatchWorkflow({
   prompt,
   callbackUrl,
   correlationId,
+  inboxUrl,
   discussionId,
   resumeContext,
 }) {
@@ -40,6 +42,7 @@ export async function dispatchWorkflow({
     callback_url: callbackUrl,
     correlation_id: correlationId,
   };
+  if (inboxUrl !== undefined) inputs.inbox_url = inboxUrl;
   if (discussionId !== undefined) inputs.discussion_id = discussionId;
   if (resumeContext !== undefined) inputs.resume_context = resumeContext;
 

package/src/dispatcher.js

@@ -1,7 +1,8 @@
 import { randomUUID } from "node:crypto";
 
+import { createDefaultClock } from "@forwardimpact/libutil/runtime";
+
 import { dispatchWorkflow } from "./dispatch.js";
-import { appendHistory } from "./history.js";
 
 /** Dispatch dance: resolve per-user token, register callback, ack, fire workflow, flush. */
 export class Dispatcher {
@@ -12,6 +13,7 @@ export class Dispatcher {
   #workflowFile;
   #githubRepo;
   #tokenResolver;
+  #clock;
 
   /**
    * @param {object} options
@@ -22,6 +24,7 @@ export class Dispatcher {
    * @param {string} options.workflowFile
    * @param {string} options.githubRepo
    * @param {import("./token-resolver.js").TokenResolver} options.tokenResolver
+   * @param {import("@forwardimpact/libutil/runtime").Runtime["clock"]} [options.clock]
    */
   constructor({
     callbacks,
@@ -31,6 +34,7 @@ export class Dispatcher {
     workflowFile,
     githubRepo,
     tokenResolver,
+    clock = createDefaultClock(),
   }) {
     if (!callbacks) throw new Error("callbacks is required");
     if (!ack) throw new Error("ack is required");
@@ -48,6 +52,7 @@ export class Dispatcher {
     this.#workflowFile = workflowFile;
     this.#githubRepo = githubRepo;
     this.#tokenResolver = tokenResolver;
+    this.#clock = clock;
   }
 
   /**
@@ -57,7 +62,6 @@ export class Dispatcher {
    * @param {string} args.requester - Surface user id of the triggering human
    * @param {object} args.callbackMeta - Stored on the callback token
    * @param {unknown} [args.ackTarget] - If omitted, no acknowledgement is started
-   * @param {string} [args.historyText] - Appended to ctx.history as the user turn on success
    * @param {object} [args.workflowInputs] - Extra fields for `dispatchWorkflow`
    * @returns {Promise<{kind: "dispatched", token: string, correlationId: string} | {kind: "link_required", authorizeUrl: string} | {kind: "reauth_required"} | {kind: "transient", error: Error}>}
    */
@@ -67,7 +71,6 @@ export class Dispatcher {
     requester,
     callbackMeta,
     ackTarget,
-    historyText,
     workflowInputs,
   }) {
     if (!ctx) throw new Error("ctx is required");
@@ -81,7 +84,9 @@ export class Dispatcher {
     const mergedMeta = { ...(callbackMeta ?? {}), requester };
     const token = this.#callbacks.register(correlationId, mergedMeta);
     ctx.pending_callbacks[token] = correlationId;
+    ctx.active_requester = requester;
     const callbackUrl = `${this.#callbackBaseUrl}/api/callback/${token}`;
+    const inboxUrl = `${this.#callbackBaseUrl}/api/inbox/${correlationId}`;
 
     if (ackTarget !== undefined) await this.#ack.start(token, ackTarget);
     try {
@@ -92,13 +97,11 @@ export class Dispatcher {
         prompt,
         callbackUrl,
         correlationId,
+        inboxUrl,
         ...(workflowInputs ?? {}),
       });
-      if (historyText !== undefined) {
-        appendHistory(ctx.history, { role: "user", text: historyText });
-      }
-      ctx.dispatches.push(Date.now());
-      ctx.last_active_at = Date.now();
+      ctx.dispatches.push(this.#clock.now());
+      ctx.last_active_at = this.#clock.now();
       await this.#store.add(ctx);
       await this.#store.flush();
       return { kind: "dispatched", token, correlationId };
@@ -106,6 +109,7 @@ export class Dispatcher {
       if (ackTarget !== undefined) await this.#ack.finish(token, ackTarget);
       this.#callbacks.consume(token);
       delete ctx.pending_callbacks[token];
+      ctx.active_requester = null;
       throw err;
     }
   }

package/src/elapsed-scheduler.js

@@ -1,3 +1,5 @@
+import { createDefaultClock } from "@forwardimpact/libutil/runtime";
+
 const CHUNK_CAP_MS = 7 * 24 * 60 * 60 * 1000;
 
 /**
@@ -12,16 +14,19 @@ export class ElapsedScheduler {
   #timers = new Map();
   #onFire;
   #onError;
+  #clock;
 
   /**
    * @param {object} options
    * @param {(correlationId: string) => Promise<void>} options.onFire - Invoked when the deadline passes.
    * @param {(err: Error, correlationId: string) => void} [options.onError] - Invoked when `onFire` rejects.
+   * @param {import("@forwardimpact/libutil/runtime").Runtime["clock"]} [options.clock]
    */
-  constructor({ onFire, onError = () => {} }) {
+  constructor({ onFire, onError = () => {}, clock = createDefaultClock() }) {
     if (typeof onFire !== "function") throw new Error("onFire is required");
     this.#onFire = onFire;
     this.#onError = onError;
+    this.#clock = clock;
   }
 
   /** @returns {number} */
@@ -38,13 +43,13 @@ export class ElapsedScheduler {
    */
   schedule(correlationId, dueAt) {
     this.cancel(correlationId);
-    const remaining = dueAt - Date.now();
+    const remaining = dueAt - this.#clock.now();
     if (remaining <= 0) {
       this.#fire(correlationId);
       return;
     }
     const delay = Math.min(remaining, CHUNK_CAP_MS);
-    const timer = setTimeout(() => {
+    const timer = this.#clock.setTimeout(() => {
       this.#timers.delete(correlationId);
       if (remaining > CHUNK_CAP_MS) {
         this.schedule(correlationId, dueAt);
@@ -63,14 +68,14 @@ export class ElapsedScheduler {
   cancel(correlationId) {
     const timer = this.#timers.get(correlationId);
     if (timer) {
-      clearTimeout(timer);
+      this.#clock.clearTimeout(timer);
       this.#timers.delete(correlationId);
     }
   }
 
   /** Cancel every scheduled timer. */
   clear() {
-    for (const timer of this.#timers.values()) clearTimeout(timer);
+    for (const timer of this.#timers.values()) this.#clock.clearTimeout(timer);
     this.#timers.clear();
   }
 

package/src/history.js

@@ -9,6 +9,8 @@
  * @param {number} [options.maxEntries] - Default 10
  */
 export function appendHistory(history, entry, { maxEntries = 10 } = {}) {
-  history.push(entry);
+  const record = { role: entry.role, text: entry.text };
+  if (entry.author !== undefined) record.author = entry.author;
+  history.push(record);
   while (history.length > maxEntries) history.shift();
 }

package/src/inbox-handler.js

@@ -0,0 +1,47 @@
+import { bridge } from "@forwardimpact/libtype";
+import { createDefaultClock } from "@forwardimpact/libutil/runtime";
+
+/**
+ * Long-poll handler for the per-correlation inbox. The run's InboxPoller
+ * fetches injected messages via this endpoint.
+ *
+ * @param {object} deps
+ * @param {object} deps.client - Bridge gRPC client with DrainInbox
+ * @param {object} deps.logger
+ * @param {number} [deps.pollTimeoutMs] - Max wait before returning empty (default 30s)
+ * @param {number} [deps.pollIntervalMs] - Poll interval (default 1s)
+ * @param {import("@forwardimpact/libutil/runtime").Runtime["clock"]} [deps.clock]
+ * @returns {(c: import("hono").Context) => Promise<Response>}
+ */
+export function createInboxHandler({
+  client,
+  logger,
+  pollTimeoutMs = 30_000,
+  pollIntervalMs = 1_000,
+  clock = createDefaultClock(),
+}) {
+  return async (c) => {
+    const correlationId = c.req.param("correlationId");
+    const sinceSeq = parseInt(c.req.query("since") ?? "0", 10);
+    const deadline = clock.now() + pollTimeoutMs;
+
+    while (clock.now() < deadline) {
+      try {
+        const result = await client.DrainInbox(
+          bridge.DrainInboxRequest.fromObject({
+            correlation_id: correlationId,
+            since_seq: sinceSeq,
+          }),
+        );
+        if (result.messages?.length > 0) {
+          return c.json({ messages: result.messages });
+        }
+      } catch (err) {
+        logger.error?.("inbox", err);
+        return c.json({ error: "Inbox failure" }, 500);
+      }
+      await clock.sleep(pollIntervalMs);
+    }
+    return c.json({ messages: [] });
+  };
+}

package/src/index.js

@@ -18,6 +18,8 @@
  * @property {(ctx: object) => Promise<void>} add
  * @property {() => Promise<void>} flush
  * @property {() => Promise<void>} shutdown
+ * @property {(target: object) => Promise<void>} [putPendingDispatch]
+ * @property {(linkToken: string) => Promise<object|null>} [resolvePendingDispatch]
  */
 
 export { createBridgeServer } from "./server.js";
@@ -47,3 +49,5 @@ export {
   validateCallbackPayload,
 } from "./callback-payload.js";
 export { evaluateTrigger, parseIsoDuration } from "./triggers.js";
+export { prepareLinkResume, createLinkCompleteHandler } from "./link-resume.js";
+export { createInboxHandler } from "./inbox-handler.js";

package/src/link-resume.js

@@ -0,0 +1,92 @@
+import { randomUUID } from "node:crypto";
+import { normalizeBaseUrl } from "./callback-payload.js";
+import { buildPrompt } from "./prompt.js";
+
+/**
+ * @param {string} authorizeUrl
+ * @param {string} callbackBaseUrl
+ * @returns {{ linkToken: string, augmentedUrl: string }}
+ */
+export function prepareLinkResume(authorizeUrl, callbackBaseUrl) {
+  const linkToken = randomUUID();
+  const url = new URL(authorizeUrl);
+  url.searchParams.set(
+    "redirect_uri",
+    `${normalizeBaseUrl(callbackBaseUrl)}/api/link-complete`,
+  );
+  url.searchParams.set("client_state", linkToken);
+  return { linkToken, augmentedUrl: url.toString() };
+}
+
+/**
+ * @param {object} options
+ * @returns {(c: import("hono").Context) => Promise<Response>}
+ */
+export function createLinkCompleteHandler({
+  channel,
+  store,
+  dispatcher,
+  buildCallbackMeta,
+}) {
+  return async (c) => {
+    const linkToken = c.req.query("state");
+    if (!linkToken) {
+      return c.html(
+        "<!DOCTYPE html><html><body><h1>Error</h1>" +
+          "<p>Missing state parameter.</p></body></html>",
+        400,
+      );
+    }
+
+    const target = await store.resolvePendingDispatch(linkToken);
+    if (!target) {
+      return c.html(
+        "<!DOCTYPE html><html><body><h1>Already processed</h1>" +
+          "<p>This link has already been used or has expired." +
+          "</p></body></html>",
+      );
+    }
+
+    const ctx = await store.loadByChannel(channel, target.discussion_id);
+    if (!ctx) {
+      return c.html(
+        "<!DOCTYPE html><html><body><h1>Error</h1>" +
+          "<p>Discussion not found.</p></body></html>",
+        404,
+      );
+    }
+
+    const userTurn = [...ctx.history]
+      .reverse()
+      .find((e) => e.role === "user" && e.author === target.surface_user_id);
+    if (!userTurn) {
+      return c.html(
+        "<!DOCTYPE html><html><body><h1>Error</h1>" +
+          "<p>No message found to re-dispatch.</p></body></html>",
+        404,
+      );
+    }
+
+    const result = await dispatcher.dispatch({
+      ctx,
+      prompt: buildPrompt(userTurn.text, ctx.history),
+      requester: target.surface_user_id,
+      callbackMeta: buildCallbackMeta(ctx),
+      workflowInputs: { discussionId: target.discussion_id },
+    });
+
+    if (result.kind === "dispatched") {
+      return c.html(
+        "<!DOCTYPE html><html><body><h1>Processing</h1>" +
+          "<p>Your message is being processed. " +
+          "You can close this window.</p></body></html>",
+      );
+    }
+
+    return c.html(
+      "<!DOCTYPE html><html><body><h1>Unable to dispatch</h1>" +
+        "<p>Your account could not be verified. Please try " +
+        "linking again from the conversation.</p></body></html>",
+    );
+  };
+}

package/src/rate-limit.js

@@ -1,3 +1,5 @@
+import { createDefaultClock } from "@forwardimpact/libutil/runtime";
+
 /**
  * Sliding-window rate limiter. Operates on a caller-owned `dispatches: number[]`
  * array of timestamps and returns a structured result so callers can both
@@ -6,15 +8,22 @@
 export class RateLimiter {
   #windowMs;
   #max;
+  #clock;
 
   /**
    * @param {object} [options]
    * @param {number} [options.windowMs] - Sliding window length in ms (default: 60_000)
    * @param {number} [options.max] - Max dispatches allowed in the window (default: 5)
+   * @param {import("@forwardimpact/libutil/runtime").Runtime["clock"]} [options.clock]
    */
-  constructor({ windowMs = 60_000, max = 5 } = {}) {
+  constructor({
+    windowMs = 60_000,
+    max = 5,
+    clock = createDefaultClock(),
+  } = {}) {
     this.#windowMs = windowMs;
     this.#max = max;
+    this.#clock = clock;
   }
 
   /**
@@ -29,7 +38,7 @@ export class RateLimiter {
     if (!Array.isArray(dispatches)) {
       throw new Error("dispatches must be an array");
     }
-    const now = Date.now();
+    const now = this.#clock.now();
     const cutoff = now - this.#windowMs;
     let i = 0;
     while (i < dispatches.length && dispatches[i] < cutoff) i++;

package/src/resume-scheduler.js

@@ -1,3 +1,5 @@
+import { createDefaultClock } from "@forwardimpact/libutil/runtime";
+
 import { ElapsedScheduler } from "./elapsed-scheduler.js";
 import { evaluateTrigger, parseIsoDuration } from "./triggers.js";
 
@@ -13,6 +15,7 @@ export class ResumeScheduler {
   #buildResumeInputs;
   #buildCallbackMeta;
   #onDeclined;
+  #clock;
 
   /**
    * @param {object} options
@@ -23,6 +26,7 @@ export class ResumeScheduler {
    * @param {(ctx: object) => object} [options.buildCallbackMeta]
    * @param {(ctx: object) => object} [options.buildResumeInputs]
    * @param {((ctx: object, outcome: object) => Promise<void>) | null} [options.onDeclined]
+   * @param {import("@forwardimpact/libutil/runtime").Runtime["clock"]} [options.clock]
    */
   constructor({
     dispatcher,
@@ -32,6 +36,7 @@ export class ResumeScheduler {
     buildCallbackMeta = (ctx) => ({ discussionId: ctx.discussion_id }),
     buildResumeInputs = () => ({}),
     onDeclined = null,
+    clock = createDefaultClock(),
   }) {
     if (!dispatcher) throw new Error("dispatcher is required");
     if (!store) throw new Error("store is required");
@@ -51,12 +56,14 @@ export class ResumeScheduler {
     this.#buildCallbackMeta = buildCallbackMeta;
     this.#buildResumeInputs = buildResumeInputs;
     this.#onDeclined = onDeclined;
+    this.#clock = clock;
     this.#elapsed = new ElapsedScheduler({
       onFire: (cid) => this.#fireElapsed(cid),
       onError: (err, cid) =>
         this.#logger?.error?.("resume.elapsed", err, {
           correlation_id: cid,
         }),
+      clock,
     });
   }
 
@@ -81,7 +88,7 @@ export class ResumeScheduler {
    */
   enterRecess(ctx, correlationId, trigger, requester) {
     if (!trigger) return;
-    const openedAt = Date.now();
+    const openedAt = this.#clock.now();
     ctx.open_rfcs[correlationId] = {
       trigger,
       opened_at: openedAt,
@@ -157,7 +164,7 @@ export class ResumeScheduler {
         replies: ctx.history.length - rfc.history_index_at_open,
         opened_at: rfc.opened_at,
       };
-      if (evaluateTrigger(trigger, observed, Date.now()).fired) {
+      if (evaluateTrigger(trigger, observed, this.#clock.now()).fired) {
         fired.push({ correlationId, rfc });
       }
     }
@@ -207,7 +214,7 @@ export class ResumeScheduler {
     const result = await this.#redispatch(ctx, correlationId, historySince);
     if (result.kind === "dispatched") {
       this.cancelRecess(ctx, correlationId);
-      ctx.last_active_at = Date.now();
+      ctx.last_active_at = this.#clock.now();
       await this.#store.add(ctx);
       await this.#store.flush();
     }

package/src/server.js

@@ -23,6 +23,8 @@ import { serve } from "@hono/node-server";
  * @param {string} options.webhookPath - e.g. `/api/messages` or `/api/webhooks/github`
  * @param {(c: import("hono").Context) => Promise<Response> | Response} options.onWebhook
  * @param {(c: import("hono").Context) => Promise<Response> | Response} options.onCallback
+ * @param {((c: import("hono").Context) => Promise<Response> | Response)} [options.onLinkComplete]
+ * @param {(c: import("hono").Context) => Promise<Response> | Response} [options.onInbox] - Long-poll inbox handler
  * @returns {{ start: () => Promise<void>, stop: () => Promise<void>, app: import("hono").Hono, address: () => ({port: number} | null) }}
  */
 export function createBridgeServer({
@@ -32,6 +34,8 @@ export function createBridgeServer({
   webhookPath,
   onWebhook,
   onCallback,
+  onLinkComplete,
+  onInbox,
 }) {
   if (!config) throw new Error("config is required");
   if (!logger) throw new Error("logger is required");
@@ -86,6 +90,28 @@ export function createBridgeServer({
     }
   });
 
+  if (onLinkComplete) {
+    app.get("/api/link-complete", async (c) => {
+      try {
+        return await onLinkComplete(c);
+      } catch (err) {
+        logger.error("bridge.link-complete", err);
+        return c.json({ error: "Link completion failure" }, 500);
+      }
+    });
+  }
+
+  if (onInbox) {
+    app.get("/api/inbox/:correlationId", async (c) => {
+      try {
+        return await onInbox(c);
+      } catch (err) {
+        logger.error("bridge.inbox", err);
+        return c.json({ error: "Inbox failure" }, 500);
+      }
+    });
+  }
+
   let server = null;
 
   return {

package/src/token-resolver.js

@@ -1,19 +1,19 @@
-import { ghauth } from "@forwardimpact/libtype";
+import { ghuser } from "@forwardimpact/libtype";
 
-/** Maps ghauth GetToken oneof + gRPC transport into a discriminated DispatchAuth result. */
+/** Maps ghuser GetToken oneof + gRPC transport into a discriminated DispatchAuth result. */
 export class TokenResolver {
   #client;
 
-  /** @param {object} client - ghauth gRPC client */
+  /** @param {object} client - ghuser gRPC client */
   constructor(client) {
-    if (!client) throw new Error("ghauth client is required");
+    if (!client) throw new Error("ghuser client is required");
     this.#client = client;
   }
 
   /** @returns {Promise<{kind: string, token?: string, authorizeUrl?: string, error?: Error}>} */
   async resolve(surface, surfaceUserId) {
     try {
-      const req = new ghauth.GetTokenRequest({
+      const req = new ghuser.GetTokenRequest({
         surface,
         surface_user_id: surfaceUserId,
       });