@nowcrew/daemon 0.5.44 → 0.5.46

package/dist/runtimes/kimi-acp-runner.js

@@ -3,7 +3,7 @@ import { parseArgs } from "node:util";
 import { Readable, Writable } from "node:stream";
 import { pathToFileURL } from "node:url";
 import spawn from "cross-spawn";
-import { PROTOCOL_VERSION, client, methods, ndJsonStream, } from "@agentclientprotocol/sdk";
+import { PROTOCOL_VERSION, RequestError, client, methods, ndJsonStream, } from "@agentclientprotocol/sdk";
 import { augmentedPath } from "../runtime-path.js";
 import { startFirstProgressWatchdog } from "./progress-watchdog.js";
 import { assertKimiLegacyPromptFits, buildKimiArgs } from "./kimi.js";
@@ -33,13 +33,13 @@ function textContent(content) {
     }).join("\n");
 }
 /** Translate stable ACP updates into daemon-owned NDJSON, without exposing thought chunks. */
-export function mapKimiAcpUpdate(update) {
+export function mapAcpUpdate(provider, update) {
     if (update.sessionUpdate === "agent_message_chunk" && update.content.type === "text") {
-        return [{ type: "kimi.acp.text_delta", text: update.content.text }];
+        return [{ type: `${provider}.acp.text_delta`, text: update.content.text }];
     }
     if (update.sessionUpdate === "tool_call") {
         return [{
-                type: "kimi.acp.tool_call",
+                type: `${provider}.acp.tool_call`,
                 id: update.toolCallId,
                 title: update.title,
                 ...(update.kind === undefined ? {} : { kind: update.kind }),
@@ -50,7 +50,7 @@ export function mapKimiAcpUpdate(update) {
     if (update.sessionUpdate === "tool_call_update") {
         const output = textContent(update.content);
         return [{
-                type: "kimi.acp.tool_result",
+                type: `${provider}.acp.tool_result`,
                 id: update.toolCallId,
                 ...(update.status === undefined ? {} : { status: update.status }),
                 ...(output ? { content: output } : {}),
@@ -58,6 +58,9 @@ export function mapKimiAcpUpdate(update) {
     }
     return [];
 }
+export function mapKimiAcpUpdate(update) {
+    return mapAcpUpdate("kimi", update);
+}
 function safeErrorMessage(error, prompt) {
     const raw = error instanceof Error ? error.message : String(error);
     const redacted = prompt && raw.includes(prompt) ? raw.replaceAll(prompt, "[prompt redacted]") : raw;
@@ -67,6 +70,20 @@ export function isKimiAuthenticationRequired(error) {
     const message = error instanceof Error ? error.message : String(error);
     return /\bauthentication required\b/i.test(message);
 }
+export function isAcpSessionNotFound(error) {
+    if (!(error instanceof RequestError) || (error.code !== -32602 && error.code !== -32603)) {
+        return false;
+    }
+    let data = "";
+    try {
+        data = JSON.stringify(error.data ?? "");
+    }
+    catch {
+        data = String(error.data ?? "");
+    }
+    return /session not found|no session found|unknown (?:durable )?session/i
+        .test(`${error.message} ${data}`);
+}
 export function kimiResumeMethod(capabilities) {
     if (capabilities?.sessionCapabilities?.resume != null)
         return "resume";
@@ -88,6 +105,36 @@ export function selectKimiPermission(params) {
         ? { outcome: { outcome: "cancelled" } }
         : { outcome: { outcome: "selected", optionId: allowed.optionId } };
 }
+function selectConfigId(options, category) {
+    const normalizedNames = category === "model"
+        ? new Set(["model"])
+        : new Set(["reasoning", "effort", "thought level", "thinking level"]);
+    const matches = (options ?? []).filter((option) => (option.type === "select"
+        && (option.category === category
+            || normalizedNames.has(option.id.toLowerCase())
+            || normalizedNames.has(option.name.toLowerCase()))));
+    return matches.length === 1 ? matches[0].id : null;
+}
+async function applySessionConfig(context, provider, sessionId, configOptions, options) {
+    const modelConfigId = provider === "kimi" && options.model
+        ? "model"
+        : selectConfigId(configOptions, "model");
+    if (options.model && modelConfigId !== null) {
+        await context.request(methods.agent.session.setConfigOption, {
+            sessionId,
+            configId: modelConfigId,
+            value: options.model,
+        });
+    }
+    const reasoningConfigId = selectConfigId(configOptions, "thought_level");
+    if (options.reasoning && reasoningConfigId !== null) {
+        await context.request(methods.agent.session.setConfigOption, {
+            sessionId,
+            configId: reasoningConfigId,
+            value: options.reasoning,
+        });
+    }
+}
 async function readPrompt() {
     process.stdin.setEncoding("utf8");
     let prompt = "";
@@ -116,6 +163,7 @@ async function stopChild(child) {
 }
 /** Probe the ACP transport without starting a session or forcing an optional interactive login flow. */
 export async function probeKimiAcp(options, spawnProcess = spawn) {
+    const provider = options.provider ?? "kimi";
     const child = spawnProcess(options.bin, ["acp"], {
         cwd: process.cwd(),
         // probe 在 daemon 自身 PATH 下运行,补上用户级 CLI 目录,与 which 探测保持一致。
@@ -125,12 +173,13 @@ export async function probeKimiAcp(options, spawnProcess = spawn) {
     if (child.stdin === null || child.stdout === null || child.stderr === null)
         return false;
     child.stderr.resume();
-    const app = client({ name: "nowcrew-daemon-kimi-probe" })
+    const app = client({ name: `nowcrew-daemon-${provider}-probe` })
         .onRequest(methods.client.session.requestPermission, () => ({
         outcome: { outcome: "cancelled" },
     }))
         .onNotification(methods.client.session.update, () => undefined);
     let timeout;
+    let onAbort;
     try {
         const stream = ndJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout));
         const connected = app.connectWith(stream, async (context) => {
@@ -149,6 +198,16 @@ export async function probeKimiAcp(options, spawnProcess = spawn) {
                     resolve(false);
                 }, PROBE_TIMEOUT_MS);
             }),
+            new Promise((resolve) => {
+                onAbort = () => {
+                    void stopChild(child);
+                    resolve(false);
+                };
+                if (options.signal?.aborted)
+                    onAbort();
+                else
+                    options.signal?.addEventListener("abort", onAbort, { once: true });
+            }),
         ]);
         return result;
     }
@@ -158,10 +217,14 @@ export async function probeKimiAcp(options, spawnProcess = spawn) {
     finally {
         if (timeout !== undefined)
             clearTimeout(timeout);
+        if (onAbort !== undefined)
+            options.signal?.removeEventListener("abort", onAbort);
         await stopChild(child);
     }
 }
 export async function runKimiAcp(options) {
+    const provider = options.provider ?? "kimi";
+    const displayName = provider === "kimi" ? "Kimi" : "Hermes";
     const prompt = await readPrompt();
     const child = spawn(options.bin, ["acp"], {
         cwd: process.cwd(),
@@ -170,7 +233,7 @@ export async function runKimiAcp(options) {
     });
     let runtimeChild = child;
     if (child.stdin === null || child.stdout === null || child.stderr === null) {
-        throw new Error("Kimi ACP process did not expose stdio");
+        throw new Error(`${displayName} ACP process did not expose stdio`);
     }
     child.stderr.pipe(process.stderr, { end: false });
     let context = null;
@@ -192,12 +255,12 @@ export async function runKimiAcp(options) {
     };
     process.once("SIGTERM", onSignal);
     process.once("SIGINT", onSignal);
-    const app = client({ name: "nowcrew-daemon-kimi" })
+    const app = client({ name: `nowcrew-daemon-${provider}` })
         .onRequest(methods.client.session.requestPermission, ({ params }) => selectKimiPermission(params))
         .onNotification(methods.client.session.update, async ({ params }) => {
         acpSemanticProgress = true;
         firstProgress.observe();
-        for (const event of mapKimiAcpUpdate(params.update))
+        for (const event of mapAcpUpdate(provider, params.update))
             await jsonLine(event);
     });
     let firstProgress = startFirstProgressWatchdog(() => undefined);
@@ -211,29 +274,44 @@ export async function runKimiAcp(options) {
                 clientCapabilities: {},
                 clientInfo: { name: "nowcrew-daemon", version: "1" },
             });
-            if (process.env.CREW_KIMI_ACP_DEBUG === "1") {
-                process.stderr.write(`Kimi ACP auth methods: ${JSON.stringify(initialized.authMethods ?? [])}\n`);
+            if (provider === "kimi" && process.env.CREW_KIMI_ACP_DEBUG === "1") {
+                process.stderr.write(`${displayName} ACP auth methods: ${JSON.stringify(initialized.authMethods ?? [])}\n`);
             }
+            let configOptions;
             if (options.resume && options.sessionId) {
                 const resumeMethod = kimiResumeMethod(initialized.agentCapabilities);
-                if (resumeMethod === "resume") {
-                    await nextContext.request(methods.agent.session.resume, {
-                        sessionId: options.sessionId,
-                        cwd: process.cwd(),
-                        mcpServers: [],
-                    });
+                try {
+                    if (resumeMethod === "resume") {
+                        const resumed = await nextContext.request(methods.agent.session.resume, {
+                            sessionId: options.sessionId,
+                            cwd: process.cwd(),
+                            mcpServers: [],
+                        });
+                        configOptions = resumed.configOptions;
+                    }
+                    else if (resumeMethod === "load") {
+                        const loaded = await nextContext.request(methods.agent.session.load, {
+                            sessionId: options.sessionId,
+                            cwd: process.cwd(),
+                            mcpServers: [],
+                        });
+                        configOptions = loaded.configOptions;
+                    }
+                    else {
+                        throw new Error(`${displayName} ACP does not advertise session resume support`);
+                    }
+                    sessionId = options.sessionId;
                 }
-                else if (resumeMethod === "load") {
-                    await nextContext.request(methods.agent.session.load, {
-                        sessionId: options.sessionId,
+                catch (error) {
+                    if (provider !== "hermes" || !isAcpSessionNotFound(error))
+                        throw error;
+                    const session = await nextContext.request(methods.agent.session.new, {
                         cwd: process.cwd(),
                         mcpServers: [],
                     });
+                    sessionId = session.sessionId;
+                    configOptions = session.configOptions;
                 }
-                else {
-                    throw new Error("Kimi ACP does not advertise session resume support");
-                }
-                sessionId = options.sessionId;
             }
             else {
                 const session = await nextContext.request(methods.agent.session.new, {
@@ -241,15 +319,10 @@ export async function runKimiAcp(options) {
                     mcpServers: [],
                 });
                 sessionId = session.sessionId;
+                configOptions = session.configOptions;
             }
             await jsonLine({ type: "thread.started", thread_id: sessionId });
-            if (options.model) {
-                await nextContext.request(methods.agent.session.setConfigOption, {
-                    sessionId,
-                    configId: "model",
-                    value: options.model,
-                });
-            }
+            await applySessionConfig(nextContext, provider, sessionId, configOptions, options);
             firstProgress = startFirstProgressWatchdog(() => {
                 progressTimedOut = true;
                 void cancel();
@@ -261,7 +334,7 @@ export async function runKimiAcp(options) {
         });
         firstProgress.stop();
         if (progressTimedOut) {
-            process.stderr.write("Kimi produced no semantic progress within the startup window\n");
+            process.stderr.write(`${displayName} produced no semantic progress within the startup window\n`);
             return 1;
         }
         const usage = result.usage;
@@ -281,10 +354,10 @@ export async function runKimiAcp(options) {
     }
     catch (error) {
         if (progressTimedOut) {
-            process.stderr.write("Kimi produced no semantic progress within the startup window\n");
+            process.stderr.write(`${displayName} produced no semantic progress within the startup window\n`);
             return 1;
         }
-        if (!acpSemanticProgress && isKimiAuthenticationRequired(error)) {
+        if (provider === "kimi" && !acpSemanticProgress && isKimiAuthenticationRequired(error)) {
             firstProgress.stop();
             await stopChild(child);
             process.stderr.write("Kimi ACP requires account login; falling back to configured CLI provider transport\n");
@@ -323,7 +396,7 @@ export async function runKimiAcp(options) {
             }
             return code;
         }
-        process.stderr.write(`Kimi ACP execution failed: ${safeErrorMessage(error, prompt)}\n`);
+        process.stderr.write(`${displayName} ACP execution failed: ${safeErrorMessage(error, prompt)}\n`);
         return 1;
     }
     finally {
@@ -337,19 +410,26 @@ function optionsFromArgv(argv) {
     const { values } = parseArgs({
         args: [...argv],
         options: {
+            provider: { type: "string", default: "kimi" },
             bin: { type: "string" },
             model: { type: "string" },
+            reasoning: { type: "string" },
             session: { type: "string" },
             resume: { type: "boolean", default: false },
         },
     });
     if (!values.bin)
         throw new Error("--bin is required");
+    if (values.provider !== "kimi" && values.provider !== "hermes") {
+        throw new Error("--provider must be kimi or hermes");
+    }
     if (values.resume && !values.session)
         throw new Error("--resume requires --session");
     return {
+        provider: values.provider,
         bin: values.bin,
         ...(values.model ? { model: values.model } : {}),
+        ...(values.reasoning ? { reasoning: values.reasoning } : {}),
         ...(values.session ? { sessionId: values.session } : {}),
         ...(values.resume ? { resume: true } : {}),
     };
@@ -358,7 +438,7 @@ if (process.argv[1] !== undefined && import.meta.url === pathToFileURL(process.a
     runKimiAcp(optionsFromArgv(process.argv.slice(2)))
         .then((code) => { process.exitCode = code; })
         .catch((error) => {
-        process.stderr.write(`Kimi ACP runner failed: ${safeErrorMessage(error, "")}\n`);
+        process.stderr.write(`ACP runner failed: ${safeErrorMessage(error, "")}\n`);
         process.exitCode = 1;
     });
 }

package/dist/runtimes/opencode-runner.js

@@ -0,0 +1,122 @@
+import { once } from "node:events";
+import { createInterface } from "node:readline";
+import { parseArgs } from "node:util";
+import { pathToFileURL } from "node:url";
+import spawn from "cross-spawn";
+import { augmentedPath } from "../runtime-path.js";
+import { buildOpenCodeArgs, createOpenCodeEventDecoder } from "./opencode.js";
+const ERROR_CAP = 2_000;
+async function readPrompt() {
+    process.stdin.setEncoding("utf8");
+    let prompt = "";
+    for await (const chunk of process.stdin)
+        prompt += String(chunk);
+    if (!prompt)
+        throw new Error("OpenCode prompt is empty");
+    return prompt;
+}
+async function jsonLine(event) {
+    if (process.stdout.write(`${JSON.stringify(event)}\n`))
+        return;
+    await once(process.stdout, "drain");
+}
+export function isOpenCodeSessionNotFound(message) {
+    return /(?:session|conversation).*(?:not found|does not exist|unknown|invalid)|(?:not found|unknown|invalid).*(?:session|conversation)/iu
+        .test(message);
+}
+async function runAttempt(options, prompt) {
+    const cwd = process.cwd();
+    const child = spawn(options.bin, buildOpenCodeArgs({ cwd, ...options }), {
+        cwd,
+        env: { ...process.env, PATH: augmentedPath(), PWD: cwd },
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    if (!child.stdin || !child.stdout || !child.stderr) {
+        throw new Error("OpenCode process did not expose stdio");
+    }
+    child.stderr.pipe(process.stderr, { end: false });
+    const childExit = once(child, "close");
+    child.stdin.end(prompt);
+    const decoder = createOpenCodeEventDecoder();
+    const lines = createInterface({ input: child.stdout });
+    const pending = [];
+    let emittedSemanticOutput = false;
+    for await (const line of lines) {
+        let event;
+        try {
+            event = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        for (const normalized of decoder.push(event)) {
+            const type = normalized.type;
+            const semantic = type === "opencode.text_delta"
+                || type === "opencode.tool_call"
+                || type === "opencode.tool_result";
+            if (!emittedSemanticOutput && !semantic) {
+                pending.push(normalized);
+                continue;
+            }
+            if (!emittedSemanticOutput) {
+                emittedSemanticOutput = true;
+                for (const buffered of pending.splice(0))
+                    await jsonLine(buffered);
+            }
+            await jsonLine(normalized);
+        }
+    }
+    const [exitCode, signal] = await childExit;
+    const result = decoder.finish();
+    const staleSession = options.sessionId !== undefined
+        && !emittedSemanticOutput
+        && result.error !== undefined
+        && isOpenCodeSessionNotFound(result.error);
+    if (staleSession)
+        return { code: 1, staleSession: true };
+    for (const buffered of pending)
+        await jsonLine(buffered);
+    if (!result.ok) {
+        process.stderr.write(`${result.error?.slice(0, ERROR_CAP)}\n`);
+        return { code: 1, staleSession: false };
+    }
+    if (exitCode !== 0)
+        return { code: exitCode ?? (signal ? 128 : 1), staleSession: false };
+    await jsonLine({ type: "turn.completed", ...(result.usage ? { usage: result.usage } : {}) });
+    return { code: 0, staleSession: false };
+}
+export async function runOpenCode(options) {
+    const prompt = await readPrompt();
+    const first = await runAttempt(options, prompt);
+    if (!first.staleSession)
+        return first.code;
+    const { sessionId: _staleSessionId, ...freshOptions } = options;
+    return (await runAttempt(freshOptions, prompt)).code;
+}
+function optionsFromArgv(argv) {
+    const { values } = parseArgs({
+        args: [...argv],
+        options: {
+            bin: { type: "string" },
+            model: { type: "string" },
+            reasoning: { type: "string" },
+            session: { type: "string" },
+        },
+    });
+    if (!values.bin)
+        throw new Error("--bin is required");
+    return {
+        bin: values.bin,
+        ...(values.model ? { model: values.model } : {}),
+        ...(values.reasoning ? { reasoning: values.reasoning } : {}),
+        ...(values.session ? { sessionId: values.session } : {}),
+    };
+}
+if (process.argv[1] !== undefined && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    runOpenCode(optionsFromArgv(process.argv.slice(2)))
+        .then((code) => { process.exitCode = code; })
+        .catch((error) => {
+        process.stderr.write(`OpenCode runner failed: ${String(error).slice(0, ERROR_CAP)}\n`);
+        process.exitCode = 1;
+    });
+}

package/dist/runtimes/opencode.js

@@ -0,0 +1,181 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { isWin } from "../platform.js";
+import { augmentedPath } from "../runtime-path.js";
+const execFileP = promisify(execFile);
+const REQUIRED_RUN_FLAGS = [
+    "--format",
+    "--dangerously-skip-permissions",
+    "--dir",
+    "--model",
+    "--variant",
+    "--session",
+];
+export async function probeOpenCodeRun(signal) {
+    try {
+        const { stdout, stderr } = await execFileP("opencode", ["run", "--help"], {
+            shell: isWin(),
+            timeout: 8_000,
+            killSignal: "SIGKILL",
+            maxBuffer: 1024 * 1024,
+            signal,
+            env: { ...process.env, PATH: augmentedPath() },
+        });
+        const help = `${stdout}\n${stderr}`;
+        return REQUIRED_RUN_FLAGS.every((flag) => help.includes(flag));
+    }
+    catch {
+        return false;
+    }
+}
+export function buildOpenCodeArgs(options) {
+    return [
+        "run", "--format", "json", "--dangerously-skip-permissions",
+        "--dir", options.cwd,
+        ...(options.model ? ["--model", options.model] : []),
+        ...(options.reasoning ? ["--variant", options.reasoning] : []),
+        ...(options.sessionId ? ["--session", options.sessionId] : []),
+    ];
+}
+function outputText(value) {
+    if (typeof value === "string")
+        return value;
+    if (value === undefined || value === null)
+        return "";
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function reportedUsage(part) {
+    if ((part.cost ?? 0) > 0)
+        return true;
+    const tokens = part.tokens;
+    if (!tokens)
+        return false;
+    return (tokens.input ?? 0) > 0 || (tokens.output ?? 0) > 0
+        || (tokens.reasoning ?? 0) > 0 || (tokens.total ?? 0) > 0
+        || (tokens.cache?.read ?? 0) > 0 || (tokens.cache?.write ?? 0) > 0;
+}
+export function createOpenCodeEventDecoder() {
+    let sessionId = null;
+    let announcedSession = null;
+    let finalText = "";
+    let error = null;
+    let openStep = false;
+    let stepHasContinuationTool = false;
+    let awaitingContinuation = false;
+    let stepProducedOutput = false;
+    let lastStepVoid = false;
+    let sawEvent = false;
+    let sawStepFinish = false;
+    const usage = {
+        input_tokens: 0,
+        output_tokens: 0,
+        cache_read_input_tokens: 0,
+        cache_creation_input_tokens: 0,
+    };
+    return {
+        push(raw) {
+            const event = (raw ?? {});
+            const out = [];
+            if (typeof event.type === "string" && event.type)
+                sawEvent = true;
+            if (typeof event.sessionID === "string" && event.sessionID) {
+                sessionId = event.sessionID;
+                if (announcedSession !== sessionId) {
+                    announcedSession = sessionId;
+                    out.push({ type: "thread.started", thread_id: sessionId });
+                }
+            }
+            const part = event.part ?? {};
+            if (event.type === "step_start") {
+                openStep = true;
+                awaitingContinuation = false;
+                stepHasContinuationTool = false;
+                stepProducedOutput = false;
+                out.push({ type: "opencode.step_start" });
+            }
+            else if (event.type === "text" && typeof part.text === "string" && part.text) {
+                finalText += part.text;
+                stepProducedOutput = true;
+                out.push({ type: "opencode.text_delta", text: part.text });
+            }
+            else if (event.type === "tool_use") {
+                stepProducedOutput = true;
+                if (part.metadata?.providerExecuted !== true)
+                    stepHasContinuationTool = true;
+                out.push({
+                    type: "opencode.tool_call",
+                    ...(part.callID ? { id: part.callID } : {}),
+                    ...(part.tool ? { title: part.tool } : {}),
+                    ...(part.state?.input === undefined ? {} : { input: part.state.input }),
+                });
+                if (part.state?.status === "completed" || part.state?.status === "error") {
+                    const content = part.state.status === "error" && part.state.error
+                        ? part.state.error
+                        : outputText(part.state.output);
+                    out.push({
+                        type: "opencode.tool_result",
+                        ...(part.callID ? { id: part.callID } : {}),
+                        status: part.state.status,
+                        ...(content ? { content } : {}),
+                    });
+                }
+            }
+            else if (event.type === "step_finish") {
+                openStep = false;
+                sawStepFinish = true;
+                awaitingContinuation = part.reason === "tool-calls"
+                    || (Boolean(part.reason) && stepHasContinuationTool);
+                stepHasContinuationTool = false;
+                if (reportedUsage(part))
+                    stepProducedOutput = true;
+                lastStepVoid = !stepProducedOutput;
+                const tokens = part.tokens;
+                if (tokens) {
+                    usage.input_tokens += tokens.input ?? 0;
+                    usage.output_tokens += tokens.output ?? 0;
+                    usage.cache_read_input_tokens += tokens.cache?.read ?? 0;
+                    usage.cache_creation_input_tokens += tokens.cache?.write ?? 0;
+                }
+                out.push({
+                    type: "opencode.step_finish",
+                    ...(part.reason ? { stop_reason: part.reason } : {}),
+                    ...(tokens ? { usage: {
+                            input_tokens: tokens.input ?? 0,
+                            output_tokens: tokens.output ?? 0,
+                            cache_read_input_tokens: tokens.cache?.read ?? 0,
+                            cache_creation_input_tokens: tokens.cache?.write ?? 0,
+                        } } : {}),
+                });
+            }
+            else if (event.type === "error") {
+                error = event.error?.data?.message || event.error?.name || "unknown OpenCode error";
+                out.push({ type: "opencode.error", message: error });
+            }
+            return out;
+        },
+        finish() {
+            const structuralError = openStep
+                ? "OpenCode stream ended while a step was still open"
+                : awaitingContinuation
+                    ? "OpenCode stream ended before the required continuation"
+                    : lastStepVoid
+                        ? "OpenCode stream ended on an empty step"
+                        : !sawEvent || !sawStepFinish
+                            ? "OpenCode stream ended with no events proving completion"
+                            : null;
+            const failure = error ?? structuralError;
+            return {
+                ok: failure === null,
+                ...(failure === null ? {} : { error: failure }),
+                finalText,
+                sessionId,
+                ...(sawStepFinish ? { usage } : {}),
+            };
+        },
+    };
+}