@opengeni/api-router 2.5.0 → 2.6.4-canary.0

package/dist/http/sse.d.ts

@@ -5,6 +5,8 @@ import type { Observability } from "@opengeni/observability";
 export declare const SSE_QUEUED_FRAME_MAX_COUNT = 1;
 export declare const SSE_WRITE_STALL_TIMEOUT_MS = 30000;
 export declare const SSE_HEARTBEAT_INTERVAL_MS = 15000;
+export declare const HTTP1_BROWSER_SSE_BATCH_MAX_BYTES: number;
+export declare const HTTP1_BROWSER_SSE_BATCH_CONTENT_TYPE = "application/vnd.opengeni.sse-batch";
 export type SseDeliveryBoundObservation = {
     reason: "desired_size_non_positive" | "stall_timeout" | "frame_too_large";
     desiredSize: number | null;
@@ -12,6 +14,7 @@ export type SseDeliveryBoundObservation = {
     queuedBytes: number;
 };
 export type ByteBoundedSseStreamOptions = {
+    connectionLifetimeMs?: number | undefined;
     maxQueuedBytes?: number;
     stallTimeoutMs?: number;
     onStop?: () => void;
@@ -76,6 +79,11 @@ export declare function sseWorkspaceLiveStream(db: Database, bus: EventBus, acco
  */
 export declare function sseWorkspaceInteractionRevisionStream(db: Database, accountId: string, workspaceId: string, after: number, signal: AbortSignal, options?: WorkspaceInteractionSseOptions): Promise<Response>;
 export type SseDeliveryOptions = {
+    connectionLifetimeMs?: number | undefined;
+    /** Return a known-length batch instead of a chunked response. HTTP/1 only. */
+    finiteResponseMaxBytes?: number | undefined;
+    /** Browser transport classification for a finite response. */
+    finiteResponseMediaType?: "event-stream" | "http1-browser-batch" | undefined;
     maxQueuedBytes?: number;
     stallTimeoutMs?: number;
     heartbeatIntervalMs?: number;
@@ -87,4 +95,5 @@ export type SseDeliveryOptions = {
     /** Exact selected actor emitted on the stream response for cross-tab fencing. */
     actorEpoch?: string | undefined;
 };
+export declare function browserSseDeliveryOptions(transport: string | undefined): Pick<SseDeliveryOptions, "connectionLifetimeMs" | "finiteResponseMaxBytes" | "finiteResponseMediaType">;
 export type SessionSseDeliveryOptions = SseDeliveryOptions;

package/dist/index.js

@@ -6,7 +6,7 @@ import {
   createOpenGeniSlackBotInteractionClient,
   startSlackInteractionPump,
   startTemporalScheduleCleanupPump
-} from "./chunk-QESX7HDK.js";
+} from "./chunk-UOI7KAP3.js";
 
 // src/index.ts
 import {
@@ -32,7 +32,10 @@ import {
 } from "@opengeni/observability";
 import { createObjectStorage } from "@opengeni/storage";
 import { isArtifactRuntimeConfigured } from "@opengeni/artifact-tool/runtime/development";
-import { SESSION_WORKFLOW_WAKE_DISPATCHER_SCHEDULE_ID } from "@opengeni/core";
+import {
+  resolveCatalogSettings,
+  SESSION_WORKFLOW_WAKE_DISPATCHER_SCHEDULE_ID
+} from "@opengeni/core";
 import {
   Connection,
   Client as TemporalClient,
@@ -233,6 +236,94 @@ import {
 } from "@opengeni/agent-proto";
 var AGENT_EVENTS_SUBJECT = "agent.*.*.connection.*.events";
 var AGENT_HELLO_SUBJECT = "agent.*.*.connection.*.hello";
+function payloadIsHeartbeat(payload) {
+  try {
+    return AgentEvent.decode(payload).event?.$case === "heartbeat";
+  } catch {
+    return false;
+  }
+}
+function createAgentEventIngestionScheduler(handler, options = {}) {
+  const maxConcurrentSubjects = options.maxConcurrentSubjects ?? 32;
+  if (!Number.isSafeInteger(maxConcurrentSubjects) || maxConcurrentSubjects <= 0) {
+    throw new RangeError("maxConcurrentSubjects must be a positive safe integer");
+  }
+  const states = /* @__PURE__ */ new Map();
+  const readySubjects = [];
+  const idleWaiters = /* @__PURE__ */ new Set();
+  let accepting = true;
+  let activeSubjects = 0;
+  const resolveIdleWaiters = () => {
+    if (states.size !== 0) return;
+    for (const resolve of idleWaiters) resolve();
+    idleWaiters.clear();
+  };
+  async function drain(subject, state) {
+    while (true) {
+      const event = state.pending.shift();
+      if (!event) break;
+      try {
+        await handler(event.payload, event.subject);
+      } catch {
+      }
+    }
+    activeSubjects -= 1;
+    state.scheduled = false;
+    if (state.pending.length > 0) {
+      schedule(subject, state);
+    } else {
+      if (states.get(subject) === state) states.delete(subject);
+      resolveIdleWaiters();
+    }
+    pump();
+  }
+  function pump() {
+    while (activeSubjects < maxConcurrentSubjects) {
+      const next = readySubjects.shift();
+      if (!next) return;
+      if (states.get(next.subject) !== next.state || !next.state.scheduled) continue;
+      activeSubjects += 1;
+      void drain(next.subject, next.state);
+    }
+  }
+  function schedule(subject, state) {
+    if (state.scheduled) return;
+    state.scheduled = true;
+    readySubjects.push({ subject, state });
+    pump();
+  }
+  return {
+    enqueue(payload, subject) {
+      if (!accepting) return;
+      const heartbeat = payloadIsHeartbeat(payload);
+      let state = states.get(subject);
+      if (!state) {
+        state = { scheduled: false, pending: [] };
+        states.set(subject, state);
+      }
+      const queued = { payload, subject, heartbeat };
+      const lastIndex = state.pending.length - 1;
+      if (heartbeat && lastIndex >= 0 && state.pending[lastIndex].heartbeat) {
+        state.pending[lastIndex] = queued;
+        options.onHeartbeatCoalesced?.();
+      } else {
+        state.pending.push(queued);
+      }
+      schedule(subject, state);
+    },
+    async whenIdle() {
+      if (states.size === 0) return;
+      await new Promise((resolve) => idleWaiters.add(resolve));
+    },
+    close() {
+      accepting = false;
+      for (const state of states.values()) {
+        state.pending.length = 0;
+      }
+      resolveIdleWaiters();
+    }
+  };
+}
 function parseAgentSubject(subject, tail) {
   const parts = subject.split(".");
   if (parts.length !== 6 || parts[0] !== "agent" || parts[3] !== "connection" || !parts[4] || parts[5] !== tail) {
@@ -545,10 +636,22 @@ async function handleAgentEventPayload(db, observability, payload, subject, bus)
   }
 }
 function startMetricsIngestion(deps) {
-  return deps.bus.subscribeAgentEvents(
-    AGENT_EVENTS_SUBJECT,
-    (payload, subject) => handleAgentEventPayload(deps.db, deps.observability, payload, subject, deps.bus)
+  const scheduler = createAgentEventIngestionScheduler(
+    (payload, subject) => handleAgentEventPayload(deps.db, deps.observability, payload, subject, deps.bus),
+    {
+      onHeartbeatCoalesced: () => deps.observability?.incrementCounter({
+        name: "opengeni_machine_heartbeat_coalesced_total",
+        help: "Connected Machine heartbeats collapsed while an exact runner event queue was busy."
+      })
+    }
   );
+  const unsubscribe = deps.bus.subscribeAgentEvents(AGENT_EVENTS_SUBJECT, (payload, subject) => {
+    scheduler.enqueue(payload, subject);
+  });
+  return () => {
+    unsubscribe();
+    scheduler.close();
+  };
 }
 function helloReportsDisplay(hello) {
   const caps = hello.capabilities;
@@ -2805,6 +2908,15 @@ async function startApi(options = {}) {
       () => assertRuntimeDatabasePosture(dbClient.db, databasePosture),
       { ...retryOptions, onRetry }
     );
+    const resolvedCatalog = await retryStartupDependency(
+      "model catalog",
+      () => resolveCatalogSettings(dbClient.db, settings),
+      { ...retryOptions, onRetry }
+    );
+    observability.info("OpenGeni model catalog resolved", {
+      catalogSource: resolvedCatalog.source,
+      catalogVersion: resolvedCatalog.version
+    });
     bus = await retryStartupDependency(
       "NATS",
       () => createNatsEventBus(