@parall/codex-agent 1.31.0 → 1.32.0

package/dist/dispatch.js

@@ -1,10 +1,10 @@
-import { execSync, spawn } 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 { normalizeApprovalPolicy, normalizeSandbox } from "./config.js";
-import { EventMapper } from "./event-mapping.js";
-import { JsonRpcStdioClient } from "./jsonrpc-client.js";
+import { execSync, spawn } 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 { normalizeApprovalPolicy, normalizeSandbox } from './config.js';
+import { EventMapper } from './event-mapping.js';
+import { JsonRpcStdioClient } from './jsonrpc-client.js';
 /**
  * Bridge driver backed by `codex app-server --listen stdio://`.
  *
@@ -19,7 +19,7 @@ import { JsonRpcStdioClient } from "./jsonrpc-client.js";
  * 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) {
     if (!/[\s"&|^<>()]/.test(arg))
         return arg;
@@ -27,7 +27,7 @@ function quoteWin32Arg(arg) {
 }
 function killWin32Tree(pid) {
     try {
-        execSync(`taskkill /T /F /PID ${pid}`, { windowsHide: true, stdio: "ignore" });
+        execSync(`taskkill /T /F /PID ${pid}`, { windowsHide: true, stdio: 'ignore' });
         return true;
     }
     catch {
@@ -57,7 +57,7 @@ export class CodexAppServerAdapter {
         const existing = this.activeTurns.get(threadId);
         if (existing) {
             (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);
@@ -82,7 +82,7 @@ export class CodexAppServerAdapter {
         if (!turnId)
             return false;
         try {
-            await client.sendRequest("turn/steer", {
+            await client.sendRequest('turn/steer', {
                 threadId,
                 expectedTurnId: turnId,
                 input: buildTurnInput(body, []),
@@ -95,10 +95,21 @@ export class CodexAppServerAdapter {
             return false;
         }
     }
+    abortDispatch(sessionKey) {
+        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) {
         return (this.pendingInjections.get(sessionKey) ?? 0) > 0;
     }
-    async *dispatch({ event, bodyForAgent, sessionKey, context }) {
+    async *dispatch({ event, bodyForAgent, sessionKey, context, }) {
         const pending = this.pendingInjections.get(sessionKey) ?? 0;
         if (pending > 0) {
             this.pendingInjections.delete(sessionKey);
@@ -106,7 +117,7 @@ export class CodexAppServerAdapter {
             if (threadId && this.client && !this.client.isDisposed()) {
                 (this.opts.log ?? context.log)?.info?.(`${pending} steer injection(s) already sent; skipping turn/start`);
                 yield {
-                    type: "runtime_session",
+                    type: 'runtime_session',
                     runtimeSessionId: threadId,
                     runtimeLaneKey: sessionKey,
                 };
@@ -121,7 +132,10 @@ export class CodexAppServerAdapter {
         // 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;
@@ -140,7 +154,7 @@ export class CodexAppServerAdapter {
                 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;
             }
         }
@@ -163,7 +177,7 @@ export class CodexAppServerAdapter {
                 }
                 catch (innerErr) {
                     yield {
-                        type: "error",
+                        type: 'error',
                         message: `Codex thread/start failed after resume error (persisted thread retained): ${errToString(innerErr)}`,
                     };
                     return;
@@ -201,7 +215,7 @@ export class CodexAppServerAdapter {
             // this contract, we want a hard error surfaced to the operator, not a
             // silent fallback that hides real protocol drift.
             const turnInput = buildTurnInput(preparedBody, preparedImages);
-            const startTurn = (targetThreadId) => client.sendRequest("turn/start", {
+            const startTurn = (targetThreadId) => client.sendRequest('turn/start', {
                 threadId: targetThreadId,
                 input: turnInput,
             });
@@ -222,11 +236,11 @@ export class CodexAppServerAdapter {
                 // 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`);
@@ -237,11 +251,14 @@ export class CodexAppServerAdapter {
                 }
                 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);
@@ -254,11 +271,14 @@ export class CodexAppServerAdapter {
                     // 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
@@ -272,30 +292,30 @@ export class CodexAppServerAdapter {
             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
@@ -335,17 +355,17 @@ export class CodexAppServerAdapter {
                 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);
@@ -372,17 +392,17 @@ export class CodexAppServerAdapter {
         this.activeTurnIds.clear();
         this.pendingInjections.clear();
         if (client)
-            client.dispose(new Error("adapter stopped"));
+            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');
             }
         }
     }
     async ensureStarted(log) {
         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();
@@ -422,22 +442,22 @@ export class CodexAppServerAdapter {
         const env = {
             ...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"],
+            stdio: ['pipe', 'pipe', 'pipe'],
             shell: IS_WIN32,
         });
-        proc.stderr.setEncoding("utf8");
-        proc.stderr.on("data", (chunk) => {
+        proc.stderr.setEncoding('utf8');
+        proc.stderr.on('data', (chunk) => {
             (log ?? this.opts.log)?.warn?.(`[stderr] ${chunk.trim()}`);
         });
         // Don't publish proc/client until the initialize handshake succeeds. If
@@ -447,24 +467,24 @@ export class CodexAppServerAdapter {
         // 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;
@@ -482,7 +502,7 @@ export class CodexAppServerAdapter {
             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`);
@@ -492,7 +512,7 @@ export class CodexAppServerAdapter {
         }
         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();
@@ -517,7 +537,7 @@ export class CodexAppServerAdapter {
             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)
@@ -530,7 +550,7 @@ export class CodexAppServerAdapter {
             // `thread/start` / `thread/resume` takes the camelCase form.
             commonParams.config = { modelReasoningEffort: this.opts.reasoningEffort };
         }
-        const method = opts.resumeId ? "thread/resume" : "thread/start";
+        const method = opts.resumeId ? 'thread/resume' : 'thread/start';
         const params = opts.resumeId
             ? { threadId: opts.resumeId, ...commonParams }
             : { cwd: this.opts.workspaceDir, ...commonParams };
@@ -545,10 +565,10 @@ export class CodexAppServerAdapter {
         const threadId = extractThreadIdFromNotification(params);
         if (!threadId) {
             // Surface server-initiated generic errors to every active turn.
-            if (method === "error") {
-                const msg = params?.message ?? "Codex app-server error";
+            if (method === 'error') {
+                const msg = params?.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;
@@ -560,11 +580,11 @@ export class CodexAppServerAdapter {
         // 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 });
         }
     }
 }
@@ -594,7 +614,7 @@ class TurnSink {
         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;
@@ -604,7 +624,7 @@ class TurnSink {
         this.closed = true;
         const r = this.resolver;
         this.resolver = null;
-        r?.({ kind: "turn_end" });
+        r?.({ kind: 'turn_end' });
     }
 }
 function ensureGitRepo(workingDirectory) {
@@ -614,7 +634,7 @@ function ensureGitRepo(workingDirectory) {
     // 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;
     }
@@ -623,14 +643,14 @@ function ensureGitRepo(workingDirectory) {
     }
     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 {
@@ -639,43 +659,43 @@ function ensureGitRepo(workingDirectory) {
 }
 function buildTurnInput(body, images) {
     return [
-        { type: "text", text: body },
-        ...images.map((image) => ({ type: "localImage", path: image.localPath })),
+        { type: 'text', text: body },
+        ...images.map((image) => ({ type: 'localImage', path: image.localPath })),
     ];
 }
 function extractThreadId(result) {
-    if (!result || typeof result !== "object")
+    if (!result || typeof result !== 'object')
         return undefined;
     const r = result;
-    if (typeof r.threadId === "string")
+    if (typeof r.threadId === 'string')
         return r.threadId;
     const thread = r.thread;
-    if (thread && typeof thread.id === "string")
+    if (thread && typeof thread.id === 'string')
         return thread.id;
     return undefined;
 }
 function extractTurnId(result) {
-    if (!result || typeof result !== "object")
+    if (!result || typeof result !== 'object')
         return undefined;
     const r = result;
-    if (typeof r.turnId === "string")
+    if (typeof r.turnId === 'string')
         return r.turnId;
     const turn = r.turn;
-    if (turn && typeof turn.id === "string")
+    if (turn && typeof turn.id === 'string')
         return turn.id;
     return undefined;
 }
 function extractThreadIdFromNotification(params) {
-    if (!params || typeof params !== "object")
+    if (!params || typeof params !== 'object')
         return undefined;
     const p = params;
-    if (typeof p.threadId === "string")
+    if (typeof p.threadId === 'string')
         return p.threadId;
     const thread = p.thread;
-    if (thread && typeof thread.id === "string")
+    if (thread && typeof thread.id === 'string')
         return thread.id;
     const meta = (p._meta ?? p.meta);
-    if (meta && typeof meta.threadId === "string")
+    if (meta && typeof meta.threadId === 'string')
         return meta.threadId;
     return undefined;
 }

package/dist/event-mapping.d.ts

@@ -1,4 +1,4 @@
-import type { RuntimeEvent } from "@parall/agent-core";
+import type { RuntimeEvent } from '@parall/agent-core';
 /**
  * Translation layer between `codex app-server` JSON-RPC notifications and
  * `@parall/agent-core` RuntimeEvents. The adapter owns one of these per

package/dist/event-mapping.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"event-mapping.d.ts","sourceRoot":"","sources":["../src/event-mapping.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA6B;IAE3D;;;OAGG;IACH,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,YAAY,EAAE;IA8CpD,OAAO,CAAC,OAAO;IA4If;;;;;OAKG;IACH,OAAO,CAAC,eAAe;CASxB"}
+{"version":3,"file":"event-mapping.d.ts","sourceRoot":"","sources":["../src/event-mapping.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA6B;IAE3D;;;OAGG;IACH,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,YAAY,EAAE;IA8CpD,OAAO,CAAC,OAAO;IA4Jf;;;;;OAKG;IACH,OAAO,CAAC,eAAe;CAaxB"}