@mcoda/agents 0.1.35 → 0.1.37

package/dist/adapters/codex/CodexAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CodexAdapter.d.ts","sourceRoot":"","sources":["../../../src/adapters/codex/CodexAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAGtG,qBAAa,YAAa,YAAW,YAAY;IACnC,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,aAAa;IAEnC,eAAe,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAIpC,WAAW,IAAI,OAAO,CAAC,WAAW,CAAC;IAYnC,MAAM,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAmB5D,YAAY,CAAC,OAAO,EAAE,iBAAiB,GAAG,cAAc,CAAC,gBAAgB,EAAE,IAAI,EAAE,OAAO,CAAC;CAoBjG"}
+{"version":3,"file":"CodexAdapter.d.ts","sourceRoot":"","sources":["../../../src/adapters/codex/CodexAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAmBtG,qBAAa,YAAa,YAAW,YAAY;IACnC,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,aAAa;IAEnC,eAAe,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAIpC,WAAW,IAAI,OAAO,CAAC,WAAW,CAAC;IAYnC,MAAM,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAwB5D,YAAY,CAAC,OAAO,EAAE,iBAAiB,GAAG,cAAc,CAAC,gBAAgB,EAAE,IAAI,EAAE,OAAO,CAAC;CAyBjG"}

package/dist/adapters/codex/CodexAdapter.js

@@ -1,4 +1,18 @@
 import { cliHealthy, runCodexExec, runCodexExecStream } from "./CodexCliRunner.js";
+const extractOutputSchema = (request) => {
+    const candidate = request.metadata?.outputSchema;
+    if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) {
+        return undefined;
+    }
+    return candidate;
+};
+const extractTimeoutMs = (request) => {
+    const candidate = request.metadata?.timeoutMs;
+    if (typeof candidate !== "number" || !Number.isFinite(candidate) || candidate <= 0) {
+        return undefined;
+    }
+    return Math.floor(candidate);
+};
 export class CodexAdapter {
     constructor(config) {
         this.config = config;
@@ -20,7 +34,7 @@ export class CodexAdapter {
     async invoke(request) {
         const health = cliHealthy(true);
         const cliDetails = health.details;
-        const result = runCodexExec(request.input, this.config.model);
+        const result = await runCodexExec(request.input, this.config.model, extractOutputSchema(request), extractTimeoutMs(request));
         return {
             output: result.output,
             adapter: this.config.adapter ?? "codex-cli",
@@ -38,7 +52,7 @@ export class CodexAdapter {
     async *invokeStream(request) {
         const health = cliHealthy(true);
         const cliDetails = health.details;
-        for await (const chunk of runCodexExecStream(request.input, this.config.model)) {
+        for await (const chunk of runCodexExecStream(request.input, this.config.model, extractOutputSchema(request), extractTimeoutMs(request))) {
             yield {
                 output: chunk.output,
                 adapter: this.config.adapter ?? "codex-cli",

package/dist/adapters/codex/CodexCliRunner.d.ts

@@ -2,11 +2,11 @@ export declare const cliHealthy: (throwOnError?: boolean) => {
     ok: boolean;
     details?: Record<string, unknown>;
 };
-export declare const runCodexExec: (prompt: string, model?: string) => {
+export declare const runCodexExec: (prompt: string, model?: string, outputSchema?: Record<string, unknown>, timeoutMs?: number) => Promise<{
     output: string;
     raw: string;
-};
-export declare function runCodexExecStream(prompt: string, model?: string): AsyncGenerator<{
+}>;
+export declare function runCodexExecStream(prompt: string, model?: string, outputSchema?: Record<string, unknown>, timeoutMs?: number): AsyncGenerator<{
     output: string;
     raw: string;
 }, void, unknown>;

package/dist/adapters/codex/CodexCliRunner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CodexCliRunner.d.ts","sourceRoot":"","sources":["../../../src/adapters/codex/CodexCliRunner.ts"],"names":[],"mappings":"AA4hBA,eAAO,MAAM,UAAU,GAAI,sBAAoB,KAAG;IAAE,EAAE,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CA2BjG,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,QAAQ,MAAM,EAAE,QAAQ,MAAM,KAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAuD1F,CAAC;AAEF,wBAAuB,kBAAkB,CACvC,MAAM,EAAE,MAAM,EACd,KAAK,CAAC,EAAE,MAAM,GACb,cAAc,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,EAAE,IAAI,EAAE,OAAO,CAAC,CA+GhE"}
+{"version":3,"file":"CodexCliRunner.d.ts","sourceRoot":"","sources":["../../../src/adapters/codex/CodexCliRunner.ts"],"names":[],"mappings":"AAk1BA,eAAO,MAAM,UAAU,GAAI,sBAAoB,KAAG;IAAE,EAAE,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CA+BjG,CAAC;AAEF,eAAO,MAAM,YAAY,GACvB,QAAQ,MAAM,EACd,QAAQ,MAAM,EACd,eAAe,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACtC,YAAY,MAAM,KACjB,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CASzC,CAAC;AAEF,wBAAuB,kBAAkB,CACvC,MAAM,EAAE,MAAM,EACd,KAAK,CAAC,EAAE,MAAM,EACd,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACtC,SAAS,CAAC,EAAE,MAAM,GACjB,cAAc,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,EAAE,IAAI,EAAE,OAAO,CAAC,CAmFhE"}

package/dist/adapters/codex/CodexCliRunner.js

@@ -1,4 +1,7 @@
 import { spawn, spawnSync } from "node:child_process";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
 const CODEX_MAX_BUFFER_BYTES = 10 * 1024 * 1024;
 const CODEX_REASONING_ENV = "MCODA_CODEX_REASONING_EFFORT";
 const CODEX_REASONING_ENV_FALLBACK = "CODEX_REASONING_EFFORT";
@@ -7,6 +10,12 @@ const CODEX_STREAM_IO_ENV = "MCODA_STREAM_IO";
 const CODEX_STREAM_IO_FORMAT_ENV = "MCODA_STREAM_IO_FORMAT";
 const CODEX_STREAM_IO_COLOR_ENV = "MCODA_STREAM_IO_COLOR";
 const CODEX_STREAM_IO_PREFIX = "codex-cli";
+const CODEX_COMMAND_ENV = "MCODA_CODEX_COMMAND";
+const CODEX_COMMAND_ARGS_ENV = "MCODA_CODEX_COMMAND_ARGS";
+const CODEX_TIMEOUT_ENV = "MCODA_CODEX_TIMEOUT_MS";
+const CODEX_EXIT_GRACE_ENV = "MCODA_CODEX_EXIT_GRACE_MS";
+const CODEX_DEFAULT_TIMEOUT_MS = 15 * 60 * 1000;
+const CODEX_DEFAULT_EXIT_GRACE_MS = 5000;
 const ANSI = {
     reset: "\u001b[0m",
     bold: "\u001b[1m",
@@ -114,6 +123,95 @@ const extractItemText = (item) => {
     }
     return "";
 };
+const parseCommandArgs = (raw) => {
+    const trimmed = raw?.trim();
+    if (!trimmed)
+        return [];
+    if (trimmed.startsWith("[")) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (Array.isArray(parsed)) {
+                return parsed
+                    .map((entry) => (typeof entry === "string" ? entry.trim() : ""))
+                    .filter(Boolean);
+            }
+        }
+        catch {
+            // fall through to whitespace parsing
+        }
+    }
+    return trimmed.split(/\s+/).filter(Boolean);
+};
+const resolveCodexCommand = () => {
+    const command = process.env[CODEX_COMMAND_ENV]?.trim() || "codex";
+    const preArgs = parseCommandArgs(process.env[CODEX_COMMAND_ARGS_ENV]);
+    return { command, preArgs };
+};
+const parsePositiveIntEnv = (name, fallback) => {
+    const raw = process.env[name]?.trim();
+    if (!raw)
+        return fallback;
+    const parsed = Number(raw);
+    return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : fallback;
+};
+const resolveCodexTimeoutMs = () => parsePositiveIntEnv(CODEX_TIMEOUT_ENV, CODEX_DEFAULT_TIMEOUT_MS);
+const resolveCodexExitGraceMs = () => parsePositiveIntEnv(CODEX_EXIT_GRACE_ENV, CODEX_DEFAULT_EXIT_GRACE_MS);
+const isIgnorableStdinError = (error) => error.code === "EPIPE" || error.code === "ERR_STREAM_DESTROYED";
+const safeKill = (child, signal) => {
+    try {
+        if (!child.killed) {
+            child.kill(signal);
+        }
+    }
+    catch {
+        /* ignore kill errors */
+    }
+};
+const scheduleHardKill = (child, delayMs = 250) => {
+    const timer = setTimeout(() => {
+        safeKill(child, "SIGKILL");
+    }, delayMs);
+    timer.unref();
+};
+const extractProtocolError = (parsed) => {
+    if (!parsed || typeof parsed !== "object")
+        return undefined;
+    const type = typeof parsed.type === "string" ? parsed.type : "";
+    if (type === "turn.failed") {
+        const message = parsed?.error?.message ?? parsed?.error;
+        return message ? String(message) : "codex turn failed";
+    }
+    if (type === "error" && parsed?.message) {
+        return String(parsed.message);
+    }
+    return undefined;
+};
+const isCompletionEvent = (parsed) => {
+    if (!parsed || typeof parsed !== "object")
+        return false;
+    const type = typeof parsed.type === "string" ? parsed.type : "";
+    return type === "turn.completed" || type === "response.completed";
+};
+const parseCodexOutput = (raw) => {
+    const lines = raw.split(/\r?\n/).filter((line) => line.trim().length > 0);
+    let message = "";
+    for (const line of lines) {
+        const parsed = safeJsonParse(line);
+        const event = extractAssistantText(parsed);
+        if (!event)
+            continue;
+        if (event.kind === "delta") {
+            message += event.text;
+            continue;
+        }
+        message = event.text;
+    }
+    if (!message) {
+        return lines[lines.length - 1] ?? "";
+    }
+    return message;
+};
+const normalizeComparableAssistantText = (value) => value.replace(/\r\n/g, "\n").trim();
 const normalizeValue = (value) => {
     if (typeof value !== "string")
         return value;
@@ -541,6 +639,185 @@ const extractAssistantText = (parsed) => {
     }
     return null;
 };
+const materializeOutputSchema = async (outputSchema) => {
+    if (!outputSchema || typeof outputSchema !== "object" || Array.isArray(outputSchema)) {
+        return undefined;
+    }
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), "mcoda-codex-schema-"));
+    const schemaPath = path.join(tempDir, "output-schema.json");
+    await writeFile(schemaPath, `${JSON.stringify(outputSchema, null, 2)}\n`, "utf8");
+    return {
+        schemaPath,
+        cleanup: async () => {
+            try {
+                await rm(tempDir, { recursive: true, force: true });
+            }
+            catch {
+                /* ignore cleanup errors */
+            }
+        },
+    };
+};
+const invokeCodexProcess = async (prompt, model, options) => {
+    const resolvedModel = model ?? "gpt-5.1-codex-max";
+    const sandboxArgs = resolveSandboxArgs();
+    const reasoningEffort = resolveReasoningEffort(resolvedModel);
+    const codexCommand = resolveCodexCommand();
+    const args = [...codexCommand.preArgs, ...sandboxArgs.args, "exec", "--model", resolvedModel, "--json"];
+    const schemaFile = await materializeOutputSchema(options?.outputSchema);
+    if (schemaFile) {
+        args.push("--output-schema", schemaFile.schemaPath);
+    }
+    if (!sandboxArgs.bypass) {
+        args.push("--full-auto");
+    }
+    if (reasoningEffort) {
+        args.push("-c", `model_reasoning_effort=${reasoningEffort}`);
+    }
+    args.push("-");
+    const timeoutMs = typeof options?.timeoutMs === "number" && Number.isFinite(options.timeoutMs) && options.timeoutMs > 0
+        ? Math.floor(options.timeoutMs)
+        : resolveCodexTimeoutMs();
+    const exitGraceMs = resolveCodexExitGraceMs();
+    try {
+        return await new Promise((resolve, reject) => {
+            const child = spawn(codexCommand.command, args, { stdio: ["pipe", "pipe", "pipe"] });
+            let raw = "";
+            let stderr = "";
+            let lineBuffer = "";
+            let message = "";
+            let protocolError;
+            let settled = false;
+            let forcedExit = false;
+            let completionTimer;
+            const clearTimers = () => {
+                if (completionTimer) {
+                    clearTimeout(completionTimer);
+                    completionTimer = undefined;
+                }
+                clearTimeout(timeoutHandle);
+            };
+            const finalizeOutput = () => {
+                const parsedOutput = parseCodexOutput(raw).trim();
+                return parsedOutput || message.trim();
+            };
+            const finishResolve = () => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimers();
+                resolve({ output: finalizeOutput(), raw, forcedExit });
+            };
+            const finishReject = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimers();
+                reject(error);
+            };
+            const scheduleCompletionGrace = () => {
+                if (settled)
+                    return;
+                if (completionTimer) {
+                    clearTimeout(completionTimer);
+                }
+                completionTimer = setTimeout(() => {
+                    if (settled)
+                        return;
+                    forcedExit = true;
+                    safeKill(child, "SIGTERM");
+                    scheduleHardKill(child);
+                    finishResolve();
+                }, exitGraceMs);
+                completionTimer.unref();
+            };
+            const handleLine = (line) => {
+                const normalized = line.replace(/\r$/, "");
+                options?.hooks?.onLine?.(normalized);
+                const parsed = safeJsonParse(normalized);
+                const event = extractAssistantText(parsed);
+                if (event) {
+                    if (event.kind === "delta") {
+                        message += event.text;
+                    }
+                    else {
+                        message = event.text;
+                        scheduleCompletionGrace();
+                    }
+                    options?.hooks?.onAssistantEvent?.(event, normalized);
+                }
+                const parsedError = extractProtocolError(parsed);
+                if (parsedError) {
+                    protocolError = parsedError;
+                }
+                if (isCompletionEvent(parsed)) {
+                    scheduleCompletionGrace();
+                }
+            };
+            const timeoutHandle = setTimeout(() => {
+                if (settled)
+                    return;
+                forcedExit = true;
+                safeKill(child, "SIGTERM");
+                scheduleHardKill(child);
+                const detail = stderr.trim().length > 0 ? `: ${stderr.trim()}` : "";
+                finishReject(new Error(`AUTH_ERROR: codex CLI timed out after ${timeoutMs}ms${detail}`));
+            }, timeoutMs);
+            timeoutHandle.unref();
+            child.stdout?.setEncoding("utf8");
+            child.stdout?.on("data", (chunk) => {
+                const text = chunk.toString();
+                raw += text;
+                lineBuffer += text;
+                let idx;
+                while ((idx = lineBuffer.indexOf("\n")) !== -1) {
+                    const line = lineBuffer.slice(0, idx);
+                    lineBuffer = lineBuffer.slice(idx + 1);
+                    handleLine(line);
+                }
+            });
+            child.stderr?.setEncoding("utf8");
+            child.stderr?.on("data", (chunk) => {
+                stderr += chunk.toString();
+            });
+            child.stdin?.on("error", (error) => {
+                if (settled || isIgnorableStdinError(error))
+                    return;
+                finishReject(new Error(`AUTH_ERROR: codex CLI stdin failed (${error.message})`));
+            });
+            child.on("error", (error) => {
+                finishReject(new Error(`AUTH_ERROR: codex CLI failed (${error.message})`));
+            });
+            child.on("close", (code) => {
+                if (lineBuffer.trim()) {
+                    handleLine(lineBuffer);
+                    lineBuffer = "";
+                }
+                if (settled)
+                    return;
+                if ((code ?? 0) !== 0) {
+                    finishReject(new Error(`AUTH_ERROR: codex CLI failed (exit ${code ?? 0}): ${stderr || protocolError || "no output"}`));
+                    return;
+                }
+                if (protocolError && !finalizeOutput()) {
+                    finishReject(new Error(`AUTH_ERROR: codex CLI failed (${protocolError})`));
+                    return;
+                }
+                finishResolve();
+            });
+            try {
+                child.stdin?.write(prompt);
+                child.stdin?.end();
+            }
+            catch (error) {
+                finishReject(new Error(`AUTH_ERROR: codex CLI stdin failed (${error.message})`));
+            }
+        });
+    }
+    finally {
+        await schemaFile?.cleanup();
+    }
+};
 export const cliHealthy = (throwOnError = false) => {
     if (process.env.MCODA_CLI_STUB === "1") {
         return { ok: true, details: { stub: true } };
@@ -548,7 +825,11 @@ export const cliHealthy = (throwOnError = false) => {
     if (process.env.MCODA_SKIP_CLI_CHECKS === "1") {
         return { ok: true, details: { skipped: true } };
     }
-    const result = spawnSync("codex", ["--version"], { encoding: "utf8", maxBuffer: CODEX_MAX_BUFFER_BYTES });
+    const codexCommand = resolveCodexCommand();
+    const result = spawnSync(codexCommand.command, [...codexCommand.preArgs, "--version"], {
+        encoding: "utf8",
+        maxBuffer: CODEX_MAX_BUFFER_BYTES,
+    });
     if (result.error) {
         const details = { reason: "missing_cli", error: result.error.message };
         if (throwOnError) {
@@ -569,64 +850,17 @@ export const cliHealthy = (throwOnError = false) => {
     }
     return { ok: true, details: { version: result.stdout?.toString().trim() } };
 };
-export const runCodexExec = (prompt, model) => {
+export const runCodexExec = async (prompt, model, outputSchema, timeoutMs) => {
     if (process.env.MCODA_CLI_STUB === "1") {
         const output = `qa-stub:${prompt}`;
         const raw = JSON.stringify({ type: "item.completed", item: { type: "agent_message", text: output } });
         return { output, raw };
     }
-    const health = cliHealthy(true);
-    const resolvedModel = model ?? "gpt-5.1-codex-max";
-    const sandboxArgs = resolveSandboxArgs();
-    const args = [...sandboxArgs.args, "exec", "--model", resolvedModel, "--json"];
-    if (!sandboxArgs.bypass) {
-        args.push("--full-auto");
-    }
-    const reasoningEffort = resolveReasoningEffort(resolvedModel);
-    if (reasoningEffort) {
-        args.push("-c", `model_reasoning_effort=${reasoningEffort}`);
-    }
-    args.push("-");
-    const result = spawnSync("codex", args, {
-        input: prompt,
-        encoding: "utf8",
-        maxBuffer: CODEX_MAX_BUFFER_BYTES,
-    });
-    if (result.error) {
-        const error = new Error(`AUTH_ERROR: codex CLI failed (${result.error.message})`);
-        error.details = { reason: "cli_error", cli: health.details };
-        throw error;
-    }
-    if (result.status !== 0) {
-        const error = new Error(`AUTH_ERROR: codex CLI failed (exit ${result.status}): ${result.stderr ?? result.stdout ?? ""}`);
-        error.details = { reason: "cli_error", exitCode: result.status, stderr: result.stderr };
-        throw error;
-    }
-    const raw = result.stdout?.toString() ?? "";
-    const lines = raw.split(/\r?\n/).filter((l) => l.trim().length > 0);
-    let message = "";
-    for (const line of lines) {
-        try {
-            const parsed = JSON.parse(line);
-            const event = extractAssistantText(parsed);
-            if (!event)
-                continue;
-            if (event.kind === "delta") {
-                message += event.text;
-                continue;
-            }
-            message = event.text;
-        }
-        catch {
-            /* ignore parse errors */
-        }
-    }
-    if (!message) {
-        message = lines[lines.length - 1] ?? "";
-    }
-    return { output: message.trim(), raw };
+    cliHealthy(true);
+    const result = await invokeCodexProcess(prompt, model, { outputSchema, timeoutMs });
+    return { output: result.output, raw: result.raw };
 };
-export async function* runCodexExecStream(prompt, model) {
+export async function* runCodexExecStream(prompt, model, outputSchema, timeoutMs) {
     if (process.env.MCODA_CLI_STUB === "1") {
         const output = `qa-stub:${prompt}\n`;
         const raw = JSON.stringify({ type: "item.delta", item: { type: "agent_message", text: output } });
@@ -635,103 +869,74 @@ export async function* runCodexExecStream(prompt, model) {
     }
     cliHealthy(true);
     const resolvedModel = model ?? "gpt-5.1-codex-max";
-    const sandboxArgs = resolveSandboxArgs();
-    const args = [...sandboxArgs.args, "exec", "--model", resolvedModel, "--json"];
-    if (!sandboxArgs.bypass) {
-        args.push("--full-auto");
-    }
-    const reasoningEffort = resolveReasoningEffort(resolvedModel);
-    if (reasoningEffort) {
-        args.push("-c", `model_reasoning_effort=${reasoningEffort}`);
-    }
-    args.push("-");
-    const child = spawn("codex", args, { stdio: ["pipe", "pipe", "pipe"] });
-    child.stdin.write(prompt);
-    child.stdin.end();
-    let stderr = "";
-    child.stderr?.setEncoding("utf8");
-    child.stderr?.on("data", (chunk) => {
-        stderr += chunk.toString();
-    });
-    const closePromise = new Promise((resolve, reject) => {
-        child.on("error", (err) => reject(err));
-        child.on("close", (code) => resolve(code ?? 0));
-    });
-    const parseLine = (line) => {
-        try {
-            const parsed = JSON.parse(line);
-            return extractAssistantText(parsed);
-        }
-        catch {
-            return null;
-        }
-    };
-    const stream = child.stdout;
-    stream?.setEncoding("utf8");
     const formatter = createStreamFormatter(resolvedModel);
-    let buffer = "";
+    const queue = [];
+    const waiters = [];
+    let done = false;
+    let failure;
     let sawDelta = false;
-    let streamError = null;
-    try {
-        for await (const chunk of stream ?? []) {
-            buffer += chunk;
-            let idx;
-            while ((idx = buffer.indexOf("\n")) !== -1) {
-                const line = buffer.slice(0, idx);
-                buffer = buffer.slice(idx + 1);
-                const normalized = line.replace(/\r$/, "");
-                formatter.handleLine(normalized);
-                const parsed = parseLine(normalized);
-                if (!parsed)
-                    continue;
-                if (parsed.kind === "delta") {
+    let assistantDeltaBuffer = "";
+    const notify = () => {
+        while (waiters.length) {
+            waiters.shift()?.();
+        }
+    };
+    void invokeCodexProcess(prompt, model, {
+        outputSchema,
+        timeoutMs,
+        hooks: {
+            onLine: (line) => {
+                formatter.handleLine(line);
+            },
+            onAssistantEvent: (event, rawLine) => {
+                if (event.kind === "delta") {
                     sawDelta = true;
-                    yield { output: parsed.text, raw: normalized };
-                    continue;
+                    assistantDeltaBuffer += event.text;
+                    queue.push({ output: event.text, raw: rawLine });
+                    notify();
+                    return;
                 }
+                const finalText = event.text;
+                const bufferedText = assistantDeltaBuffer;
+                assistantDeltaBuffer = "";
                 if (!sawDelta) {
-                    const output = parsed.text.endsWith("\n") ? parsed.text : `${parsed.text}\n`;
-                    yield { output, raw: normalized };
+                    const output = finalText.endsWith("\n") ? finalText : `${finalText}\n`;
+                    queue.push({ output, raw: rawLine });
+                    notify();
+                    return;
                 }
                 sawDelta = false;
-            }
-        }
-        const trailing = buffer.replace(/\r$/, "");
-        if (trailing) {
-            formatter.handleLine(trailing);
-            const parsed = parseLine(trailing);
-            if (parsed) {
-                if (parsed.kind === "delta") {
-                    sawDelta = true;
-                    yield { output: parsed.text, raw: trailing };
-                }
-                else if (!sawDelta) {
-                    const output = parsed.text.endsWith("\n") ? parsed.text : `${parsed.text}\n`;
-                    yield { output, raw: trailing };
-                    sawDelta = false;
+                const normalizedFinal = normalizeComparableAssistantText(finalText);
+                const normalizedBuffered = normalizeComparableAssistantText(bufferedText);
+                if (!normalizedFinal || normalizedFinal === normalizedBuffered) {
+                    return;
                 }
-            }
-        }
-    }
-    catch (error) {
-        streamError = error;
-    }
-    const exitCode = await closePromise;
-    if (exitCode !== 0) {
-        formatter.handleLine(JSON.stringify({
-            type: "error",
-            message: `codex exec failed with exit ${exitCode}: ${stderr || "no output"}`,
-        }));
-        const error = new Error(`AUTH_ERROR: codex CLI failed (exit ${exitCode}): ${stderr || "no output"}`);
-        error.details = { reason: "cli_error", exitCode, stderr };
+                const suffix = finalText.startsWith(bufferedText) ? finalText.slice(bufferedText.length) : finalText;
+                const output = suffix.endsWith("\n") ? suffix : `${suffix}\n`;
+                queue.push({ output, raw: rawLine });
+                notify();
+            },
+        },
+    })
+        .catch((error) => {
+        failure = error;
+        formatter.handleLine(JSON.stringify({ type: "error", message: failure.message }));
+    })
+        .finally(() => {
+        done = true;
         formatter.end();
-        if (streamError) {
-            throw streamError;
+        notify();
+    });
+    while (!done || queue.length > 0) {
+        if (queue.length > 0) {
+            yield queue.shift();
+            continue;
         }
-        throw error;
+        await new Promise((resolve) => {
+            waiters.push(resolve);
+        });
     }
-    formatter.end();
-    if (streamError) {
-        throw streamError;
+    if (failure) {
+        throw failure;
     }
 }

package/dist/adapters/openai/OpenAiCliAdapter.js

@@ -19,7 +19,7 @@ export class OpenAiCliAdapter {
     }
     async invoke(request) {
         const cliDetails = codexCliHealthy(true);
-        const result = runCodexExec(request.input, this.config.model);
+        const result = await runCodexExec(request.input, this.config.model);
         return {
             output: result.output,
             adapter: this.config.adapter ?? "codex-cli",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcoda/agents",
-  "version": "0.1.35",
+  "version": "0.1.37",
   "description": "Agent registry and capabilities for mcoda.",
   "type": "module",
   "main": "dist/index.js",
@@ -30,8 +30,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@mcoda/shared": "0.1.35",
-    "@mcoda/db": "0.1.35"
+    "@mcoda/shared": "0.1.37",
+    "@mcoda/db": "0.1.37"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",