@cursor/july 0.1.109 → 0.1.111

package/src/internal/session-run-log.ts

@@ -148,7 +148,7 @@ export async function flushSessionRunFatal(error: unknown): Promise<void> {
   }
   await Promise.race([
     fatalFlush(error).catch(() => undefined),
-    new Promise<void>((resolve) => {
+    new Promise<void>(resolve => {
       setTimeout(resolve, SESSION_RUN_FATAL_FLUSH_TIMEOUT_MS);
     }),
   ]);
@@ -187,7 +187,7 @@ export function snapshotSessionRunLogs(
   entries: readonly LogRingEntry[]
 ): LogRingEntry[] {
   const tail = entries.slice(-SESSION_RUN_LOG_MAX_ENTRIES);
-  return tail.map((entry) => ({
+  return tail.map(entry => ({
     index: entry.index,
     at: entry.at,
     line: boundedText(entry.line, SESSION_RUN_LOG_MAX_LINE_CHARS),
@@ -340,7 +340,7 @@ function upsertExecution(
   next: SessionRunExecution
 ): SessionRunExecution[] {
   const executions = existing.filter(
-    (entry) => entry.executionId !== next.executionId
+    entry => entry.executionId !== next.executionId
   );
   executions.push(next);
   executions.sort((a, b) => a.writtenAt.localeCompare(b.writtenAt));
@@ -358,9 +358,7 @@ function shrinkSessionDocument(
   };
   let serialized = JSON.stringify(next);
   while (serialized.length > MAX_DOCUMENT_CHARS) {
-    const oldestWithLogs = executions.findIndex(
-      (entry) => entry.logs.length > 0
-    );
+    const oldestWithLogs = executions.findIndex(entry => entry.logs.length > 0);
     if (oldestWithLogs >= 0) {
       const entry = executions[oldestWithLogs]!;
       executions = executions.map((item, index) =>

package/src/internal/session-store.ts

@@ -2,12 +2,26 @@
  * Persisted session registry. Each session lives at
  * `<stateRoot>/sessions/<sessionId>/` with a `session.json` record, an
  * `events.ndjson` log, and a `workspace/` directory. Continuation keys are
- * indexed in memory (hydrated by scanning session records on first use) so
- * channels can address sessions by their channel-local token.
+ * indexed in memory so channels can address sessions by their channel-local
+ * token.
+ *
+ * The directory is the source of truth and the in-memory maps are a cache:
+ * another process may create and update sessions behind this one's back (the
+ * two version containers of a persistent deployment during a redeploy, or an
+ * old process still exiting after a restart). A lookup that would otherwise
+ * conclude "no such session" rescans the directory first, listings pick up
+ * new directories, and a cached record is re-read when its file changed.
  */
 
 import { randomBytes } from "node:crypto";
-import { mkdir, readdir, readFile, rename, writeFile } from "node:fs/promises";
+import {
+  mkdir,
+  readdir,
+  readFile,
+  rename,
+  stat,
+  writeFile,
+} from "node:fs/promises";
 import { join } from "node:path";
 import type { SessionRecord } from "../types.js";
 import { isSafeSessionId } from "./auth.js";
@@ -16,7 +30,13 @@ import { isV2DurableContinuationKey } from "./continuation-identity.js";
 export class SessionStore {
   private readonly cache = new Map<string, SessionRecord>();
   private readonly continuationIndex = new Map<string, string>();
+  /**
+   * Identity of the `session.json` each cached record was read from, to
+   * notice a peer's writes. Absent while our own `save` is still writing.
+   */
+  private readonly stamps = new Map<string, string>();
   private hydrated: Promise<void> | undefined;
+  private scanning: Promise<void> | undefined;
 
   constructor(private readonly sessionsDir: string) {}
 
@@ -48,28 +68,58 @@ export class SessionStore {
     return `${channelId}\n${key}`;
   }
 
-  private async hydrate(): Promise<void> {
+  /**
+   * Bring the cache in line with the directory: load records for session
+   * directories not seen yet, drop records whose file is gone, and re-read
+   * records whose file changed. Callers arriving while a scan is running
+   * share it rather than queueing another.
+   */
+  private scan(): Promise<void> {
+    if (this.scanning === undefined) {
+      this.scanning = this.rescan().finally(() => {
+        this.scanning = undefined;
+      });
+      this.hydrated ??= this.scanning;
+    }
+    return this.scanning;
+  }
+
+  private async rescan(): Promise<void> {
     let entries: string[];
     try {
       entries = await readdir(this.sessionsDir);
-    } catch {
-      return;
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
+        // Unreadable for a reason other than absence: keep what we have
+        // rather than forgetting sessions we cannot currently list.
+        return;
+      }
+      // No directory means no sessions; the cache must not outlive it.
+      entries = [];
     }
+    const present = new Set<string>();
     for (const sessionId of entries) {
-      if (!isSafeSessionId(sessionId) || this.cache.has(sessionId)) {
+      if (!isSafeSessionId(sessionId)) {
         continue;
       }
-      const record = await this.readRecord(sessionId);
-      if (record !== undefined) {
-        this.cache.set(sessionId, record);
-        this.indexRecord(record);
+      present.add(sessionId);
+      if (this.cache.has(sessionId)) {
+        await this.refreshIfChanged(sessionId);
+        continue;
+      }
+      await this.load(sessionId);
+    }
+    // The listing is a snapshot: a session saved since it was taken is not
+    // in `present` but is on disk, so ask the file rather than the listing.
+    for (const sessionId of [...this.cache.keys()]) {
+      if (!present.has(sessionId)) {
+        await this.refreshIfChanged(sessionId);
       }
     }
   }
 
   private async ensureHydrated(): Promise<void> {
-    this.hydrated ??= this.hydrate();
-    await this.hydrated;
+    await (this.hydrated ?? this.scan());
   }
 
   private async readRecord(
@@ -86,6 +136,125 @@ export class SessionStore {
     }
   }
 
+  /**
+   * Identity of the file at `path`: inode plus mtime, so two renames within
+   * one clock tick still read as different. Undefined when there is no
+   * file; any other failure propagates.
+   */
+  private async stampOf(path: string): Promise<string | undefined> {
+    try {
+      const info = await stat(path);
+      return `${info.ino}:${info.mtimeMs}`;
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+        return undefined;
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Read a record from disk into the cache; returns it when present. The
+   * stamp is taken before the read so a write landing in between leaves a
+   * stale stamp, and the next lookup re-reads, rather than a fresh stamp on
+   * stale bytes.
+   */
+  private async load(sessionId: string): Promise<SessionRecord | undefined> {
+    if (!isSafeSessionId(sessionId)) {
+      return undefined;
+    }
+    const stamp = await this.stampOf(this.recordPath(sessionId)).catch(
+      () => undefined
+    );
+    if (stamp === undefined) {
+      return undefined;
+    }
+    const record = await this.readRecord(sessionId);
+    if (record === undefined) {
+      return undefined;
+    }
+    this.remember(record, stamp);
+    return record;
+  }
+
+  private async refreshIfChanged(sessionId: string): Promise<void> {
+    let stamp: string | undefined;
+    try {
+      stamp = await this.stampOf(this.recordPath(sessionId));
+    } catch {
+      // Unreadable for a reason other than absence: keep what we have.
+      return;
+    }
+    if (stamp === undefined) {
+      // No file for a record we never stamped is our own `save` still
+      // writing it, not a deletion.
+      if (this.stamps.has(sessionId)) {
+        this.evict(sessionId);
+      }
+      return;
+    }
+    if (stamp !== this.stamps.get(sessionId)) {
+      await this.load(sessionId);
+    }
+  }
+
+  private remember(record: SessionRecord, stamp: string | undefined): void {
+    const previous = this.cache.get(record.sessionId);
+    this.cache.set(record.sessionId, record);
+    if (stamp !== undefined) {
+      this.stamps.set(record.sessionId, stamp);
+    }
+    if (
+      previous !== undefined &&
+      previous.continuationKey !== null &&
+      previous.continuationKey !== record.continuationKey
+    ) {
+      this.unindex(previous);
+    }
+    this.indexRecord(record);
+  }
+
+  private evict(sessionId: string): void {
+    const previous = this.cache.get(sessionId);
+    this.cache.delete(sessionId);
+    this.stamps.delete(sessionId);
+    if (previous?.continuationKey != null) {
+      this.unindex(previous);
+    }
+  }
+
+  /**
+   * Drop `record`'s claim on its continuation key. The index holds one
+   * session per key; if another cached session still carries the same key
+   * (a replacement created before the old one was re-keyed, or a peer's
+   * write we learned of in this order), it takes the slot so the key does
+   * not go dark until a restart.
+   */
+  private unindex(record: SessionRecord): void {
+    if (record.continuationKey === null) {
+      return;
+    }
+    const indexKey = this.continuationKeyOf(
+      record.channelId,
+      record.continuationKey
+    );
+    if (this.continuationIndex.get(indexKey) !== record.sessionId) {
+      return;
+    }
+    this.continuationIndex.delete(indexKey);
+    for (const other of this.cache.values()) {
+      if (
+        other.sessionId !== record.sessionId &&
+        other.continuationKey !== null &&
+        this.continuationKeyOf(other.channelId, other.continuationKey) ===
+          indexKey
+      ) {
+        this.continuationIndex.set(indexKey, other.sessionId);
+        return;
+      }
+    }
+  }
+
   private indexRecord(record: SessionRecord): void {
     if (record.continuationKey !== null) {
       this.continuationIndex.set(
@@ -99,20 +268,15 @@ export class SessionStore {
     if (!isSafeSessionId(sessionId)) {
       return undefined;
     }
-    const cached = this.cache.get(sessionId);
-    if (cached !== undefined) {
-      return cached;
+    if (this.cache.has(sessionId)) {
+      await this.refreshIfChanged(sessionId);
+      return this.cache.get(sessionId);
     }
-    const record = await this.readRecord(sessionId);
-    if (record !== undefined) {
-      this.cache.set(sessionId, record);
-      this.indexRecord(record);
-    }
-    return record;
+    return this.load(sessionId);
   }
 
   async list(): Promise<SessionRecord[]> {
-    await this.ensureHydrated();
+    await this.scan();
     return [...this.cache.values()].sort((a, b) =>
       a.createdAt.localeCompare(b.createdAt)
     );
@@ -123,31 +287,41 @@ export class SessionStore {
     key: string
   ): Promise<SessionRecord | undefined> {
     await this.ensureHydrated();
-    const sessionId = this.continuationIndex.get(
-      this.continuationKeyOf(channelId, key)
-    );
-    return sessionId === undefined ? undefined : this.get(sessionId);
+    const indexKey = this.continuationKeyOf(channelId, key);
+    const lookup = async (): Promise<SessionRecord | undefined> => {
+      const sessionId = this.continuationIndex.get(indexKey);
+      if (sessionId === undefined) {
+        return undefined;
+      }
+      const record = await this.get(sessionId);
+      // `get` may have re-read the record and found its continuation moved,
+      // or evicted it; either way this hit is stale.
+      return record?.continuationKey === key ? record : undefined;
+    };
+    const found = await lookup();
+    if (found !== undefined) {
+      return found;
+    }
+    // A miss or a stale hit: another process may have created or re-keyed a
+    // session since the last scan. Rescan once and retry.
+    await this.scan();
+    return lookup();
   }
 
   async save(record: SessionRecord): Promise<void> {
-    const previous = this.cache.get(record.sessionId);
-    if (
-      previous !== undefined &&
-      previous.continuationKey !== null &&
-      previous.continuationKey !== record.continuationKey
-    ) {
-      this.continuationIndex.delete(
-        this.continuationKeyOf(previous.channelId, previous.continuationKey)
-      );
-    }
-    this.cache.set(record.sessionId, record);
-    this.indexRecord(record);
+    this.remember(record, undefined);
 
     const dir = this.sessionDir(record.sessionId);
     await mkdir(dir, { recursive: true });
     const finalPath = this.recordPath(record.sessionId);
     const tmpPath = `${finalPath}.${randomBytes(4).toString("hex")}.tmp`;
     await writeFile(tmpPath, `${JSON.stringify(record, null, 2)}\n`, "utf8");
+    // Stamp the bytes we wrote, not whatever is at `finalPath` afterwards:
+    // rename keeps inode and mtime, and a peer landing right behind us must
+    // read as a change. Remember again so a concurrent read that loaded the
+    // peer's earlier file does not leave the cache pointing at it.
+    const stamp = await this.stampOf(tmpPath);
     await rename(tmpPath, finalPath);
+    this.remember(record, stamp);
   }
 }

package/src/internal/sessions-client.ts

@@ -194,7 +194,7 @@ export function pickPreviousSession(
   sessions: readonly SessionSummary[]
 ): SessionSummary | undefined {
   const followable = sessions.filter(
-    (s) => typeof s.continuationToken === "string" && s.continuationToken !== ""
+    s => typeof s.continuationToken === "string" && s.continuationToken !== ""
   );
   if (followable.length === 0) {
     return undefined;
@@ -238,7 +238,7 @@ export function formatSessionsTable(
     return `${sourceLine}No sessions.\n`;
   }
   const header = ["SESSION", "CHANNEL", "MODE", "TURNS", "RUNNING", "UPDATED"];
-  const rows = sessions.map((s) => [
+  const rows = sessions.map(s => [
     s.sessionId,
     s.channelId,
     s.mode,
@@ -251,7 +251,7 @@ export function formatSessionsTable(
 
 function renderTable(header: string[], rows: string[][]): string {
   const widths = header.map((h, i) =>
-    Math.max(h.length, ...rows.map((row) => (row[i] ?? "").length))
+    Math.max(h.length, ...rows.map(row => (row[i] ?? "").length))
   );
   const renderRow = (row: string[]): string =>
     row

package/src/internal/slack-thread-key.ts

@@ -0,0 +1,11 @@
+/**
+ * Slack IM ids are `D…`. Those conversations are the channel, not a thread.
+ * Channel mentions stay `{channelId}:{threadTs}`.
+ */
+export function isSlackImChannel(channelId: string): boolean {
+  return channelId.startsWith("D");
+}
+
+export function slackThreadKey(channelId: string, threadTs: string): string {
+  return isSlackImChannel(channelId) ? channelId : `${channelId}:${threadTs}`;
+}

package/src/internal/sleep.ts

@@ -1,3 +1,3 @@
 export function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise(resolve => setTimeout(resolve, ms));
 }

package/src/internal/storage-coordinator.ts

@@ -68,6 +68,9 @@ const CLOSE_DRAIN_TIMEOUT_MS = 10_000;
 /** Debounced event batching flushes early past this many buffered events. */
 const DEBOUNCE_MAX_BATCH = 200;
 
+/** Cap on the per-session acked-record dedupe cache (oldest-out). */
+const MAX_ACKED_RECORDS = 5_000;
+
 /** One queued sink call (KV put/delete or a dedicated-table write). */
 interface StorageOp {
   /** Human-readable op label for failure logs, e.g. `put({root}/...)`. */
@@ -94,9 +97,9 @@ interface SessionBuffer {
 /** Session records out of raw sink entries; rows without a usable id are dropped. */
 function sessionRecordsOf(entries: readonly StorageEntry[]): SessionRecord[] {
   return entries
-    .map((entry) => entry.value as unknown as SessionRecord)
+    .map(entry => entry.value as unknown as SessionRecord)
     .filter(
-      (record) =>
+      record =>
         record != null &&
         typeof record.sessionId === "string" &&
         record.sessionId !== ""
@@ -120,6 +123,15 @@ export class StorageCoordinator
    * change emits a delete for the stale index entry alongside the new put.
    */
   private readonly continuationIndex = new Map<string, string | null>();
+  /**
+   * Serialized form of the last session record each session **successfully**
+   * wrote, so a flush whose record is byte-identical skips the rewrite (the
+   * record rides every flush, changed or not). Keyed on acknowledged writes
+   * only: a failed write clears the entry, so at-most-once delivery never
+   * turns into never-delivered. Bounded; eviction only costs a redundant
+   * rewrite.
+   */
+  private readonly lastAckedRecordJson = new Map<string, string>();
   /** Single delivery chain: writes reach the sink serialized, in order. */
   private queue: Promise<void> = Promise.resolve();
   /** Ops on the queue not yet delivered (bounded by MAX_PENDING_OPS). */
@@ -205,22 +217,33 @@ export class StorageCoordinator
       clearTimeout(buffer.debounceTimer);
     }
     const ops: StorageOp[] = [];
+    const puts: Array<{ key: string; value: JsonValue }> = [];
     const first = buffer.events[0];
     if (first !== undefined) {
-      ops.push(
-        this.putOp(
-          this.keys.sessionEvents(this.agentName, sessionId, first.index),
-          buffer.events as unknown as JsonValue
-        )
-      );
+      puts.push({
+        key: this.keys.sessionEvents(this.agentName, sessionId, first.index),
+        value: buffer.events as unknown as JsonValue,
+      });
+    }
+    /** Set after the record write is acknowledged; undefined = no record write. */
+    let recordAck: { sessionId: string; json: string } | undefined;
+    if (buffer.record !== undefined) {
+      const recordJson = JSON.stringify(buffer.record);
+      if (this.lastAckedRecordJson.get(sessionId) === recordJson) {
+        // Byte-identical to the last acknowledged write: rewriting it buys
+        // nothing. Events and continuation index still flush normally.
+      } else {
+        puts.push({
+          key: this.keys.session(this.agentName, sessionId),
+          value: JSON.parse(recordJson) as JsonValue,
+        });
+        recordAck = { sessionId, json: recordJson };
+      }
+    }
+    if (puts.length > 0) {
+      ops.push(this.putsOp(puts, recordAck));
     }
     if (buffer.record !== undefined) {
-      ops.push(
-        this.putOp(
-          this.keys.session(this.agentName, sessionId),
-          buffer.record as unknown as JsonValue
-        )
-      );
       ops.push(...this.continuationOps(buffer.record));
     }
     if (ops.length > 0) {
@@ -228,6 +251,80 @@ export class StorageCoordinator
     }
   }
 
+  /**
+   * One queued op covering every put of a flush. When the sink offers
+   * `putMany`, the whole flush is one backend round trip (on the hosted
+   * file store: one presign call instead of one per key); otherwise the
+   * puts run sequentially, exactly as before. Failures stay per-key —
+   * logged and dropped (at-most-once), never failing batch siblings.
+   */
+  private putsOp(
+    puts: Array<{ key: string; value: JsonValue }>,
+    recordAck: { sessionId: string; json: string } | undefined
+  ): StorageOp {
+    const recordKey =
+      recordAck === undefined
+        ? undefined
+        : this.keys.session(this.agentName, recordAck.sessionId);
+    const settleRecord = (failed: boolean): void => {
+      if (recordAck === undefined) {
+        return;
+      }
+      if (failed) {
+        this.lastAckedRecordJson.delete(recordAck.sessionId);
+        return;
+      }
+      if (this.lastAckedRecordJson.size >= MAX_ACKED_RECORDS) {
+        const oldest = this.lastAckedRecordJson.keys().next();
+        if (!oldest.done) {
+          this.lastAckedRecordJson.delete(oldest.value);
+        }
+      }
+      this.lastAckedRecordJson.set(recordAck.sessionId, recordAck.json);
+    };
+    const putMany = this.definition.putMany?.bind(this.definition);
+    if (putMany !== undefined) {
+      return {
+        label: `putMany(${puts.map(entry => entry.key).join(", ")})`,
+        run: async ctx => {
+          const results = await putMany(puts, ctx);
+          let recordFailed = false;
+          for (const result of results) {
+            if (result.error === undefined) {
+              continue;
+            }
+            if (result.key === recordKey) {
+              recordFailed = true;
+            }
+            this.logger(
+              `[agent-sdk] storage put(${result.key}) failed: ${describeError(result.error)}`
+            );
+          }
+          settleRecord(recordFailed);
+        },
+      };
+    }
+    return {
+      label: `put(${puts.map(entry => entry.key).join(", ")})`,
+      run: async ctx => {
+        let recordFailed = false;
+        for (const entry of puts) {
+          try {
+            await this.definition.put(entry.key, entry.value, ctx);
+          } catch (error) {
+            if (entry.key === recordKey) {
+              recordFailed = true;
+            }
+            this.logger(
+              `[agent-sdk] storage put(${entry.key}) failed: ${describeError(error)}`
+            );
+          }
+        }
+        settleRecord(recordFailed);
+      },
+    };
+  }
+
   /**
    * Index maintenance for `continuation/{channelId}/{token}` → sessionId:
    * put the current token, delete the previous one when it changed.
@@ -262,7 +359,7 @@ export class StorageCoordinator
   private putOp(key: string, value: JsonValue): StorageOp {
     return {
       label: `put(${key})`,
-      run: (ctx) => this.definition.put(key, value, ctx),
+      run: ctx => this.definition.put(key, value, ctx),
     };
   }
 
@@ -270,7 +367,7 @@ export class StorageCoordinator
   private deleteOp(key: string): StorageOp {
     return {
       label: `delete(${key})`,
-      run: (ctx) => this.definition.delete?.(key, ctx),
+      run: ctx => this.definition.delete?.(key, ctx),
     };
   }
 
@@ -299,8 +396,8 @@ export class StorageCoordinator
   async listSessions(): Promise<SessionRecord[]> {
     const entries = await this.tryList(this.keys.sessionPrefix(this.agentName));
     return entries
-      .map((entry) => entry.value as unknown as SessionRecord)
-      .filter((record) => record != null);
+      .map(entry => entry.value as unknown as SessionRecord)
+      .filter(record => record != null);
   }
 
   /**
@@ -517,7 +614,7 @@ export class StorageCoordinator
           [
             {
               label: `evals.put(${run.runId})`,
-              run: (ctx) => table.put(snapshot, ctx),
+              run: ctx => table.put(snapshot, ctx),
             },
           ],
           "policy"
@@ -528,7 +625,7 @@ export class StorageCoordinator
           [
             {
               label: `evals.delete(${runId})`,
-              run: (ctx) => table.delete(runId, ctx),
+              run: ctx => table.delete(runId, ctx),
             },
           ],
           "policy"
@@ -567,7 +664,7 @@ export class StorageCoordinator
     let timer: ReturnType<typeof setTimeout> | undefined;
     const drained = await Promise.race([
       this.queue.then(() => true),
-      new Promise<boolean>((resolve) => {
+      new Promise<boolean>(resolve => {
         timer = setTimeout(() => resolve(false), CLOSE_DRAIN_TIMEOUT_MS);
         timer.unref?.();
       }),

package/src/internal/storage.ts

@@ -0,0 +1 @@
+export * from "../storage.js";

package/src/internal/store-mirror.ts

@@ -26,15 +26,15 @@ export async function mirrorToStore(args: {
     )
   );
   const listed = await Promise.all(
-    [args.prefix, ...(args.legacyPrefixes ?? [])].map((prefix) =>
+    [args.prefix, ...(args.legacyPrefixes ?? [])].map(prefix =>
       args.sink.list(prefix)
     )
   );
   await Promise.all(
     listed
       .flat()
-      .filter((entry) => !args.desired.has(entry.key))
-      .map((entry) => args.sink.delete(entry.key))
+      .filter(entry => !args.desired.has(entry.key))
+      .map(entry => args.sink.delete(entry.key))
   );
 }
 
@@ -55,7 +55,7 @@ export function storeRelPath(
     relPath.includes("\\") ||
     posix.isAbsolute(relPath) ||
     relPath.endsWith("/") ||
-    relPath.split("/").some((seg) => seg === ".." || seg === ".") ||
+    relPath.split("/").some(seg => seg === ".." || seg === ".") ||
     posix.normalize(relPath) !== relPath
   ) {
     throw new Error(

package/src/internal/terminal-style.ts

@@ -111,7 +111,7 @@ export function formatTerminalBox(
   const padding = options?.padding ?? 1;
   const contentWidth = Math.max(
     options?.minWidth ?? 0,
-    ...lines.map((line) => visibleWidth(line)),
+    ...lines.map(line => visibleWidth(line)),
     1
   );
   const inner = contentWidth + padding * 2;
@@ -122,7 +122,7 @@ export function formatTerminalBox(
   const paint = (line: string): string => color(line);
   const box = [
     paint(`╭${"─".repeat(inner)}╮`),
-    ...lines.map((line) => paint(padLine(line))),
+    ...lines.map(line => paint(padLine(line))),
     paint(`╰${"─".repeat(inner)}╯`),
   ].join("\n");
   return box;

package/src/internal/tool-result.ts

@@ -47,8 +47,8 @@ export function toolCallErrorMessage(result: unknown): string | undefined {
   const texts = (
     result as { content: Array<{ type?: string; text?: string }> }
   ).content
-    .filter((part) => part.type === "text" && typeof part.text === "string")
-    .map((part) => part.text!.trim())
-    .filter((text) => text !== "");
+    .filter(part => part.type === "text" && typeof part.text === "string")
+    .map(part => part.text!.trim())
+    .filter(text => text !== "");
   return texts.length === 0 ? undefined : texts.join("\n");
 }