@cursor/july 0.1.11 → 0.1.14

package/src/internal/server.ts

@@ -21,6 +21,7 @@ import {
   getGithubCursorAccountRuntime,
   parseCursorGithubRepoScope,
   resolveCursorGithubPermissions,
+  resolveCursorGithubProxyUrl,
 } from "../channels/github/cursor-account.js";
 import { findGitHubChannelTargets } from "../channels/github/forward.js";
 import {
@@ -80,7 +81,9 @@ import {
 import {
   EvalRunConflictError,
   EvalRunEmptyError,
+  EvalRunNotRunningError,
   EvalRunStore,
+  EvalRunUnknownError,
 } from "./eval-run-store.js";
 import {
   collectGitHubTriggerTargets,
@@ -251,8 +254,35 @@ export async function startServer(
       logger,
     });
     cursorGithubCredentials = provider;
-    for (const target of cursorGithubTargets) {
-      target.accountRuntime.credentials.bind(() => provider.getToken());
+    const githubProxyUrl =
+      options.cursorGithubProxy === true
+        ? resolveCursorGithubProxyUrl(cursorEventsAuth.baseUrl)
+        : undefined;
+    if (githubProxyUrl !== undefined) {
+      // Proxy mode: channel Octokit calls carry the Cursor API key to the
+      // backend forwarder, which swaps in the installation token server-side
+      // and logs every call with per-deployment attribution. The provider
+      // still runs so child `gh` processes get a `GH_TOKEN` lease (v1).
+      const proxyTransport = {
+        apiBaseUrl: githubProxyUrl,
+        headers: {
+          "x-cursor-github-repos": cursorGithubConfig.scope.repos.join(","),
+          "x-cursor-github-permissions": cursorGithubConfig.scope.permissions,
+        },
+      };
+      for (const target of cursorGithubTargets) {
+        target.accountRuntime.credentials.bind(
+          async () => cursorEventsAuth.apiKey
+        );
+        target.accountRuntime.credentials.bindProxyTransport(proxyTransport);
+      }
+      logger(
+        `[agentkit] GitHub auth: channel API calls route through ${githubProxyUrl}`
+      );
+    } else {
+      for (const target of cursorGithubTargets) {
+        target.accountRuntime.credentials.bind(() => provider.getToken());
+      }
     }
   }
   const resolvedCursorGithubCredentials = cursorGithubCredentials;
@@ -392,6 +422,7 @@ export async function startServer(
       get: (runId) => evalRuns.get(runId),
       listRunsWithActive: () => evalRuns.listRunsWithActive(),
       start: (input) => evalRuns.start(input),
+      cancel: (runId) => evalRuns.cancel(runId),
     });
     const runtime: MountedRuntime = {
       slug,
@@ -1171,6 +1202,42 @@ function mountAgentRoutes(
       return jsonResponse(snap);
     },
   });
+  router.add({
+    method: "POST",
+    pattern: `${base}/v1/dev/evals/runs/:runId/cancel`,
+    auth: httpAuth,
+    handler: async (_request, ctx) => {
+      const runId = ctx.params.runId ?? "";
+      try {
+        const snap = await runtime.evalRuns.cancel(runId);
+        return jsonResponse(snap);
+      } catch (error) {
+        if (error instanceof EvalRunUnknownError) {
+          return jsonResponse(
+            { ok: false, error: "unknown_eval_run" },
+            { status: 404 }
+          );
+        }
+        if (error instanceof EvalRunNotRunningError) {
+          return jsonResponse(
+            {
+              ok: false,
+              error: "eval_run_not_running",
+              runId: error.runId,
+              status: error.status,
+              message: error.message,
+            },
+            { status: 409 }
+          );
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        return jsonResponse(
+          { ok: false, error: "eval_cancel_failed", message },
+          { status: 400 }
+        );
+      }
+    },
+  });
 
   if (dev) {
     router.add({

package/src/internal/session-engine.ts

@@ -2335,6 +2335,25 @@ export class SessionEngine {
     }
   }
 
+  /**
+   * Local session lookup with lazy restore by session id.
+   *
+   * `GET /v1/sessions` (cursor-hosted) can list durable rows that were not
+   * bulk-restored into `--state-root` (restore caps, `restore: "off"`, or
+   * eval Open-trace by id). Events/stream/follow-up must materialize that
+   * one session before answering, or the playground shows an empty timeline
+   * after redeploy.
+   */
+  async getOrRestoreSession(
+    sessionId: string
+  ): Promise<SessionRecord | undefined> {
+    const local = await this.sessions.get(sessionId);
+    if (local !== undefined) {
+      return local;
+    }
+    return this.restoreSessionById(sessionId);
+  }
+
   /**
    * Lazy restore: a continuation lookup missed locally, so ask the sink
    * for that one session and materialize it before resuming. Disk grows
@@ -2367,6 +2386,24 @@ export class SessionEngine {
     return pending;
   }
 
+  private restoreSessionById(
+    sessionId: string
+  ): Promise<SessionRecord | undefined> {
+    const storage = this.storage;
+    if (storage === undefined) {
+      return Promise.resolve(undefined);
+    }
+    const key = `id\u0000${sessionId}`;
+    let pending = this.restoreInFlight.get(key);
+    if (pending === undefined) {
+      pending = this.loadAndMaterializeById(storage, sessionId).finally(() =>
+        this.restoreInFlight.delete(key)
+      );
+      this.restoreInFlight.set(key, pending);
+    }
+    return pending;
+  }
+
   private async loadAndMaterializeByContinuation(
     storage: StorageCoordinator,
     channelId: string,
@@ -2380,10 +2417,31 @@ export class SessionEngine {
       // Definitive miss: the caller starts a fresh session under this token.
       return undefined;
     }
+    return this.materializeRestoredRecord(record);
+  }
+
+  private async loadAndMaterializeById(
+    storage: StorageCoordinator,
+    sessionId: string
+  ): Promise<SessionRecord | undefined> {
+    const record = await storage.getSessionById(sessionId);
+    if (record === undefined) {
+      return undefined;
+    }
+    return this.materializeRestoredRecord(record);
+  }
+
+  private async materializeRestoredRecord(
+    record: SessionRecord
+  ): Promise<SessionRecord> {
     const local = await this.sessions.get(record.sessionId);
     if (local !== undefined) {
       return local;
     }
+    const storage = this.storage;
+    if (storage === undefined) {
+      return record;
+    }
     const events = await storage.listSessionEvents(record.sessionId);
     await this.materializeSession(record, eventsNdjson(events));
     this.logger(

package/src/internal/storage-coordinator.ts

@@ -329,6 +329,36 @@ export class StorageCoordinator {
     return events;
   }
 
+  /**
+   * One saved session by id (lazy restore for playground Open-trace /
+   * events / stream after a host replacement). Sink errors **propagate**
+   * — same posture as {@link getSessionByContinuation}. A definitive miss
+   * (no row, or a write-only sink without `get`) resolves undefined.
+   */
+  async getSessionById(sessionId: string): Promise<SessionRecord | undefined> {
+    const get = this.definition.get;
+    if (get === undefined) {
+      return undefined;
+    }
+    if (typeof sessionId !== "string" || sessionId === "") {
+      return undefined;
+    }
+    const ctx = this.context("restore");
+    const record = (await get(
+      storageKeys.session(this.agentName, sessionId),
+      ctx
+    )) as SessionRecord | null | undefined;
+    if (record == null) {
+      return undefined;
+    }
+    if (record.sessionId !== sessionId) {
+      throw new Error(
+        `storage returned a session that does not match the requested id ${sessionId}`
+      );
+    }
+    return record;
+  }
+
   /**
    * One saved session by channel continuation key (lazy restore). Unlike
    * the startup reads, sink errors **propagate**: a failing store must
@@ -363,11 +393,8 @@ export class StorageCoordinator {
         `storage returned a malformed continuation entry for channel ${channelId}`
       );
     }
-    const record = (await get(
-      storageKeys.session(this.agentName, sessionId),
-      ctx
-    )) as SessionRecord | null | undefined;
-    if (record == null) {
+    const record = await this.getSessionById(sessionId);
+    if (record === undefined) {
       // Index entry without its record (e.g. the record write was shed
       // under at-most-once). The session is unrecoverable; treat as a miss
       // so the conversation can continue rather than failing forever.
@@ -380,7 +407,6 @@ export class StorageCoordinator {
     // mismatched row is a broken store, not a miss; treating it as a miss
     // would fork the continuation token onto a new session.
     if (
-      record.sessionId !== sessionId ||
       record.channelId !== channelId ||
       record.continuationKey !== continuationKey
     ) {

package/src/types.ts

@@ -1974,6 +1974,16 @@ export interface ServeOptions {
    * SSO/Okta proxy in front of the host).
    */
   allowAnonymousCursorGithub?: boolean;
+  /**
+   * Route `githubChannel({ cursorAccount })` API calls through the Cursor
+   * backend's GitHub forwarder (`/v0/github-proxy`) instead of minting raw
+   * installation tokens into this process. The backend logs and meters every
+   * call with per-deployment attribution. `AGENT_SERVE_GITHUB_PROXY_URL`
+   * overrides the forwarder base URL (default: the resolved Cursor API base
+   * URL + `/v0/github-proxy`). Child `gh` processes still use a minted
+   * `GH_TOKEN` lease (proxying `gh` is a follow-up).
+   */
+  cursorGithubProxy?: boolean;
   /**
    * Allow {@link allowAnonymous} together with
    * `defineConnection({ cursorAccount: true })`. Without this opt-in, `serve`

package/dist/channels/slack/post-update-delivery.d.ts

@@ -1,85 +0,0 @@
-/**
- * Live-reply delivery strategies for the Slack default handlers.
- *
- * A single strategy owns how an in-progress reply is opened, updated,
- * finalized, and cleaned up so the handlers in `defaults.ts` don't fork on the
- * delivery mode at every event:
- *
- * - `stream`: Slack chat.startStream / appendStream / stopStream.
- * - `post-update`: a chat.postMessage skeleton edited with chat.update. This is
- *   the only path that preserves Cursor-account identity pinning (which only
- *   covers postMessage).
- *
- * `buildDefaultEvents` selects one via {@link selectLiveDeliveryStrategy} up
- * front and calls into it. All calls keep the same soft-fail / log behavior as
- * the inlined logic they replaced.
- */
-import type { ChannelEventContext } from "../../types.js";
-import type { SlackLog } from "./log.js";
-import type { SlackBotToken, SlackChannelState } from "./types.js";
-type SlackChannel = ChannelEventContext<SlackChannelState>;
-export interface LiveDeliveryDeps {
-    botToken: SlackBotToken | undefined;
-    getLog: () => SlackLog;
-}
-/**
- * How the default handlers deliver an in-progress reply. Methods write live
- * delivery state (`streamTs`, `streamChannelId`, `lastPostedText`,
- * `lastPostUpdateAtMs`, `streamingUnavailable`) on `channel.state` directly.
- */
-export interface LiveDeliveryStrategy {
-    /** True when tool-call thinking steps can be appended to the live message. */
-    readonly inlineToolSteps: boolean;
-    /** Open the live message (skeleton post / stream start). */
-    start(args: {
-        channel: SlackChannel;
-        channelId: string;
-        threadTs: string;
-        sessionId: string;
-    }): Promise<void>;
-    /** Push the latest cumulative text to the live message (throttled). */
-    append(args: {
-        channel: SlackChannel;
-        channelId: string;
-        streamTs: string;
-        text: string;
-        sessionId: string;
-    }): Promise<void>;
-    /**
-     * Flush the final reply text. `delivered` is false only when the caller must
-     * post the full reply as a fresh message (finalize failed on partial text).
-     */
-    finalize(args: {
-        channel: SlackChannel;
-        channelId: string;
-        streamTs: string;
-        text: string;
-        sessionId: string;
-    }): Promise<{
-        delivered: boolean;
-    }>;
-    /** Close the live message when the turn produced no final text. */
-    finalizeEmpty(args: {
-        channel: SlackChannel;
-        channelId: string;
-        streamTs: string;
-    }): Promise<void>;
-    /** Best-effort remove a live message left open after the turn ended. */
-    cleanupOrphan(args: {
-        channel: SlackChannel;
-    }): Promise<void>;
-    /** Deliver the error text into the live message; `delivered` gates a fallback post. */
-    fail(args: {
-        channel: SlackChannel;
-        channelId: string;
-        streamTs: string;
-        errorText: string;
-        sessionId: string;
-    }): Promise<{
-        delivered: boolean;
-    }>;
-}
-/** Pick the live-reply delivery strategy for a `buildDefaultEvents` instance. */
-export declare function selectLiveDeliveryStrategy(deps: LiveDeliveryDeps, usePostUpdate: boolean): LiveDeliveryStrategy;
-export {};
-//# sourceMappingURL=post-update-delivery.d.ts.map

package/dist/channels/slack/post-update-delivery.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"post-update-delivery.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/post-update-delivery.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAW1D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEzC,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEnE,KAAK,YAAY,GAAG,mBAAmB,CAAC,iBAAiB,CAAC,CAAC;AAE3D,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,aAAa,GAAG,SAAS,CAAC;IACpC,MAAM,EAAE,MAAM,QAAQ,CAAC;CACxB;AAED;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC,8EAA8E;IAC9E,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;IAClC,4DAA4D;IAC5D,KAAK,CAAC,IAAI,EAAE;QACV,OAAO,EAAE,YAAY,CAAC;QACtB,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,MAAM,CAAC;QACjB,SAAS,EAAE,MAAM,CAAC;KACnB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClB,uEAAuE;IACvE,MAAM,CAAC,IAAI,EAAE;QACX,OAAO,EAAE,YAAY,CAAC;QACtB,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,MAAM,CAAC;QACjB,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,EAAE,MAAM,CAAC;KACnB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClB;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE;QACb,OAAO,EAAE,YAAY,CAAC;QACtB,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,MAAM,CAAC;QACjB,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,EAAE,MAAM,CAAC;KACnB,GAAG,OAAO,CAAC;QAAE,SAAS,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IACpC,mEAAmE;IACnE,aAAa,CAAC,IAAI,EAAE;QAClB,OAAO,EAAE,YAAY,CAAC;QACtB,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,MAAM,CAAC;KAClB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClB,wEAAwE;IACxE,aAAa,CAAC,IAAI,EAAE;QAAE,OAAO,EAAE,YAAY,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9D,uFAAuF;IACvF,IAAI,CAAC,IAAI,EAAE;QACT,OAAO,EAAE,YAAY,CAAC;QACtB,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,MAAM,CAAC;QACjB,SAAS,EAAE,MAAM,CAAC;QAClB,SAAS,EAAE,MAAM,CAAC;KACnB,GAAG,OAAO,CAAC;QAAE,SAAS,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;CACrC;AA6RD,iFAAiF;AACjF,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,gBAAgB,EACtB,aAAa,EAAE,OAAO,GACrB,oBAAoB,CAItB"}

package/dist/channels/slack/post-update-delivery.js

@@ -1,318 +0,0 @@
-/**
- * Live-reply delivery strategies for the Slack default handlers.
- *
- * A single strategy owns how an in-progress reply is opened, updated,
- * finalized, and cleaned up so the handlers in `defaults.ts` don't fork on the
- * delivery mode at every event:
- *
- * - `stream`: Slack chat.startStream / appendStream / stopStream.
- * - `post-update`: a chat.postMessage skeleton edited with chat.update. This is
- *   the only path that preserves Cursor-account identity pinning (which only
- *   covers postMessage).
- *
- * `buildDefaultEvents` selects one via {@link selectLiveDeliveryStrategy} up
- * front and calls into it. All calls keep the same soft-fail / log behavior as
- * the inlined logic they replaced.
- */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { appendChatStream, deleteMessage, postMessage, setThreadStatus, startChatStream, stopChatStream, updateMessage, } from "./api.js";
-import { SLACK_POST_UPDATE_MIN_INTERVAL_MS } from "./constants.js";
-import { computeStreamAppend } from "./stream.js";
-function createPostUpdateStrategy(deps) {
-    const { botToken, getLog } = deps;
-    return {
-        inlineToolSteps: false,
-        start(_a) {
-            return __awaiter(this, arguments, void 0, function* ({ channel, channelId, threadTs, sessionId }) {
-                const log = getLog();
-                try {
-                    const posted = yield postMessage({
-                        botToken,
-                        channel: channelId,
-                        text: "…",
-                        threadTs,
-                    });
-                    if (posted.ts !== "") {
-                        channel.state.streamTs = posted.ts;
-                        channel.state.streamChannelId = channelId;
-                        channel.state.lastPostedText = "";
-                        log.info("postMessage skeleton ok", {
-                            channel: channelId,
-                            message_ts: posted.ts,
-                            session: sessionId,
-                        });
-                    }
-                }
-                catch (error) {
-                    log.warn("postMessage skeleton failed", {
-                        error: error instanceof Error ? error.message : String(error),
-                        channel: channelId,
-                        session: sessionId,
-                    });
-                    // Transient proxy/network failures must not permanently disable
-                    // live delivery — only the stream path sets streamingUnavailable
-                    // when Slack reports the feature unsupported.
-                }
-            });
-        },
-        append(_a) {
-            return __awaiter(this, arguments, void 0, function* ({ channel, channelId, streamTs, text, sessionId }) {
-                var _b;
-                const now = Date.now();
-                const isFirstUpdate = channel.state.lastPostedText === null ||
-                    channel.state.lastPostedText === "";
-                const lastAt = (_b = channel.state.lastPostUpdateAtMs) !== null && _b !== void 0 ? _b : 0;
-                const due = isFirstUpdate || now - lastAt >= SLACK_POST_UPDATE_MIN_INTERVAL_MS;
-                if (!due) {
-                    // Skip intermediate update; message.completed flushes full text.
-                    return;
-                }
-                const result = yield updateMessage({
-                    botToken,
-                    channel: channelId,
-                    ts: streamTs,
-                    text,
-                });
-                if (!result.ok) {
-                    getLog().warn("chat.update failed", {
-                        error: result.error,
-                        channel: channelId,
-                        message_ts: streamTs,
-                        session: sessionId,
-                    });
-                    return;
-                }
-                channel.state.lastPostUpdateAtMs = now;
-                channel.state.lastPostedText = text;
-            });
-        },
-        finalize(_a) {
-            return __awaiter(this, arguments, void 0, function* ({ channel, channelId, streamTs, text, sessionId }) {
-                const log = getLog();
-                const result = yield updateMessage({
-                    botToken,
-                    channel: channelId,
-                    ts: streamTs,
-                    text,
-                });
-                channel.state.streamTs = null;
-                if (result.ok) {
-                    channel.state.lastPostedText = text;
-                    log.info("reply delivered via chat.update", {
-                        channel: channelId,
-                        message_ts: streamTs,
-                        session: sessionId,
-                        chars: text.length,
-                    });
-                    return { delivered: true };
-                }
-                log.warn("chat.update finalize failed; falling back to postMessage", {
-                    error: result.error,
-                    channel: channelId,
-                    message_ts: streamTs,
-                    session: sessionId,
-                });
-                // Only suppress the fallback when the skeleton already holds the exact
-                // final text. Partial updates must not permanently truncate.
-                if (channel.state.lastPostedText === text) {
-                    return { delivered: true };
-                }
-                // The skeleton still shows the placeholder or a stale partial and we're
-                // about to post the full reply as a fresh message. Best-effort delete the
-                // orphan so the thread doesn't show a duplicate.
-                yield deleteMessage({ botToken, channel: channelId, ts: streamTs });
-                return { delivered: false };
-            });
-        },
-        finalizeEmpty(_a) {
-            return __awaiter(this, arguments, void 0, function* ({ channelId, streamTs }) {
-                yield updateMessage({
-                    botToken,
-                    channel: channelId,
-                    ts: streamTs,
-                    text: " ",
-                });
-            });
-        },
-        cleanupOrphan(_a) {
-            return __awaiter(this, arguments, void 0, function* ({ channel }) {
-                var _b;
-                // A skeleton that was never finalized (e.g. an empty turn that produced
-                // no message.completed) would otherwise linger as a "…" placeholder
-                // forever. Best-effort delete it and clear typing.
-                const orphanTs = channel.state.streamTs;
-                if (orphanTs === null || orphanTs === "") {
-                    return;
-                }
-                const orphanChannelId = (_b = channel.state.streamChannelId) !== null && _b !== void 0 ? _b : channel.state.channelId;
-                if (orphanChannelId !== null && orphanChannelId !== "") {
-                    yield deleteMessage({
-                        botToken,
-                        channel: orphanChannelId,
-                        ts: orphanTs,
-                    });
-                }
-                channel.state.streamTs = null;
-                if (channel.state.channelId !== null && channel.state.threadTs !== null) {
-                    yield setThreadStatus({
-                        botToken,
-                        channelId: channel.state.channelId,
-                        threadTs: channel.state.threadTs,
-                        status: "",
-                    });
-                }
-            });
-        },
-        fail(_a) {
-            return __awaiter(this, arguments, void 0, function* ({ channel, channelId, streamTs, errorText }) {
-                const updated = yield updateMessage({
-                    botToken,
-                    channel: channelId,
-                    ts: streamTs,
-                    text: errorText,
-                });
-                channel.state.streamTs = null;
-                return { delivered: updated.ok };
-            });
-        },
-    };
-}
-function createStreamStrategy(deps) {
-    const { botToken, getLog } = deps;
-    return {
-        inlineToolSteps: true,
-        start(_a) {
-            return __awaiter(this, arguments, void 0, function* ({ channel, channelId, threadTs, sessionId }) {
-                const log = getLog();
-                const started = yield startChatStream({
-                    botToken,
-                    channel: channelId,
-                    thread_ts: threadTs,
-                    markdown_text: "",
-                });
-                if (!started.ok) {
-                    log.warn("chat.startStream unavailable", {
-                        error: started.error,
-                        channel: channelId,
-                        thread_ts: threadTs,
-                        session: sessionId,
-                    });
-                    if (started.unsupported === true) {
-                        channel.state.streamingUnavailable = true;
-                    }
-                    return;
-                }
-                channel.state.streamTs = started.ts;
-                channel.state.streamChannelId = started.channel;
-                channel.state.lastPostedText = "";
-                log.info("chat.startStream ok", {
-                    channel: started.channel,
-                    stream_ts: started.ts,
-                    session: sessionId,
-                });
-            });
-        },
-        append(_a) {
-            return __awaiter(this, arguments, void 0, function* ({ channel, channelId, streamTs, text, sessionId }) {
-                const appendText = computeStreamAppend(channel.state.lastPostedText, text);
-                if (appendText === "") {
-                    return;
-                }
-                const result = yield appendChatStream({
-                    botToken,
-                    channel: channelId,
-                    ts: streamTs,
-                    markdown_text: appendText,
-                });
-                if (!result.ok) {
-                    getLog().warn("appendStream failed", {
-                        error: result.error,
-                        channel: channelId,
-                        stream_ts: streamTs,
-                        session: sessionId,
-                    });
-                    if (result.unsupported === true) {
-                        channel.state.streamingUnavailable = true;
-                    }
-                    return;
-                }
-                channel.state.lastPostedText = text;
-            });
-        },
-        finalize(_a) {
-            return __awaiter(this, arguments, void 0, function* ({ channel, channelId, streamTs, text, sessionId }) {
-                const log = getLog();
-                // Only send the unsent suffix — full text was already appended.
-                const appendText = computeStreamAppend(channel.state.lastPostedText, text);
-                const stopped = yield stopChatStream({
-                    botToken,
-                    channel: channelId,
-                    ts: streamTs,
-                    markdown_text: appendText === "" ? undefined : appendText,
-                });
-                if (stopped.ok) {
-                    channel.state.streamTs = null;
-                    channel.state.lastPostedText = text;
-                    log.info("reply delivered via stream", {
-                        channel: channelId,
-                        stream_ts: streamTs,
-                        session: sessionId,
-                        chars: text.length,
-                    });
-                    return { delivered: true };
-                }
-                log.warn("chat.stopStream failed; falling back to postMessage", {
-                    error: stopped.error,
-                    channel: channelId,
-                    stream_ts: streamTs,
-                    session: sessionId,
-                });
-                if (stopped.unsupported === true) {
-                    channel.state.streamingUnavailable = true;
-                }
-                channel.state.streamTs = null;
-                // If we already streamed content, do not post the full reply again.
-                const alreadyStreamed = typeof channel.state.lastPostedText === "string" &&
-                    channel.state.lastPostedText.length > 0;
-                return { delivered: alreadyStreamed };
-            });
-        },
-        finalizeEmpty(_a) {
-            return __awaiter(this, arguments, void 0, function* ({ channelId, streamTs }) {
-                yield stopChatStream({ botToken, channel: channelId, ts: streamTs });
-            });
-        },
-        cleanupOrphan() {
-            return __awaiter(this, void 0, void 0, function* () {
-                // The stream path closes its message in message.completed / turn.failed;
-                // there is nothing to clean up after turn.completed.
-            });
-        },
-        fail(_a) {
-            return __awaiter(this, arguments, void 0, function* ({ channel, channelId, streamTs, errorText }) {
-                const stopped = yield stopChatStream({
-                    botToken,
-                    channel: channelId,
-                    ts: streamTs,
-                    markdown_text: errorText,
-                });
-                channel.state.streamTs = null;
-                return { delivered: stopped.ok };
-            });
-        },
-    };
-}
-/** Pick the live-reply delivery strategy for a `buildDefaultEvents` instance. */
-export function selectLiveDeliveryStrategy(deps, usePostUpdate) {
-    return usePostUpdate
-        ? createPostUpdateStrategy(deps)
-        : createStreamStrategy(deps);
-}