@posthog/agent 2.3.656 → 2.3.658

package/dist/server/agent-server.js

@@ -9315,7 +9315,7 @@ import { z as z5 } from "zod";
 // package.json
 var package_default = {
   name: "@posthog/agent",
-  version: "2.3.656",
+  version: "2.3.658",
   repository: "https://github.com/PostHog/code",
   description: "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   exports: {
@@ -22450,6 +22450,671 @@ function normalizeCloudPromptContent(content) {
   return content;
 }
 
+// src/server/event-stream-sender.ts
+import { Buffer as Buffer4 } from "buffer";
+
+// src/server/streaming-upload.ts
+import { Buffer as Buffer3 } from "buffer";
+import {
+  request as httpRequest
+} from "http";
+import { request as httpsRequest } from "https";
+import { URL as URL2 } from "url";
+function headersFromIncoming(headers) {
+  const result = new Headers();
+  for (const [name2, value] of Object.entries(headers)) {
+    if (value === void 0) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        result.append(name2, item);
+      }
+    } else {
+      result.set(name2, String(value));
+    }
+  }
+  return result;
+}
+function abortError() {
+  const error = new Error("aborted");
+  error.name = "AbortError";
+  return error;
+}
+function writeRequestChunk(request, chunk) {
+  return new Promise((resolve8, reject) => {
+    const onError2 = (error) => {
+      request.off("error", onError2);
+      reject(error);
+    };
+    request.once("error", onError2);
+    request.write(Buffer3.from(chunk), (error) => {
+      request.off("error", onError2);
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve8();
+    });
+  });
+}
+function closeRequest(request) {
+  return new Promise((resolve8, reject) => {
+    const onError2 = (error) => {
+      request.off("error", onError2);
+      reject(error);
+    };
+    request.once("error", onError2);
+    request.end(() => {
+      request.off("error", onError2);
+      resolve8();
+    });
+  });
+}
+function createNodeStreamingUpload({
+  url,
+  headers,
+  abortController
+}) {
+  const parsedUrl = new URL2(url);
+  const requestFactory = parsedUrl.protocol === "https:" ? httpsRequest : parsedUrl.protocol === "http:" ? httpRequest : void 0;
+  if (!requestFactory) {
+    throw new Error(`Unsupported event ingest protocol: ${parsedUrl.protocol}`);
+  }
+  const request = requestFactory(parsedUrl, {
+    method: "POST",
+    headers
+  });
+  let closed = false;
+  const responsePromise = new Promise((resolve8, reject) => {
+    request.on("response", (response) => {
+      const chunks = [];
+      response.on("data", (chunk) => {
+        chunks.push(Buffer3.isBuffer(chunk) ? chunk : Buffer3.from(chunk));
+      });
+      response.on("end", () => {
+        resolve8(
+          new Response(Buffer3.concat(chunks), {
+            status: response.statusCode ?? 0,
+            statusText: response.statusMessage,
+            headers: headersFromIncoming(response.headers)
+          })
+        );
+      });
+      response.on("error", reject);
+    });
+    request.on("error", reject);
+  });
+  const abortRequest = () => {
+    closed = true;
+    if (!request.destroyed) {
+      request.destroy(abortError());
+    }
+  };
+  abortController.signal.addEventListener("abort", abortRequest, {
+    once: true
+  });
+  void responsePromise.finally(() => {
+    abortController.signal.removeEventListener("abort", abortRequest);
+  }).catch(() => void 0);
+  return {
+    async write(chunk) {
+      if (closed) {
+        throw new Error("Cannot write to closed event ingest stream");
+      }
+      await writeRequestChunk(request, chunk);
+    },
+    async close() {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      await closeRequest(request);
+    },
+    async abort() {
+      abortRequest();
+    },
+    responsePromise
+  };
+}
+
+// src/server/event-stream-sender.ts
+var DEFAULT_MAX_BUFFERED_EVENTS = 2e4;
+var DEFAULT_MAX_STREAM_EVENTS = 900;
+var DEFAULT_MAX_STREAM_BYTES = 4e6;
+var DEFAULT_MAX_EVENT_BYTES = 9e5;
+var DEFAULT_FLUSH_DELAY_MS = 0;
+var DEFAULT_RETRY_DELAY_MS = 1e3;
+var DEFAULT_REQUEST_TIMEOUT_MS = 1e4;
+var DEFAULT_STOP_TIMEOUT_MS = 3e4;
+var DEFAULT_STREAM_WINDOW_MS = 5 * 60 * 1e3;
+var STREAM_COMPLETE_CONTROL_TYPE = "_posthog/stream_complete";
+var TaskRunEventStreamSender = class {
+  constructor(config) {
+    this.config = config;
+    const apiUrl = config.apiUrl.replace(/\/$/, "");
+    this.ingestUrl = `${apiUrl}/api/projects/${config.projectId}/tasks/${encodeURIComponent(
+      config.taskId
+    )}/runs/${encodeURIComponent(config.runId)}/event_stream/`;
+    this.maxBufferedEvents = config.maxBufferedEvents ?? DEFAULT_MAX_BUFFERED_EVENTS;
+    this.maxStreamEvents = config.maxStreamEvents ?? DEFAULT_MAX_STREAM_EVENTS;
+    this.maxStreamBytes = config.maxStreamBytes ?? DEFAULT_MAX_STREAM_BYTES;
+    this.maxEventBytes = config.maxEventBytes ?? DEFAULT_MAX_EVENT_BYTES;
+    this.flushDelayMs = config.flushDelayMs ?? DEFAULT_FLUSH_DELAY_MS;
+    this.retryDelayMs = config.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS;
+    this.requestTimeoutMs = config.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+    this.stopTimeoutMs = config.stopTimeoutMs ?? DEFAULT_STOP_TIMEOUT_MS;
+    this.streamWindowMs = config.streamWindowMs ?? DEFAULT_STREAM_WINDOW_MS;
+    this.createStreamingUpload = config.createStreamingUpload ?? createNodeStreamingUpload;
+  }
+  ingestUrl;
+  maxBufferedEvents;
+  maxStreamEvents;
+  maxStreamBytes;
+  maxEventBytes;
+  flushDelayMs;
+  retryDelayMs;
+  requestTimeoutMs;
+  stopTimeoutMs;
+  streamWindowMs;
+  createStreamingUpload;
+  encoder = new TextEncoder();
+  sequence = 0;
+  lastKnownAcceptedSeq = 0;
+  bufferedEvents = [];
+  flushTimer = null;
+  flushPromise = null;
+  streamClosePromise = null;
+  activeStream = null;
+  stopPromise = null;
+  stopped = false;
+  sequenceSynced = false;
+  sequenceInitialized = false;
+  transportCompleted = false;
+  droppedBeforeSequenceCount = 0;
+  bufferRevision = 0;
+  enqueue(event) {
+    if (this.stopped) return;
+    if (!this.canAcceptEvent(event)) {
+      return;
+    }
+    const envelope = {
+      seq: ++this.sequence,
+      event
+    };
+    this.bufferedEvents.push(envelope);
+    this.scheduleFlush();
+  }
+  async stop() {
+    if (this.stopPromise) {
+      await this.stopPromise;
+      return;
+    }
+    this.stopped = true;
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    this.stopPromise = this.drainForStop();
+    await this.stopPromise;
+  }
+  scheduleFlush(delayMs = this.flushDelayMs) {
+    if (this.flushTimer || this.flushPromise || this.stopped) return;
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = null;
+      void this.flush();
+    }, delayMs);
+  }
+  async drainForStop() {
+    const startedAtMs = Date.now();
+    const deadlineAtMs = startedAtMs + this.stopTimeoutMs;
+    while (!this.transportCompleted) {
+      const previousLength = this.bufferedEvents.length;
+      const previousRevision = this.bufferRevision;
+      try {
+        await this.flush();
+        await this.writeCompletionLine();
+        await this.closeActiveStream();
+        this.transportCompleted = true;
+        return;
+      } catch (error) {
+        this.config.logger.warn(
+          "Task run event ingest stop request failed",
+          this.describeError(error)
+        );
+      }
+      const madeProgress = this.bufferedEvents.length < previousLength || this.bufferRevision !== previousRevision;
+      if (!madeProgress && !await this.waitBeforeStopRetry(deadlineAtMs)) {
+        this.warnStopDeadlineReached(startedAtMs);
+        return;
+      }
+      if (Date.now() >= deadlineAtMs && !this.transportCompleted) {
+        this.warnStopDeadlineReached(startedAtMs);
+        return;
+      }
+    }
+  }
+  async flush() {
+    if (this.flushPromise) {
+      await this.flushPromise.catch(() => void 0);
+    }
+    if (this.bufferedEvents.length === 0) {
+      return true;
+    }
+    const previousBufferLength = this.bufferedEvents.length;
+    const flushPromise = this.flushBufferedEvents();
+    this.flushPromise = flushPromise;
+    try {
+      await flushPromise;
+      return this.bufferedEvents.length < previousBufferLength;
+    } catch (error) {
+      this.config.logger.warn(
+        "Task run event ingest stream write failed",
+        this.describeError(error)
+      );
+      await this.abortActiveStream();
+      if (!this.stopped) {
+        this.scheduleFlush(this.retryDelayMs);
+      }
+      return false;
+    } finally {
+      if (this.flushPromise === flushPromise) {
+        this.flushPromise = null;
+      }
+      if (!this.stopped && this.hasUnwrittenBufferedEvents()) {
+        this.scheduleFlush(0);
+      }
+    }
+  }
+  async flushBufferedEvents() {
+    while (true) {
+      const stream = await this.ensureActiveStream();
+      const nextEvent = this.bufferedEvents.find(
+        (event) => event.seq > stream.sentThroughSeq
+      );
+      if (!nextEvent) {
+        return;
+      }
+      const line = `${this.serializeEnvelope(nextEvent)}
+`;
+      const lineBytes = Buffer4.byteLength(line, "utf8");
+      if (this.shouldRollStreamBeforeWriting(stream, lineBytes)) {
+        await this.closeActiveStream();
+        continue;
+      }
+      await stream.upload.write(this.encoder.encode(line));
+      stream.sentThroughSeq = nextEvent.seq;
+      stream.sentEvents += 1;
+      stream.sentBytes += lineBytes;
+    }
+  }
+  hasUnwrittenBufferedEvents() {
+    const sentThroughSeq = this.activeStream?.sentThroughSeq ?? this.lastKnownAcceptedSeq;
+    return this.bufferedEvents.some((event) => event.seq > sentThroughSeq);
+  }
+  async writeCompletionLine() {
+    await this.syncSequenceWithServer();
+    while (true) {
+      const stream = await this.ensureActiveStream();
+      const hasUnwrittenEvents = this.bufferedEvents.some(
+        (event) => event.seq > stream.sentThroughSeq
+      );
+      if (hasUnwrittenEvents) {
+        await this.flushBufferedEvents();
+        continue;
+      }
+      const line = `${JSON.stringify({
+        type: STREAM_COMPLETE_CONTROL_TYPE,
+        final_seq: this.sequence
+      })}
+`;
+      const lineBytes = Buffer4.byteLength(line, "utf8");
+      if (this.shouldRollStreamBeforeWriting(stream, lineBytes, {
+        ignoreEventCount: true
+      })) {
+        await this.closeActiveStream();
+        continue;
+      }
+      await stream.upload.write(this.encoder.encode(line));
+      stream.sentBytes += lineBytes;
+      return;
+    }
+  }
+  shouldRollStreamBeforeWriting(stream, lineBytes, options = {}) {
+    if (!options.ignoreEventCount && stream.sentEvents > 0 && stream.sentEvents >= this.maxStreamEvents) {
+      return true;
+    }
+    if (stream.sentBytes > 0 && stream.sentBytes + lineBytes > this.maxStreamBytes) {
+      return true;
+    }
+    return Date.now() - stream.startedAtMs >= this.streamWindowMs;
+  }
+  async ensureActiveStream() {
+    if (this.streamClosePromise) {
+      await this.streamClosePromise.catch(() => void 0);
+    }
+    if (this.activeStream) {
+      return this.activeStream;
+    }
+    await this.syncSequenceWithServer();
+    const abortController = new AbortController();
+    const upload = this.createStreamingUpload({
+      url: this.ingestUrl,
+      headers: this.buildHeaders(),
+      abortController
+    });
+    const activeStream = {
+      abortController,
+      upload,
+      responsePromise: upload.responsePromise,
+      startedAtMs: Date.now(),
+      sentThroughSeq: this.lastKnownAcceptedSeq,
+      sentEvents: 0,
+      sentBytes: 0,
+      windowTimer: null
+    };
+    this.activeStream = activeStream;
+    this.scheduleStreamWindowClose(activeStream);
+    upload.responsePromise.catch((error) => {
+      void this.handleActiveStreamResponseFailure(activeStream, error);
+    });
+    return activeStream;
+  }
+  scheduleStreamWindowClose(stream, delayOverrideMs) {
+    this.clearStreamWindowClose(stream);
+    const delayMs = delayOverrideMs ?? Math.max(0, stream.startedAtMs + this.streamWindowMs - Date.now());
+    stream.windowTimer = setTimeout(() => {
+      stream.windowTimer = null;
+      void this.closeExpiredStream(stream);
+    }, delayMs);
+  }
+  clearStreamWindowClose(stream) {
+    if (!stream.windowTimer) {
+      return;
+    }
+    clearTimeout(stream.windowTimer);
+    stream.windowTimer = null;
+  }
+  async closeExpiredStream(stream) {
+    if (this.activeStream !== stream || this.stopped) {
+      return;
+    }
+    if (this.flushPromise) {
+      this.scheduleStreamWindowClose(stream, 50);
+      return;
+    }
+    try {
+      await this.closeActiveStream();
+    } catch (error) {
+      this.config.logger.warn(
+        "Task run event ingest stream window close failed",
+        this.describeError(error)
+      );
+      if (!this.stopped && this.bufferedEvents.length > 0) {
+        this.scheduleFlush(this.retryDelayMs);
+      }
+    }
+  }
+  async handleActiveStreamResponseFailure(stream, error) {
+    if (this.activeStream !== stream) {
+      return;
+    }
+    this.config.logger.warn(
+      "Task run event ingest stream request failed",
+      this.describeError(error)
+    );
+    try {
+      await this.abortActiveStream();
+    } catch (abortError2) {
+      this.config.logger.warn(
+        "Task run event ingest stream abort failed",
+        this.describeError(abortError2)
+      );
+    }
+    if (!this.stopped && this.bufferedEvents.length > 0) {
+      this.scheduleFlush(this.retryDelayMs);
+    }
+  }
+  async closeActiveStream() {
+    if (this.streamClosePromise) {
+      await this.streamClosePromise;
+      return;
+    }
+    const stream = this.activeStream;
+    if (!stream) {
+      return;
+    }
+    const closePromise = this.closeStream(stream);
+    this.streamClosePromise = closePromise;
+    try {
+      await closePromise;
+    } finally {
+      this.clearStreamWindowClose(stream);
+      if (this.activeStream === stream) {
+        this.activeStream = null;
+      }
+      if (this.streamClosePromise === closePromise) {
+        this.streamClosePromise = null;
+      }
+    }
+  }
+  async closeStream(stream) {
+    try {
+      await stream.upload.close();
+    } catch (error) {
+      stream.abortController.abort();
+      this.sequenceSynced = false;
+      throw error;
+    }
+    let response;
+    try {
+      response = await this.waitForResponseWithTimeout(
+        stream.responsePromise,
+        stream.abortController
+      );
+    } catch (error) {
+      stream.abortController.abort();
+      this.sequenceSynced = false;
+      throw error;
+    }
+    await this.applyIngestResponse(response, "Event ingest stream");
+    this.sequenceSynced = true;
+  }
+  async abortActiveStream() {
+    const stream = this.activeStream;
+    if (!stream) {
+      return;
+    }
+    stream.abortController.abort();
+    this.clearStreamWindowClose(stream);
+    try {
+      await stream.upload.abort();
+    } catch {
+    } finally {
+      if (this.activeStream === stream) {
+        this.activeStream = null;
+      }
+      this.sequenceSynced = false;
+    }
+  }
+  async waitBeforeStopRetry(deadlineAtMs) {
+    const remainingMs = deadlineAtMs - Date.now();
+    if (remainingMs <= 0) {
+      return false;
+    }
+    await new Promise(
+      (resolve8) => setTimeout(resolve8, Math.min(this.retryDelayMs, remainingMs))
+    );
+    return Date.now() < deadlineAtMs;
+  }
+  warnStopDeadlineReached(startedAtMs) {
+    this.config.logger.warn(
+      "Task run event ingest stop deadline reached before fully completing transport",
+      {
+        remaining: this.bufferedEvents.length,
+        stopTimeoutMs: this.stopTimeoutMs,
+        elapsedMs: Date.now() - startedAtMs
+      }
+    );
+  }
+  async syncSequenceWithServer() {
+    if (this.sequenceSynced) return;
+    const response = await this.fetchWithTimeout({
+      method: "POST",
+      headers: this.buildHeaders(),
+      body: ""
+    });
+    const responseBody = await this.parseResponse(response);
+    if (!response.ok) {
+      throw new Error(
+        `Event ingest sequence sync returned HTTP ${response.status}: ${responseBody.text.slice(0, 300)}`
+      );
+    }
+    const lastAcceptedSeq = responseBody.parsed?.last_accepted_seq;
+    if (typeof lastAcceptedSeq === "number" && lastAcceptedSeq > 0) {
+      if (!this.sequenceInitialized) {
+        this.bufferedEvents = this.bufferedEvents.map((event) => ({
+          ...event,
+          seq: event.seq + lastAcceptedSeq
+        }));
+        this.sequence += lastAcceptedSeq;
+        this.bufferRevision += 1;
+      } else {
+        this.acceptThrough(lastAcceptedSeq);
+        if (lastAcceptedSeq > this.sequence) {
+          this.sequence = lastAcceptedSeq;
+        }
+      }
+      this.lastKnownAcceptedSeq = lastAcceptedSeq;
+    }
+    this.sequenceSynced = true;
+    this.sequenceInitialized = true;
+  }
+  async fetchWithTimeout(init2) {
+    const abortController = new AbortController();
+    const timeout = setTimeout(() => {
+      abortController.abort();
+    }, this.requestTimeoutMs);
+    try {
+      return await fetch(this.ingestUrl, {
+        ...init2,
+        signal: abortController.signal
+      });
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  async waitForResponseWithTimeout(responsePromise, abortController) {
+    const timeout = setTimeout(() => {
+      abortController.abort();
+    }, this.requestTimeoutMs);
+    try {
+      return await responsePromise;
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  async applyIngestResponse(response, label) {
+    const responseBody = await this.parseResponse(response);
+    const lastAcceptedSeq = responseBody.parsed?.last_accepted_seq;
+    if (typeof lastAcceptedSeq === "number") {
+      this.acceptThrough(lastAcceptedSeq);
+      if (lastAcceptedSeq > this.sequence) {
+        this.sequence = lastAcceptedSeq;
+      }
+      this.lastKnownAcceptedSeq = lastAcceptedSeq;
+      if (response.status === 409) {
+        this.rebaseBufferedEvents(lastAcceptedSeq);
+      }
+    }
+    if (!response.ok) {
+      throw new Error(
+        `${label} returned HTTP ${response.status}: ${responseBody.text.slice(0, 300)}`
+      );
+    }
+  }
+  acceptThrough(lastAcceptedSeq) {
+    const previousLength = this.bufferedEvents.length;
+    this.bufferedEvents = this.bufferedEvents.filter(
+      (event) => event.seq > lastAcceptedSeq
+    );
+    if (this.bufferedEvents.length !== previousLength) {
+      this.bufferRevision += 1;
+    }
+  }
+  buildHeaders() {
+    return {
+      Authorization: `Bearer ${this.config.token}`,
+      "Content-Type": "application/x-ndjson"
+    };
+  }
+  rebaseBufferedEvents(lastAcceptedSeq) {
+    let nextSeq = lastAcceptedSeq + 1;
+    this.bufferedEvents = this.bufferedEvents.map((event) => ({
+      ...event,
+      seq: nextSeq++
+    }));
+    this.sequence = nextSeq - 1;
+    this.sequenceSynced = true;
+    this.sequenceInitialized = true;
+    this.lastKnownAcceptedSeq = lastAcceptedSeq;
+    this.bufferRevision += 1;
+  }
+  async parseResponse(response) {
+    const text2 = await response.text();
+    if (!text2) {
+      return { parsed: null, text: text2 };
+    }
+    try {
+      return { parsed: JSON.parse(text2), text: text2 };
+    } catch {
+      return { parsed: null, text: text2 };
+    }
+  }
+  canAcceptEvent(event) {
+    const eventBytes = Buffer4.byteLength(
+      this.serializeEnvelope({ seq: this.sequence + 1, event }),
+      "utf8"
+    );
+    if (eventBytes > this.maxEventBytes) {
+      this.config.logger.warn("Dropped oversized task run event", {
+        eventBytes,
+        maxEventBytes: this.maxEventBytes
+      });
+      return false;
+    }
+    if (this.bufferedEvents.length >= this.maxBufferedEvents) {
+      this.droppedBeforeSequenceCount += 1;
+      if (this.droppedBeforeSequenceCount === 1 || this.droppedBeforeSequenceCount % 100 === 0) {
+        this.config.logger.warn(
+          "Dropped task run event before assigning sequence due to backpressure",
+          {
+            dropped: this.droppedBeforeSequenceCount,
+            maxBufferedEvents: this.maxBufferedEvents
+          }
+        );
+      }
+      return false;
+    }
+    if (this.droppedBeforeSequenceCount > 0) {
+      this.config.logger.warn("Task run event ingest recovered after drops", {
+        dropped: this.droppedBeforeSequenceCount
+      });
+      this.droppedBeforeSequenceCount = 0;
+    }
+    return true;
+  }
+  serializeEnvelope(envelope) {
+    return JSON.stringify({ seq: envelope.seq, event: envelope.event });
+  }
+  describeError(error) {
+    if (error instanceof Error) {
+      return { message: error.message, stack: error.stack };
+    }
+    return error;
+  }
+};
+
 // src/server/jwt.ts
 import jwt from "jsonwebtoken";
 import { z as z3 } from "zod";
@@ -22714,6 +23379,7 @@ var AgentServer = class {
   session = null;
   app;
   posthogAPI;
+  eventStreamSender = null;
   questionRelayedToSlack = false;
   detectedPrUrl = null;
   lastReportedBranch = null;
@@ -22757,6 +23423,17 @@ var AgentServer = class {
       getApiKey: () => config.apiKey,
       userAgent: `posthog/cloud.hog.dev; version: ${config.version ?? package_default.version}`
     });
+    if (config.eventIngestToken) {
+      this.eventStreamSender = new TaskRunEventStreamSender({
+        apiUrl: config.apiUrl,
+        projectId: config.projectId,
+        taskId: config.taskId,
+        runId: config.runId,
+        token: config.eventIngestToken,
+        logger: this.logger.child("EventIngest"),
+        streamWindowMs: config.eventIngestStreamWindowMs
+      });
+    }
     this.app = this.createApp();
   }
   getRuntimeAdapter() {
@@ -22974,7 +23651,9 @@ var AgentServer = class {
   async stop() {
     this.logger.debug("Stopping agent server...");
     if (this.session) {
-      await this.cleanupSession();
+      await this.cleanupSession({ completeEventStream: true });
+    } else {
+      await this.eventStreamSender?.stop();
     }
     if (this.server) {
       this.server.close();
@@ -23924,6 +24603,11 @@ ${signedCommitInstructions}
       return;
     }
     const status = "failed";
+    this.enqueueTaskTerminalEvent(POSTHOG_NOTIFICATIONS.ERROR, {
+      source: "agent_server",
+      stopReason,
+      error: errorMessage2 ?? "Agent error"
+    });
     try {
       await this.posthogAPI.updateTaskRun(payload.task_id, payload.run_id, {
         status,
@@ -23932,8 +24616,21 @@ ${signedCommitInstructions}
       this.logger.debug("Task completion signaled", { status, stopReason });
     } catch (error) {
       this.logger.error("Failed to signal task completion", error);
+    } finally {
+      await this.eventStreamSender?.stop();
     }
   }
+  enqueueTaskTerminalEvent(method, params) {
+    this.eventStreamSender?.enqueue({
+      type: "notification",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      notification: {
+        jsonrpc: "2.0",
+        method,
+        params
+      }
+    });
+  }
   configureEnvironment({
     isInternal = false,
     originProduct,
@@ -24200,7 +24897,9 @@ ${signedCommitInstructions}
       });
     }
   }
-  async cleanupSession() {
+  async cleanupSession({
+    completeEventStream = false
+  } = {}) {
     if (!this.session) return;
     this.logger.debug("Cleaning up session");
     try {
@@ -24230,6 +24929,9 @@ ${signedCommitInstructions}
     if (this.session.sseController) {
       this.session.sseController.close();
     }
+    if (completeEventStream) {
+      await this.eventStreamSender?.stop();
+    }
     this.pendingEvents = [];
     this.lastReportedBranch = null;
     this.session = null;
@@ -24297,9 +24999,11 @@ ${signedCommitInstructions}
     );
   }
   broadcastEvent(event) {
+    if (!this.session) return;
+    this.eventStreamSender?.enqueue(event);
     if (this.session?.sseController) {
       this.sendSseEvent(this.session.sseController, event);
-    } else if (this.session) {
+    } else {
       this.pendingEvents.push(event);
     }
   }