@parall/codex-agent 1.30.0 → 1.32.0

package/src/dispatch.ts

@@ -1,12 +1,12 @@
-import { execSync, spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
-import { randomUUID } from "node:crypto";
-import * as fs from "node:fs";
+import { execSync, spawn, type ChildProcessWithoutNullStreams } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import * as fs from 'node:fs';
 import {
   appendPreparedLocalAttachmentRefs,
   ensureLocalAttachmentGitExclude,
   pinLocalAttachmentPaths,
-} from "@parall/agent-core/internal/attachment-input";
-import type { PreparedLocalImage } from "@parall/agent-core/internal/attachment-input";
+} from '@parall/agent-core/internal/attachment-input';
+import type { PreparedLocalImage } from '@parall/agent-core/internal/attachment-input';
 import type {
   CleanupForkOpts,
   DispatchAdapter,
@@ -15,22 +15,22 @@ import type {
   ForkSessionHandle,
   GatewayLogger,
   RuntimeEvent,
-} from "@parall/agent-core";
-import type { CodexAgentConfig } from "./config.js";
-import { normalizeApprovalPolicy, normalizeSandbox } from "./config.js";
-import { EventMapper } from "./event-mapping.js";
-import { JsonRpcStdioClient } from "./jsonrpc-client.js";
-import type { CodexSessionManager } from "./session-manager.js";
+} from '@parall/agent-core';
+import type { CodexAgentConfig } from './config.js';
+import { normalizeApprovalPolicy, normalizeSandbox } from './config.js';
+import { EventMapper } from './event-mapping.js';
+import { JsonRpcStdioClient } from './jsonrpc-client.js';
+import type { CodexSessionManager } from './session-manager.js';
 
 type CodexAppServerAdapterOptions = Pick<
   CodexAgentConfig,
-  | "approvalPolicy"
-  | "codexBin"
-  | "codexHome"
-  | "model"
-  | "reasoningEffort"
-  | "sandbox"
-  | "workspaceDir"
+  | 'approvalPolicy'
+  | 'codexBin'
+  | 'codexHome'
+  | 'model'
+  | 'reasoningEffort'
+  | 'sandbox'
+  | 'workspaceDir'
 > & {
   sessionManager: CodexSessionManager;
   log?: GatewayLogger;
@@ -39,9 +39,9 @@ type CodexAppServerAdapterOptions = Pick<
 };
 
 type TurnEventEnvelope =
-  | { kind: "runtime"; event: RuntimeEvent }
-  | { kind: "turn_end"; threadId?: string }
-  | { kind: "error"; message: string };
+  | { kind: 'runtime'; event: RuntimeEvent }
+  | { kind: 'turn_end'; threadId?: string }
+  | { kind: 'error'; message: string };
 
 /**
  * Bridge driver backed by `codex app-server --listen stdio://`.
@@ -57,7 +57,7 @@ type TurnEventEnvelope =
  * main + fork can interleave turns on the same stdio pipe. We route
  * notifications by threadId the server stamps on every item/turn event.
  */
-const IS_WIN32 = process.platform === "win32";
+const IS_WIN32 = process.platform === 'win32';
 
 function quoteWin32Arg(arg: string): string {
   if (!/[\s"&|^<>()]/.test(arg)) return arg;
@@ -66,9 +66,11 @@ function quoteWin32Arg(arg: string): string {
 
 function killWin32Tree(pid: number): boolean {
   try {
-    execSync(`taskkill /T /F /PID ${pid}`, { windowsHide: true, stdio: "ignore" });
+    execSync(`taskkill /T /F /PID ${pid}`, { windowsHide: true, stdio: 'ignore' });
     return true;
-  } catch { return false; }
+  } catch {
+    return false;
+  }
 }
 
 export class CodexAppServerAdapter implements DispatchAdapter {
@@ -96,7 +98,7 @@ export class CodexAppServerAdapter implements DispatchAdapter {
       (log ?? this.opts.log)?.warn?.(
         `thread ${threadId} already had an active turn; failing the previous dispatch`,
       );
-      existing.push({ kind: "error", message: `thread ${threadId} replaced by concurrent turn` });
+      existing.push({ kind: 'error', message: `thread ${threadId} replaced by concurrent turn` });
       existing.close();
     }
     this.activeTurns.set(threadId, sink);
@@ -106,7 +108,8 @@ export class CodexAppServerAdapter implements DispatchAdapter {
 
   updateConfig(config: { model?: string | null; reasoningEffort?: string | null }): void {
     if (config.model !== undefined) this.opts.model = config.model ?? undefined;
-    if (config.reasoningEffort !== undefined) this.opts.reasoningEffort = config.reasoningEffort ?? undefined;
+    if (config.reasoningEffort !== undefined)
+      this.opts.reasoningEffort = config.reasoningEffort ?? undefined;
   }
 
   async enqueueDuringDispatch(sessionKey: string, body: string): Promise<boolean> {
@@ -117,7 +120,7 @@ export class CodexAppServerAdapter implements DispatchAdapter {
     const turnId = this.activeTurnIds.get(threadId);
     if (!turnId) return false;
     try {
-      await client.sendRequest("turn/steer", {
+      await client.sendRequest('turn/steer', {
         threadId,
         expectedTurnId: turnId,
         input: buildTurnInput(body, []),
@@ -130,11 +133,26 @@ export class CodexAppServerAdapter implements DispatchAdapter {
     }
   }
 
+  abortDispatch(sessionKey: string): void {
+    this.pendingInjections.delete(sessionKey);
+    const threadId = this.opts.sessionManager.getThreadId(sessionKey);
+    if (!threadId) return;
+    const sink = this.activeTurns.get(threadId);
+    if (!sink) return;
+    sink.push({ kind: 'error', message: 'dispatch deadline exceeded' });
+    sink.close();
+  }
+
   hasPendingInjections(sessionKey: string): boolean {
     return (this.pendingInjections.get(sessionKey) ?? 0) > 0;
   }
 
-  async *dispatch({ event, bodyForAgent, sessionKey, context }: DispatchOpts): AsyncIterable<RuntimeEvent> {
+  async *dispatch({
+    event,
+    bodyForAgent,
+    sessionKey,
+    context,
+  }: DispatchOpts): AsyncIterable<RuntimeEvent> {
     const pending = this.pendingInjections.get(sessionKey) ?? 0;
     if (pending > 0) {
       this.pendingInjections.delete(sessionKey);
@@ -144,7 +162,7 @@ export class CodexAppServerAdapter implements DispatchAdapter {
           `${pending} steer injection(s) already sent; skipping turn/start`,
         );
         yield {
-          type: "runtime_session",
+          type: 'runtime_session',
           runtimeSessionId: threadId,
           runtimeLaneKey: sessionKey,
         };
@@ -162,7 +180,10 @@ export class CodexAppServerAdapter implements DispatchAdapter {
     // throw a TypeError on the next sendRequest call.
     const client = this.client;
     if (!client) {
-      yield { type: "error", message: "Codex app-server not available (subprocess died during dispatch start)" };
+      yield {
+        type: 'error',
+        message: 'Codex app-server not available (subprocess died during dispatch start)',
+      };
       return;
     }
     const log = this.opts.log ?? context.log;
@@ -181,7 +202,7 @@ export class CodexAppServerAdapter implements DispatchAdapter {
         // fail the resume path and replace the thread, losing the first turn.
         this.resumedThreadIds.add(threadId);
       } catch (err) {
-        yield { type: "error", message: `Codex thread/start failed: ${errToString(err)}` };
+        yield { type: 'error', message: `Codex thread/start failed: ${errToString(err)}` };
         return;
       }
     } else if (isMainSession && !this.resumedThreadIds.has(threadId)) {
@@ -195,13 +216,15 @@ export class CodexAppServerAdapter implements DispatchAdapter {
         this.opts.sessionManager.recordThreadId(sessionKey, threadId);
         this.resumedThreadIds.add(threadId);
       } catch (err) {
-        log?.warn?.(`thread/resume failed (${errToString(err)}); attempting one-shot fresh-thread start`);
+        log?.warn?.(
+          `thread/resume failed (${errToString(err)}); attempting one-shot fresh-thread start`,
+        );
         let freshThreadId: string;
         try {
           freshThreadId = await this.openThread(client, { resumeId: undefined });
         } catch (innerErr) {
           yield {
-            type: "error",
+            type: 'error',
             message: `Codex thread/start failed after resume error (persisted thread retained): ${errToString(innerErr)}`,
           };
           return;
@@ -241,7 +264,7 @@ export class CodexAppServerAdapter implements DispatchAdapter {
       // silent fallback that hides real protocol drift.
       const turnInput = buildTurnInput(preparedBody, preparedImages);
       const startTurn = (targetThreadId: string): Promise<unknown> =>
-        client.sendRequest("turn/start", {
+        client.sendRequest('turn/start', {
           threadId: targetThreadId,
           input: turnInput,
         });
@@ -262,25 +285,30 @@ export class CodexAppServerAdapter implements DispatchAdapter {
         // Fork sessions don't retry: agent-core spawns a fresh fork next trigger.
         if (!isMainSession) {
           yield {
-            type: "runtime_session",
+            type: 'runtime_session',
             runtimeSessionId: threadId,
             runtimeLaneKey: sessionKey,
           };
-          yield { type: "error", message: `Codex turn/start failed: ${message}` };
+          yield { type: 'error', message: `Codex turn/start failed: ${message}` };
           return;
         }
-        log?.warn?.(`turn/start on thread ${threadId} failed (${message}); attempting one-shot fresh-thread retry`);
+        log?.warn?.(
+          `turn/start on thread ${threadId} failed (${message}); attempting one-shot fresh-thread retry`,
+        );
         this.activeTurns.delete(threadId);
         let freshThreadId: string;
         try {
           freshThreadId = await this.openThread(client, { resumeId: undefined });
         } catch (createErr) {
           yield {
-            type: "runtime_session",
+            type: 'runtime_session',
             runtimeSessionId: threadId,
             runtimeLaneKey: sessionKey,
           };
-          yield { type: "error", message: `Codex turn/start failed; could not create replacement thread: ${errToString(createErr)}` };
+          yield {
+            type: 'error',
+            message: `Codex turn/start failed; could not create replacement thread: ${errToString(createErr)}`,
+          };
           return;
         }
         this.setActiveTurn(freshThreadId, sink, log);
@@ -292,11 +320,14 @@ export class CodexAppServerAdapter implements DispatchAdapter {
           // resume again.
           this.activeTurns.delete(freshThreadId);
           yield {
-            type: "runtime_session",
+            type: 'runtime_session',
             runtimeSessionId: threadId,
             runtimeLaneKey: sessionKey,
           };
-          yield { type: "error", message: `Codex turn/start failed after retry: ${errToString(retryErr)}` };
+          yield {
+            type: 'error',
+            message: `Codex turn/start failed after retry: ${errToString(retryErr)}`,
+          };
           return;
         }
         // Retry accepted — the original thread really was unusable. Now safe
@@ -310,31 +341,31 @@ export class CodexAppServerAdapter implements DispatchAdapter {
       const turnId = extractTurnId(turnStartResult);
       if (turnId) this.activeTurnIds.set(threadId, turnId);
       yield {
-        type: "runtime_session",
+        type: 'runtime_session',
         runtimeSessionId: threadId,
         runtimeLaneKey: sessionKey,
       };
 
       while (true) {
         const envelope = await sink.next();
-        if (envelope.kind === "turn_end") {
+        if (envelope.kind === 'turn_end') {
           sawTurnEnd = true;
           break;
         }
-        if (envelope.kind === "error") {
-          yield { type: "error", message: envelope.message };
+        if (envelope.kind === 'error') {
+          yield { type: 'error', message: envelope.message };
           continue;
         }
         const runtimeEvent = envelope.event;
-        if (runtimeEvent.type === "error") {
+        if (runtimeEvent.type === 'error') {
           yield runtimeEvent;
           continue;
         }
-        if (runtimeEvent.type === "runtime_session") {
+        if (runtimeEvent.type === 'runtime_session') {
           yield runtimeEvent;
           continue;
         }
-        if (runtimeEvent.type === "text") {
+        if (runtimeEvent.type === 'text') {
           // Layer 0 symmetric output contract: Codex's plain text is never
           // projected as a chat message. Outbound messages must come from the
           // agent explicitly invoking `@parall/cli messages send` / `dm` via
@@ -373,16 +404,16 @@ export class CodexAppServerAdapter implements DispatchAdapter {
         ephemeral: true,
       };
       if (this.opts.useParallProvider) {
-        forkParams.modelProvider = "parall";
+        forkParams.modelProvider = 'parall';
       }
       if (this.opts.model) forkParams.model = this.opts.model;
       if (this.opts.reasoningEffort) {
         forkParams.config = { modelReasoningEffort: this.opts.reasoningEffort };
       }
-      const result = await client.sendRequest("thread/fork", forkParams);
+      const result = await client.sendRequest('thread/fork', forkParams);
       const forkedThreadId = extractThreadId(result);
       if (!forkedThreadId) {
-        this.opts.log?.warn?.("thread/fork returned no thread id");
+        this.opts.log?.warn?.('thread/fork returned no thread id');
         return null;
       }
       this.opts.sessionManager.recordThreadId(handle.sessionKey, forkedThreadId);
@@ -410,10 +441,10 @@ export class CodexAppServerAdapter implements DispatchAdapter {
     this.initialized = false;
     this.activeTurnIds.clear();
     this.pendingInjections.clear();
-    if (client) client.dispose(new Error("adapter stopped"));
+    if (client) client.dispose(new Error('adapter stopped'));
     if (proc && proc.exitCode === null && proc.signalCode === null) {
       if (!IS_WIN32 || !proc.pid || !killWin32Tree(proc.pid)) {
-        proc.kill("SIGTERM");
+        proc.kill('SIGTERM');
       }
     }
   }
@@ -421,7 +452,7 @@ export class CodexAppServerAdapter implements DispatchAdapter {
   private async ensureStarted(log?: GatewayLogger): Promise<void> {
     if (this.client?.isDisposed()) {
       for (const activeSink of this.activeTurns.values()) {
-        activeSink.push({ kind: "error", message: "Codex app-server disposed; resetting adapter" });
+        activeSink.push({ kind: 'error', message: 'Codex app-server disposed; resetting adapter' });
         activeSink.close();
       }
       this.activeTurns.clear();
@@ -460,25 +491,27 @@ export class CodexAppServerAdapter implements DispatchAdapter {
     const env: Record<string, string | undefined> = {
       ...process.env,
       CODEX_HOME: this.opts.codexHome,
-      FORCE_COLOR: "0",
-      NO_COLOR: "1",
+      FORCE_COLOR: '0',
+      NO_COLOR: '1',
     };
     if (this.opts.contextFilePath) {
       env.PRLL_CONTEXT_FILE = this.opts.contextFilePath;
     }
-    const args = ["app-server", "--listen", "stdio://"];
-    (log ?? this.opts.log)?.info?.(`spawning ${this.opts.codexBin} ${args.join(" ")}`);
+    const args = ['app-server', '--listen', 'stdio://'];
+    (log ?? this.opts.log)?.info?.(`spawning ${this.opts.codexBin} ${args.join(' ')}`);
     const proc = spawn(
       IS_WIN32 ? quoteWin32Arg(this.opts.codexBin) : this.opts.codexBin,
-      IS_WIN32 ? args.map(quoteWin32Arg) : args, {
-      cwd: this.opts.workspaceDir,
-      env,
-      stdio: ["pipe", "pipe", "pipe"],
-      shell: IS_WIN32,
-    }) as ChildProcessWithoutNullStreams;
-
-    proc.stderr.setEncoding("utf8");
-    proc.stderr.on("data", (chunk: string) => {
+      IS_WIN32 ? args.map(quoteWin32Arg) : args,
+      {
+        cwd: this.opts.workspaceDir,
+        env,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        shell: IS_WIN32,
+      },
+    ) as ChildProcessWithoutNullStreams;
+
+    proc.stderr.setEncoding('utf8');
+    proc.stderr.on('data', (chunk: string) => {
       (log ?? this.opts.log)?.warn?.(`[stderr] ${chunk.trim()}`);
     });
 
@@ -489,25 +522,25 @@ export class CodexAppServerAdapter implements DispatchAdapter {
     // next ensureStarted() to spawn a second app-server on top of it.
     const client = new JsonRpcStdioClient(proc, undefined, (p) => {
       if (!IS_WIN32 || !p.pid || !killWin32Tree(p.pid)) {
-        p.kill("SIGTERM");
+        p.kill('SIGTERM');
       }
     });
     client.setNotificationHandler((method, params) => this.routeNotification(method, params));
 
-    proc.once("close", (code, signal) => this.handleSubprocessClose(proc, code, signal, log));
-    proc.once("error", (err) => this.handleSubprocessClose(proc, null, null, log, err));
+    proc.once('close', (code, signal) => this.handleSubprocessClose(proc, code, signal, log));
+    proc.once('error', (err) => this.handleSubprocessClose(proc, null, null, log, err));
 
     try {
-      await client.sendRequest("initialize", {
-        clientInfo: { name: "parall-codex-agent", version: "1" },
+      await client.sendRequest('initialize', {
+        clientInfo: { name: 'parall-codex-agent', version: '1' },
         capabilities: { experimentalApi: false },
       });
-      client.sendNotification("initialized", {});
+      client.sendNotification('initialized', {});
     } catch (err) {
       client.dispose(err instanceof Error ? err : new Error(String(err)));
       if (proc.exitCode === null && proc.signalCode === null) {
         if (!IS_WIN32 || !proc.pid || !killWin32Tree(proc.pid)) {
-          proc.kill("SIGTERM");
+          proc.kill('SIGTERM');
         }
       }
       throw err;
@@ -532,7 +565,7 @@ export class CodexAppServerAdapter implements DispatchAdapter {
     if (this.proc !== null && this.proc !== proc) return;
     const reason = err
       ? `spawn error: ${err.message}`
-      : `exited (code=${code ?? "null"}${signal ? `, signal=${signal}` : ""})`;
+      : `exited (code=${code ?? 'null'}${signal ? `, signal=${signal}` : ''})`;
     const logger = log ?? this.opts.log;
     if (this.stopping) {
       logger?.info?.(`app-server subprocess ${reason} during graceful stop`);
@@ -541,7 +574,7 @@ export class CodexAppServerAdapter implements DispatchAdapter {
     }
     this.client?.dispose(err ?? new Error(`app-server ${reason}`));
     for (const activeSink of this.activeTurns.values()) {
-      activeSink.push({ kind: "error", message: `Codex app-server ${reason}` });
+      activeSink.push({ kind: 'error', message: `Codex app-server ${reason}` });
       activeSink.close();
     }
     this.activeTurns.clear();
@@ -570,7 +603,7 @@ export class CodexAppServerAdapter implements DispatchAdapter {
       approvalPolicy: normalizeApprovalPolicy(this.opts.approvalPolicy),
     };
     if (this.opts.useParallProvider) {
-      commonParams.modelProvider = "parall";
+      commonParams.modelProvider = 'parall';
     }
     commonParams.sandbox = normalizeSandbox(this.opts.sandbox);
     if (this.opts.model) commonParams.model = this.opts.model;
@@ -583,7 +616,7 @@ export class CodexAppServerAdapter implements DispatchAdapter {
       commonParams.config = { modelReasoningEffort: this.opts.reasoningEffort };
     }
 
-    const method = opts.resumeId ? "thread/resume" : "thread/start";
+    const method = opts.resumeId ? 'thread/resume' : 'thread/start';
     const params: Record<string, unknown> = opts.resumeId
       ? { threadId: opts.resumeId, ...commonParams }
       : { cwd: this.opts.workspaceDir, ...commonParams };
@@ -600,10 +633,10 @@ export class CodexAppServerAdapter implements DispatchAdapter {
     const threadId = extractThreadIdFromNotification(params);
     if (!threadId) {
       // Surface server-initiated generic errors to every active turn.
-      if (method === "error") {
-        const msg = (params as { message?: unknown })?.message ?? "Codex app-server error";
+      if (method === 'error') {
+        const msg = (params as { message?: unknown })?.message ?? 'Codex app-server error';
         for (const sink of this.activeTurns.values()) {
-          sink.push({ kind: "error", message: String(msg) });
+          sink.push({ kind: 'error', message: String(msg) });
         }
       }
       return;
@@ -616,14 +649,13 @@ export class CodexAppServerAdapter implements DispatchAdapter {
     // RuntimeEvent error if `turn.status === "failed"`. Enqueue those events
     // before the turn_end sentinel so the dispatch loop can yield them.
     for (const event of sink.mapper.map(method, params)) {
-      sink.push({ kind: "runtime", event });
+      sink.push({ kind: 'runtime', event });
     }
-    if (method === "turn/completed") {
+    if (method === 'turn/completed') {
       this.activeTurnIds.delete(threadId);
-      sink.push({ kind: "turn_end", threadId });
+      sink.push({ kind: 'turn_end', threadId });
     }
   }
-
 }
 
 /** Per-turn buffered sink backed by an unbounded promise queue. */
@@ -652,7 +684,7 @@ class TurnSink {
     const pending = this.queue.shift();
     if (pending) return Promise.resolve(pending);
     if (this.closed) {
-      return Promise.resolve({ kind: "turn_end" });
+      return Promise.resolve({ kind: 'turn_end' });
     }
     return new Promise((resolve) => {
       this.resolver = resolve;
@@ -663,7 +695,7 @@ class TurnSink {
     this.closed = true;
     const r = this.resolver;
     this.resolver = null;
-    r?.({ kind: "turn_end" });
+    r?.({ kind: 'turn_end' });
   }
 }
 
@@ -671,10 +703,10 @@ function ensureGitRepo(workingDirectory: string): void {
   fs.mkdirSync(workingDirectory, { recursive: true });
   // Only `git init` if the workspace isn't already inside any git repo. A
   // bare existsSync(.git) check would miss the common case of a user pointing
-  // PRLL_CODEX_WORKSPACE_DIR at a subdirectory of their existing project,
+  // PRLL_WORKSPACE_DIR at a subdirectory of their existing project,
   // and silently creating a nested repo there would mangle their layout.
   try {
-    execSync("git rev-parse --is-inside-work-tree", { cwd: workingDirectory, stdio: "pipe" });
+    execSync('git rev-parse --is-inside-work-tree', { cwd: workingDirectory, stdio: 'pipe' });
     ensureLocalAttachmentGitExclude(workingDirectory);
     return;
   } catch {
@@ -682,57 +714,55 @@ function ensureGitRepo(workingDirectory: string): void {
   }
   const env = {
     ...process.env,
-    GIT_AUTHOR_NAME: "parall-codex-agent",
-    GIT_AUTHOR_EMAIL: "agent@parall.local",
-    GIT_COMMITTER_NAME: "parall-codex-agent",
-    GIT_COMMITTER_EMAIL: "agent@parall.local",
+    GIT_AUTHOR_NAME: 'parall-codex-agent',
+    GIT_AUTHOR_EMAIL: 'agent@parall.local',
+    GIT_COMMITTER_NAME: 'parall-codex-agent',
+    GIT_COMMITTER_EMAIL: 'agent@parall.local',
   };
   try {
-    execSync("git init", { cwd: workingDirectory, stdio: "pipe", env });
-    execSync("git commit --allow-empty -m init", { cwd: workingDirectory, stdio: "pipe", env });
+    execSync('git init', { cwd: workingDirectory, stdio: 'pipe', env });
+    execSync('git commit --allow-empty -m init', { cwd: workingDirectory, stdio: 'pipe', env });
     ensureLocalAttachmentGitExclude(workingDirectory);
   } catch {
     // Non-fatal: codex app-server may still accept a bare directory. Let it raise at turn time.
   }
 }
 
-type CodexTurnInput =
-  | { type: "text"; text: string }
-  | { type: "localImage"; path: string };
+type CodexTurnInput = { type: 'text'; text: string } | { type: 'localImage'; path: string };
 
 function buildTurnInput(body: string, images: PreparedLocalImage[]): CodexTurnInput[] {
   return [
-    { type: "text", text: body },
-    ...images.map((image) => ({ type: "localImage" as const, path: image.localPath })),
+    { type: 'text', text: body },
+    ...images.map((image) => ({ type: 'localImage' as const, path: image.localPath })),
   ];
 }
 
 function extractThreadId(result: unknown): string | undefined {
-  if (!result || typeof result !== "object") return undefined;
+  if (!result || typeof result !== 'object') return undefined;
   const r = result as Record<string, unknown>;
-  if (typeof r.threadId === "string") return r.threadId;
+  if (typeof r.threadId === 'string') return r.threadId;
   const thread = r.thread as Record<string, unknown> | undefined;
-  if (thread && typeof thread.id === "string") return thread.id;
+  if (thread && typeof thread.id === 'string') return thread.id;
   return undefined;
 }
 
 function extractTurnId(result: unknown): string | undefined {
-  if (!result || typeof result !== "object") return undefined;
+  if (!result || typeof result !== 'object') return undefined;
   const r = result as Record<string, unknown>;
-  if (typeof r.turnId === "string") return r.turnId;
+  if (typeof r.turnId === 'string') return r.turnId;
   const turn = r.turn as Record<string, unknown> | undefined;
-  if (turn && typeof turn.id === "string") return turn.id;
+  if (turn && typeof turn.id === 'string') return turn.id;
   return undefined;
 }
 
 function extractThreadIdFromNotification(params: unknown): string | undefined {
-  if (!params || typeof params !== "object") return undefined;
+  if (!params || typeof params !== 'object') return undefined;
   const p = params as Record<string, unknown>;
-  if (typeof p.threadId === "string") return p.threadId;
+  if (typeof p.threadId === 'string') return p.threadId;
   const thread = p.thread as Record<string, unknown> | undefined;
-  if (thread && typeof thread.id === "string") return thread.id;
+  if (thread && typeof thread.id === 'string') return thread.id;
   const meta = (p._meta ?? p.meta) as Record<string, unknown> | undefined;
-  if (meta && typeof meta.threadId === "string") return meta.threadId;
+  if (meta && typeof meta.threadId === 'string') return meta.threadId;
   return undefined;
 }