@kb-labs/rest-api-app 2.117.0 → 2.118.1

package/dist/index.js

@@ -3,7 +3,7 @@ import Fastify from 'fastify';
 import { platform } from '@kb-labs/core-runtime';
 import { EventEmitter } from 'events';
 import { performance, monitorEventLoopDelay } from 'perf_hooks';
-import { OperationMetricsTracker, getListenOptions, registerOpenAPI, createHttpLogger, createServiceObservabilityDescribe, createServiceObservabilityHealth } from '@kb-labs/shared-http';
+import { OperationMetricsTracker, getListenOptions, registerOpenAPI, createHttpLogger, createSseStream, createServiceObservabilityDescribe, createServiceObservabilityHealth } from '@kb-labs/shared-http';
 import { Registry, Histogram, Counter, Gauge } from 'prom-client';
 import * as os from 'os';
 import { hostname } from 'os';
@@ -12,7 +12,7 @@ import * as process2 from 'process';
 import { createRegistry, mergeOpenAPISpecs } from '@kb-labs/core-registry';
 import { validateManifest } from '@kb-labs/plugin-contracts';
 import { mountRoutes } from '@kb-labs/plugin-execution/http';
-import { mountWebSocketChannels } from '@kb-labs/plugin-execution';
+import { mountEventStreams, mountWebSocketChannels } from '@kb-labs/plugin-execution';
 import { InProcessBackend } from '@kb-labs/plugin-execution-factory';
 import { logDiagnosticEvent } from '@kb-labs/core-platform';
 import * as path from 'path';
@@ -823,8 +823,6 @@ function buildRegistrySseAuthHook(config) {
     });
   };
 }
-
-// src/routes/events.ts
 async function registerEventRoutes(server, basePath, registry, readiness, eventHub, config) {
   const endpoint = `${basePath}/events/registry`;
   const authHook = buildRegistrySseAuthHook(config);
@@ -833,25 +831,18 @@ async function registerEventRoutes(server, basePath, registry, readiness, eventH
     url: endpoint,
     onRequest: authHook ? [authHook] : void 0,
     handler: async (request, reply) => {
-      reply.hijack();
       const origin = request.headers.origin;
-      if (origin === "http://localhost:3000" || origin === "http://localhost:5173") {
-        reply.raw.setHeader("Access-Control-Allow-Origin", origin);
-        reply.raw.setHeader("Access-Control-Allow-Credentials", "true");
-      }
-      reply.raw.setHeader("Content-Type", "text/event-stream");
-      reply.raw.setHeader("Cache-Control", "no-cache, no-transform");
-      reply.raw.setHeader("Connection", "keep-alive");
-      reply.raw.flushHeaders?.();
-      reply.raw.write(": connected\n\n");
+      const stream = createSseStream(request, reply, {
+        logger: request.kbLogger ?? platform.logger,
+        serviceId: "rest",
+        route: endpoint,
+        headers: origin === "http://localhost:3000" || origin === "http://localhost:5173" ? { "Access-Control-Allow-Origin": origin, "Access-Control-Allow-Credentials": "true" } : void 0
+      });
       const send = (event) => {
-        reply.raw.write(`event: ${event.type}
-`);
-        reply.raw.write(`data: ${JSON.stringify(event)}
-
-`);
+        stream.send(event.type, event);
       };
       const unsubscribe = eventHub.subscribe(send);
+      stream.onCleanup(unsubscribe);
       const snapshot = registry.snapshot();
       const checksumAlgorithm = snapshot.checksumAlgorithm === "sha256" ? "sha256" : void 0;
       send({
@@ -899,20 +890,12 @@ async function registerEventRoutes(server, basePath, registry, readiness, eventH
           request.kbLogger.warn("Failed to fetch system health for SSE client", { err: error });
         }
       });
-      await new Promise((resolve2) => {
-        request.raw.on("close", () => {
-          unsubscribe();
-          reply.raw.end();
-          resolve2();
-        });
-        if (request.raw.socket && !request.raw.socket.writable) {
-          void healthPromise.then(() => {
-            unsubscribe();
-            reply.raw.end();
-            resolve2();
-          });
-        }
-      });
+      if (request.raw.socket && !request.raw.socket.writable) {
+        await healthPromise;
+        stream.close("test_complete");
+        return;
+      }
+      await stream.closed;
     }
   });
 }
@@ -2052,7 +2035,7 @@ async function registerPluginRoutes(server, config, repoRoot, registry, readines
     const backend = platform.executionBackend;
     const wsBackend = new InProcessBackend({ platform: platform });
     const mountableManifests = manifests.filter(
-      (entry) => entry.manifest.rest?.routes && entry.manifest.rest.routes.length > 0 || entry.manifest.ws?.channels && entry.manifest.ws.channels.length > 0
+      (entry) => entry.manifest.rest?.routes && entry.manifest.rest.routes.length > 0 || entry.manifest.sse?.streams && entry.manifest.sse.streams.length > 0 || entry.manifest.ws?.channels && entry.manifest.ws.channels.length > 0
     );
     platform.logger.info("Plugins selected for route mounting", {
       mountable: mountableManifests.length,
@@ -2074,6 +2057,18 @@ async function registerPluginRoutes(server, config, repoRoot, registry, readines
           }
         }
       }
+      if (entry.manifest.sse?.streams) {
+        for (const stream of entry.manifest.sse.streams) {
+          const handlerFile = stream.handler.split("#")[0];
+          if (handlerFile) {
+            const pluginDistRoot = path.join(entry.pluginRoot, "dist");
+            handlerChecks.push({
+              key: `${entry.manifest.id}::SSE ${stream.path}`,
+              filePath: path.resolve(pluginDistRoot, handlerFile)
+            });
+          }
+        }
+      }
     }
     const handlerAccessResults = await Promise.all(
       handlerChecks.map(async (check) => {
@@ -2125,6 +2120,25 @@ async function registerPluginRoutes(server, config, repoRoot, registry, readines
           }
         }
       }
+      if (manifest.sse?.streams) {
+        for (const stream of manifest.sse.streams) {
+          const handlerFile = stream.handler.split("#")[0];
+          if (!handlerFile) {
+            restValidationErrors.push(
+              `Event stream ${stream.path}: Invalid handler reference "${stream.handler}"`
+            );
+            continue;
+          }
+          const check = handlerExistsMap.get(
+            `${manifest.id}::SSE ${stream.path}`
+          );
+          if (check && !check.exists) {
+            restValidationErrors.push(
+              `Event stream ${stream.path}: Handler file not found: ${check.filePath}`
+            );
+          }
+        }
+      }
       if (restValidationErrors.length > 0) {
         const reasonCode = inferRouteValidationReasonCode(restValidationErrors);
         logDiagnosticEvent(platform.logger, {
@@ -2161,11 +2175,17 @@ async function registerPluginRoutes(server, config, repoRoot, registry, readines
             return match ? `${match[1]} ${match[2]}` : null;
           }).filter(Boolean)
         );
-        const validRoutes = manifest.rest.routes.filter((route) => {
+        const validRoutes = (manifest.rest?.routes ?? []).filter((route) => {
           const routeKey = `${route.method} ${route.path}`;
           return !errorPaths.has(routeKey);
         });
-        if (validRoutes.length === 0) {
+        const streamErrorPaths = new Set(
+          restValidationErrors.map((error) => error.match(/Event stream\s+([^\s:]+)/)?.[1]).filter((value) => Boolean(value))
+        );
+        const validStreams = (manifest.sse?.streams ?? []).filter(
+          (stream) => !streamErrorPaths.has(stream.path)
+        );
+        if (validRoutes.length === 0 && validStreams.length === 0) {
           restDomainOperationMetrics.recordOperation(
             "plugin.routes.mount",
             0,
@@ -2193,11 +2213,17 @@ async function registerPluginRoutes(server, config, repoRoot, registry, readines
           });
           continue;
         }
-        manifest.rest.routes = validRoutes;
+        if (manifest.rest) {
+          manifest.rest.routes = validRoutes;
+        }
+        if (manifest.sse) {
+          manifest.sse.streams = validStreams;
+        }
         platform.logger.info("Filtered routes, mounting valid ones", {
           plugin: `${manifest.id}@${manifest.version}`,
-          totalRoutes: manifest.rest.routes.length + restValidationErrors.length,
+          totalRoutes: validRoutes.length + restValidationErrors.length,
           validRoutes: validRoutes.length,
+          validStreams: validStreams.length,
           skippedRoutes: restValidationErrors.length
         });
       }
@@ -2218,13 +2244,28 @@ async function registerPluginRoutes(server, config, repoRoot, registry, readines
         } else {
           pluginBasePath = `${config.basePath}/plugins/${manifest.id}`;
         }
+        let sseBasePath = pluginBasePath;
+        if (manifest.sse?.basePath) {
+          if (manifest.sse.basePath.startsWith("/api/")) {
+            sseBasePath = manifest.sse.basePath;
+          } else if (manifest.sse.basePath.startsWith("/v1/")) {
+            sseBasePath = manifest.sse.basePath.replace(
+              /^\/v1/,
+              config.basePath
+            );
+          } else {
+            sseBasePath = `${config.basePath}${manifest.sse.basePath}`;
+          }
+        }
         platform.logger.info("Mounting plugin routes", {
           plugin: `${manifest.id}@${manifest.version}`,
           configBasePath: config.basePath,
           manifestBasePath: manifest.rest?.basePath,
           pluginBasePath,
+          sseBasePath,
           pluginRoot,
-          routes: manifest.rest?.routes?.length ?? 0
+          routes: manifest.rest?.routes?.length ?? 0,
+          streams: manifest.sse?.streams?.length ?? 0
         });
         await mountRoutes(server, manifest, {
           backend,
@@ -2233,8 +2274,28 @@ async function registerPluginRoutes(server, config, repoRoot, registry, readines
           basePath: pluginBasePath,
           defaultTimeoutMs: gatewayTimeoutMs
         });
+        let streamsCount = 0;
+        if (manifest.sse?.streams && manifest.sse.streams.length > 0) {
+          const streamsResult = await mountEventStreams(server, manifest, {
+            backend: wsBackend,
+            logger: platform.logger,
+            serviceId: "rest",
+            pluginRoot: pluginDistRoot,
+            workspaceRoot,
+            basePath: sseBasePath,
+            defaultTimeoutMs: manifest.sse.defaults?.timeoutMs ?? gatewayTimeoutMs,
+            defaultKeepAliveMs: manifest.sse.defaults?.keepAliveMs
+          });
+          streamsCount = streamsResult.mounted;
+          if (streamsResult.errors.length > 0) {
+            platform.logger.warn("SSE stream mounting had errors", {
+              plugin: `${manifest.id}@${manifest.version}`,
+              errors: streamsResult.errors
+            });
+          }
+        }
         const duration = performance.now() - start;
-        const routesCount = manifest.rest?.routes?.length ?? 0;
+        const routesCount = (manifest.rest?.routes?.length ?? 0) + streamsCount;
         for (const route of manifest.rest?.routes ?? []) {
           metricsCollector.registerRouteBudget(
             route.method,
@@ -2261,6 +2322,7 @@ async function registerPluginRoutes(server, config, repoRoot, registry, readines
           plugin: `${manifest.id}@${manifest.version}`,
           pluginBasePath,
           routesCount,
+          streamsCount,
           durationMs: Number(duration.toFixed(2))
         });
         let channelsCount = 0;
@@ -2930,38 +2992,27 @@ async function registerWorkflowRoutes(server, config) {
     url: `${basePath}/workflows/runs/:runId/events`,
     handler: async (request, reply) => {
       const runId = getRunId(request.params);
-      reply.hijack();
-      const raw = reply.raw;
       const origin = request.headers.origin;
-      if (typeof origin === "string" && (origin === "http://localhost:3000" || origin === "http://localhost:5173")) {
-        raw.setHeader("Access-Control-Allow-Origin", origin);
-        raw.setHeader("Access-Control-Allow-Credentials", "true");
-      }
-      raw.setHeader("Content-Type", "text/event-stream");
-      raw.setHeader("Cache-Control", "no-cache, no-transform");
-      raw.setHeader("Connection", "keep-alive");
-      raw.flushHeaders?.();
-      raw.write(": connected\n\n");
+      const stream = createSseStream(request, reply, {
+        logger: request.kbLogger ?? platform.logger,
+        serviceId: "rest",
+        route: `${basePath}/workflows/runs/:runId/events`,
+        keepAliveMs: KEEP_ALIVE_MS,
+        headers: typeof origin === "string" && (origin === "http://localhost:3000" || origin === "http://localhost:5173") ? { "Access-Control-Allow-Origin": origin, "Access-Control-Allow-Credentials": "true" } : void 0
+      });
       const sentIds = /* @__PURE__ */ new Set();
       const sendEvent = (type, payload, timestamp) => {
-        if (raw.writableEnded) {
-          return;
-        }
         const data = { type, runId, payload, timestamp: timestamp ?? (/* @__PURE__ */ new Date()).toISOString() };
         const dedup = `${type}:${data.timestamp}`;
         if (sentIds.has(dedup)) {
           return;
         }
         sentIds.add(dedup);
-        raw.write(`event: workflow.event
-`);
-        raw.write(`data: ${JSON.stringify(data)}
-
-`);
+        stream.send("workflow.event", data);
       };
       const alreadyFinished = await replayHistory(runId, sendEvent);
       if (alreadyFinished) {
-        raw.end();
+        stream.close("run_already_finished");
         return;
       }
       let idleTimer = null;
@@ -2973,12 +3024,6 @@ async function registerWorkflowRoutes(server, config) {
           cleanup();
         }, IDLE_TIMEOUT_MS);
       };
-      const keepAliveTimer = setInterval(() => {
-        if (raw.writableEnded) {
-          return;
-        }
-        raw.write(": keep-alive\n\n");
-      }, KEEP_ALIVE_MS);
       const unsubscribe = platform.eventBus.subscribe(WORKFLOW_REDIS_CHANNEL, async (rawEvent) => {
         const event = rawEvent;
         if (event.runId !== runId) {
@@ -2995,17 +3040,17 @@ async function registerWorkflowRoutes(server, config) {
         if (idleTimer) {
           clearTimeout(idleTimer);
         }
-        clearInterval(keepAliveTimer);
-        if (!raw.writableEnded) {
-          raw.write(`event: workflow.done
-data: {}
-
-`);
-          raw.end();
-        }
+        stream.send("workflow.done", {});
+        stream.close("workflow_complete");
       };
       resetIdle();
-      request.raw.on("close", cleanup);
+      stream.onCleanup(() => {
+        if (idleTimer) {
+          clearTimeout(idleTimer);
+        }
+        unsubscribe();
+      });
+      await stream.closed;
     }
   });
   server.route({
@@ -3015,41 +3060,30 @@ data: {}
       const runId = getRunId(request.params);
       const query = request.query;
       const idleTimeout = query.idleTimeoutMs ? parseInt(query.idleTimeoutMs, 10) : IDLE_TIMEOUT_MS;
-      reply.hijack();
-      const raw = reply.raw;
       const origin = request.headers.origin;
-      if (typeof origin === "string" && (origin === "http://localhost:3000" || origin === "http://localhost:5173")) {
-        raw.setHeader("Access-Control-Allow-Origin", origin);
-        raw.setHeader("Access-Control-Allow-Credentials", "true");
-      }
-      raw.setHeader("Content-Type", "text/event-stream");
-      raw.setHeader("Cache-Control", "no-cache, no-transform");
-      raw.setHeader("Connection", "keep-alive");
-      raw.flushHeaders?.();
-      raw.write(": connected\n\n");
+      const stream = createSseStream(request, reply, {
+        logger: request.kbLogger ?? platform.logger,
+        serviceId: "rest",
+        route: `${basePath}/workflows/runs/:runId/logs`,
+        keepAliveMs: KEEP_ALIVE_MS,
+        headers: typeof origin === "string" && (origin === "http://localhost:3000" || origin === "http://localhost:5173") ? { "Access-Control-Allow-Origin": origin, "Access-Control-Allow-Credentials": "true" } : void 0
+      });
       const sentLogIds = /* @__PURE__ */ new Set();
       const sendLog = (event) => {
-        if (raw.writableEnded) {
-          return;
-        }
         const ts = event.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
         const dedup = `${event.type}:${event.jobId ?? ""}:${event.stepId ?? ""}:${ts}`;
         if (sentLogIds.has(dedup)) {
           return;
         }
         sentLogIds.add(dedup);
-        raw.write(`event: workflow.log
-`);
-        raw.write(`data: ${JSON.stringify({
+        stream.send("workflow.log", {
           type: event.type,
           runId: event.runId,
           jobId: event.jobId,
           stepId: event.stepId,
           payload: event.payload,
           timestamp: ts
-        })}
-
-`);
+        });
       };
       let logsAlreadyFinished = false;
       try {
@@ -3074,11 +3108,8 @@ data: {}
       } catch {
       }
       if (logsAlreadyFinished) {
-        raw.write(`event: workflow.done
-data: {}
-
-`);
-        raw.end();
+        stream.send("workflow.done", {});
+        stream.close("run_already_finished");
         return;
       }
       let idleTimer = null;
@@ -3090,12 +3121,6 @@ data: {}
           cleanup();
         }, idleTimeout);
       };
-      const keepAliveTimer = setInterval(() => {
-        if (raw.writableEnded) {
-          return;
-        }
-        raw.write(": keep-alive\n\n");
-      }, KEEP_ALIVE_MS);
       const unsubscribe = platform.eventBus.subscribe(WORKFLOW_REDIS_CHANNEL, async (rawEvent) => {
         const event = rawEvent;
         if (event.runId !== runId) {
@@ -3112,17 +3137,17 @@ data: {}
         if (idleTimer) {
           clearTimeout(idleTimer);
         }
-        clearInterval(keepAliveTimer);
-        if (!raw.writableEnded) {
-          raw.write(`event: workflow.done
-data: {}
-
-`);
-          raw.end();
-        }
+        stream.send("workflow.done", {});
+        stream.close("workflow_complete");
       };
       resetIdle();
-      request.raw.on("close", cleanup);
+      stream.onCleanup(() => {
+        if (idleTimer) {
+          clearTimeout(idleTimer);
+        }
+        unsubscribe();
+      });
+      await stream.closed;
     }
   });
 }
@@ -3372,7 +3397,7 @@ async function registerCacheRoutes(server, config, registry) {
     }
   });
 }
-async function registerObservabilityRoutes(fastify, config, repoRoot, historicalMetrics, platform16) {
+async function registerObservabilityRoutes(fastify, config, repoRoot, historicalMetrics, platform17) {
   const basePath = normalizeBasePath(config.basePath);
   const stateBrokerPaths = resolvePaths(basePath, "/observability/state-broker");
   const systemMetricsPaths = resolvePaths(basePath, "/observability/system-metrics");
@@ -3419,7 +3444,7 @@ async function registerObservabilityRoutes(fastify, config, repoRoot, historical
           }
         };
       } catch (error) {
-        platform16?.logger.error("Failed to fetch State Broker stats", error instanceof Error ? error : new Error(String(error)));
+        platform17?.logger.error("Failed to fetch State Broker stats", error instanceof Error ? error : new Error(String(error)));
         const isTimeout = error instanceof Error && error.name === "AbortError";
         return reply.code(503).send({
           ok: false,
@@ -3437,7 +3462,7 @@ async function registerObservabilityRoutes(fastify, config, repoRoot, historical
   for (const path2 of systemMetricsPaths) {
     fastify.get(path2, { schema: { tags: ["Observability"], summary: "System resource metrics" } }, async (_request, reply) => {
       try {
-        if (!platform16?.cache) {
+        if (!platform17?.cache) {
           return reply.code(503).send({
             ok: false,
             error: {
@@ -3449,18 +3474,18 @@ async function registerObservabilityRoutes(fastify, config, repoRoot, historical
         fastify.log.debug("Fetching system metrics from all instances");
         const allMetrics = [];
         try {
-          const cacheWithScan = platform16.cache;
-          if ("scan" in platform16.cache && typeof cacheWithScan.scan === "function") {
+          const cacheWithScan = platform17.cache;
+          if ("scan" in platform17.cache && typeof cacheWithScan.scan === "function") {
             const keys = await cacheWithScan.scan("system-metrics:*");
             for (const key of keys) {
-              const metrics = await platform16.cache.get(key);
+              const metrics = await platform17.cache.get(key);
               if (metrics) {
                 allMetrics.push(metrics);
               }
             }
           } else {
             const currentInstanceId = hostname();
-            const metrics = await platform16.cache.get(`system-metrics:${currentInstanceId}`);
+            const metrics = await platform17.cache.get(`system-metrics:${currentInstanceId}`);
             if (metrics) {
               allMetrics.push(metrics);
             }
@@ -3469,7 +3494,7 @@ async function registerObservabilityRoutes(fastify, config, repoRoot, historical
         } catch (scanError) {
           fastify.log.warn({ err: scanError }, "Failed to scan platform.cache for system metrics");
           const currentInstanceId = hostname();
-          const metrics = await platform16.cache.get(`system-metrics:${currentInstanceId}`);
+          const metrics = await platform17.cache.get(`system-metrics:${currentInstanceId}`);
           if (metrics) {
             allMetrics.push(metrics);
           }
@@ -3517,7 +3542,7 @@ async function registerObservabilityRoutes(fastify, config, repoRoot, historical
           }
         };
       } catch (error) {
-        platform16?.logger.error("Failed to fetch system metrics", error instanceof Error ? error : new Error(String(error)));
+        platform17?.logger.error("Failed to fetch system metrics", error instanceof Error ? error : new Error(String(error)));
         return reply.code(500).send({
           ok: false,
           error: {
@@ -3615,7 +3640,7 @@ async function registerObservabilityRoutes(fastify, config, repoRoot, historical
           }
         };
       } catch (error) {
-        platform16?.logger.error("Failed to query historical metrics", error instanceof Error ? error : new Error(String(error)), { query });
+        platform17?.logger.error("Failed to query historical metrics", error instanceof Error ? error : new Error(String(error)), { query });
         return reply.code(500).send({
           ok: false,
           error: {
@@ -3706,7 +3731,7 @@ async function registerObservabilityRoutes(fastify, config, repoRoot, historical
           }
         };
       } catch (error) {
-        platform16?.logger.error("Failed to query heatmap data", error instanceof Error ? error : new Error(String(error)), { query });
+        platform17?.logger.error("Failed to query heatmap data", error instanceof Error ? error : new Error(String(error)), { query });
         return reply.code(500).send({
           ok: false,
           error: {
@@ -3740,7 +3765,7 @@ async function registerObservabilityRoutes(fastify, config, repoRoot, historical
         }
       }
     }, async (request, reply) => {
-      if (!platform16?.llm) {
+      if (!platform17?.llm) {
         return reply.code(503).send({
           ok: false,
           error: {
@@ -3806,15 +3831,15 @@ Provide a clear, actionable response based on the data above. Include:
 
 Be concise but thorough. Use markdown formatting.`;
         fastify.log.debug({ question: body.question, contextLength: contextText.length }, "Calling LLM for insights");
-        const result = await platform16.llm.complete(prompt, {
+        const result = await platform17.llm.complete(prompt, {
           systemPrompt: "You are a DevOps and SRE expert assistant. Analyze system metrics and provide actionable insights. Be concise, technical, and helpful.",
           temperature: 0.7,
           maxTokens: 1e3
         });
         const totalTokens = result.usage.promptTokens + result.usage.completionTokens;
         fastify.log.debug({ tokensUsed: totalTokens }, "LLM response received for insights");
-        if (platform16.analytics) {
-          platform16.analytics.track("ai_insights.chat", {
+        if (platform17.analytics) {
+          platform17.analytics.track("ai_insights.chat", {
             questionLength: body.question.length,
             contextIncluded: Object.keys(contextConfig).filter((k) => contextConfig[k]),
             timeRange: contextConfig.timeRange,
@@ -3843,9 +3868,9 @@ Be concise but thorough. Use markdown formatting.`;
           }
         };
       } catch (error) {
-        platform16?.logger.error("Failed to generate insights", error instanceof Error ? error : new Error(String(error)));
-        if (platform16?.analytics) {
-          platform16.analytics.track("ai_insights.error", {
+        platform17?.logger.error("Failed to generate insights", error instanceof Error ? error : new Error(String(error)));
+        if (platform17?.analytics) {
+          platform17.analytics.track("ai_insights.error", {
             error: error instanceof Error ? error.message : "Unknown error",
             questionLength: request.body?.question?.length ?? 0
           }).catch(() => {
@@ -5353,55 +5378,21 @@ async function registerLogRoutes(server, config, eventHub) {
           message: "Logger adapter does not support streaming. Enable logRingBuffer in kb.config.json"
         });
       }
-      reply.hijack();
-      let streamClosed = false;
       const origin = request.headers.origin;
-      if (origin === "http://localhost:3000" || origin === "http://localhost:5173") {
-        reply.raw.setHeader("Access-Control-Allow-Origin", origin);
-        reply.raw.setHeader("Access-Control-Allow-Credentials", "true");
-      } else {
-        reply.raw.setHeader("Access-Control-Allow-Origin", "*");
-      }
-      reply.raw.setHeader("Content-Type", "text/event-stream");
-      reply.raw.setHeader("Cache-Control", "no-cache, no-transform");
-      reply.raw.setHeader("Connection", "keep-alive");
-      try {
-        reply.raw.flushHeaders?.();
-        reply.raw.write(": connected\n\n");
-      } catch (err) {
-        streamClosed = true;
-        return;
-      }
-      const unsubscribe = platform.logs.subscribe((log) => {
-        if (!streamClosed && !reply.raw.writableEnded && !reply.raw.destroyed) {
-          try {
-            const frontendLog = toFrontendLogRecord(log);
-            reply.raw.write(`event: log
-`);
-            reply.raw.write(`data: ${JSON.stringify(frontendLog)}
-
-`);
-          } catch (err) {
-            streamClosed = true;
-          }
-        }
+      const stream = createSseStream(request, reply, {
+        logger: request.kbLogger ?? platform.logger,
+        serviceId: "rest",
+        route: "/api/v1/logs/stream",
+        // This stream carries logs, so event-level telemetry would feed it
+        // back into itself. Lifecycle + close summary remain enabled.
+        logEvents: false,
+        headers: origin === "http://localhost:3000" || origin === "http://localhost:5173" ? { "Access-Control-Allow-Origin": origin, "Access-Control-Allow-Credentials": "true" } : { "Access-Control-Allow-Origin": "*" }
       });
-      const cleanup = () => {
-        if (!streamClosed) {
-          streamClosed = true;
-          unsubscribe();
-          try {
-            if (!reply.raw.writableEnded && !reply.raw.destroyed) {
-              reply.raw.end();
-            }
-          } catch (err) {
-          }
-        }
-      };
-      request.raw.on("close", cleanup);
-      request.raw.on("error", cleanup);
-      await new Promise(() => {
+      const unsubscribe = platform.logs.subscribe((log) => {
+        stream.send("log", toFrontendLogRecord(log));
       });
+      stream.onCleanup(unsubscribe);
+      await stream.closed;
     }
   );
   server.get(
@@ -6565,7 +6556,7 @@ async function bootstrap(cwd = process.cwd()) {
   });
 }
 async function startRestApi({
-  platform: platform16,
+  platform: platform17,
   projectRoot: repoRoot,
   platformRoot,
   logger: serviceLogger
@@ -6604,7 +6595,7 @@ async function startRestApi({
     platformRoot: platformRoot !== repoRoot ? platformRoot : void 0,
     cache: {
       ttlMs: snapshotTTL,
-      adapter: platform16.cache
+      adapter: platform17.cache
     }
   });
   restDomainOperationMetrics.recordOperation(
@@ -6633,7 +6624,7 @@ async function startRestApi({
     () => metricsCollector.getActiveRequests()
   );
   await metricsCollector2.start(1e4, 6e4);
-  const restTransport = platform16.getAdapter("serviceTransport");
+  const restTransport = platform17.getAdapter("serviceTransport");
   const restAddr = restTransport?.listenAddress?.("rest");
   const netOffset = Number(process.env.KB_NET_OFFSET) || 0;
   const listenPort = restAddr && "port" in restAddr ? restAddr.port : config.port + netOffset;