@astrosheep/keiyaku 4.5.29 → 4.6.2

package/build/src/akuma/providers/opencode-sdk/event-stream.js

@@ -0,0 +1,92 @@
+/**
+ * A backoff sleep that resolves when the owned signal aborts and always clears
+ * its timer. Cancellation before the sleep starts completes immediately, and a
+ * simultaneous timeout and abort still settles once and drops the listener.
+ */
+function cancellableSleep(signal) {
+    return (milliseconds) => new Promise((resolve) => {
+        if (signal.aborted) {
+            resolve();
+            return;
+        }
+        let timer;
+        const finish = () => {
+            if (timer !== undefined)
+                clearTimeout(timer);
+            signal.removeEventListener("abort", finish);
+            resolve();
+        };
+        timer = setTimeout(finish, milliseconds);
+        signal.addEventListener("abort", finish, { once: true });
+    });
+}
+export function ownEventStream(input) {
+    const controller = new AbortController();
+    const follow = () => {
+        if (!controller.signal.aborted)
+            controller.abort(input.signal.reason);
+    };
+    input.signal.addEventListener("abort", follow, { once: true });
+    if (input.signal.aborted)
+        follow();
+    let iterator;
+    let pending;
+    let settling;
+    let ready;
+    let subscribed;
+    // Retirement may be requested the moment custody owns this stream, so it
+    // waits for the one subscription call rather than reaching an unset value.
+    const subscribing = new Promise((resolve) => {
+        subscribed = resolve;
+    });
+    let settleClosed;
+    let rejectClosed;
+    const closed = new Promise((resolve, reject) => {
+        settleClosed = resolve;
+        rejectClosed = reject;
+    });
+    const retire = () => {
+        if (settling !== undefined)
+            return settling;
+        settling = (async () => {
+            // Abort first: it interrupts the SDK's fetch, reader, and backoff and
+            // settles a pending read, before iterator return can be waited on.
+            if (!controller.signal.aborted)
+                controller.abort(new Error("OpenCode event stream retired"));
+            input.signal.removeEventListener("abort", follow);
+            await subscribing;
+            await ready.catch(() => undefined);
+            const reading = pending;
+            if (reading !== undefined)
+                await reading.catch(() => undefined);
+            if (iterator?.return !== undefined)
+                await iterator.return(undefined);
+        })();
+        settling.then(settleClosed, rejectClosed);
+        return settling;
+    };
+    // The owner is registered before native subscription setup begins, so
+    // resources arriving after cancellation are still owned and retired.
+    input.custody?.own({ closed, abort: retire, forceDispose: retire });
+    ready = (async () => {
+        const subscription = await input.subscribe({
+            directory: input.directory,
+            signal: controller.signal,
+            sleep: cancellableSleep(controller.signal),
+        });
+        iterator = subscription.stream[Symbol.asyncIterator]();
+    })();
+    subscribed();
+    void ready.catch(() => undefined);
+    return {
+        ready,
+        next: () => {
+            const reading = ready.then(() => iterator.next());
+            pending = reading;
+            void reading.catch(() => undefined);
+            return reading;
+        },
+        retire,
+        closed,
+    };
+}

package/build/src/akuma/providers/opencode-sdk/events.d.ts

@@ -49,6 +49,5 @@ export declare const OPENCODE_EVENT_DISPOSITIONS: {
     readonly "server.connected": "dropped";
 };
 export declare function mapEvent(value: unknown, events: Emitter, state: State): void;
-export type EventState = State;
 export declare function createEventState(sessionId?: string): State;
 export {};

package/build/src/akuma/providers/opencode-sdk/index.js

@@ -1,7 +1,7 @@
-import { randomUUID } from "node:crypto";
 import { AgentEventChannel, createProviderAttempt, } from "../../provider.js";
+import { ownEventStream } from "./event-stream.js";
 import { createEventState, mapEvent } from "./events.js";
-import { coordinate, loadOpencode, OPENCODE_SDK_PROVIDER, parseModel } from "./session.js";
+import { coordinate, loadOpencode, messageId, OPENCODE_SDK_PROVIDER, parseModel, } from "./session.js";
 function object(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value)
         ? value
@@ -70,7 +70,7 @@ function newest(rows) {
             return row;
         const at = Number(object(row.info.time)?.created ?? 0);
         const latestAt = Number(object(latest.info.time)?.created ?? 0);
-        return at >= latestAt ? row : latest;
+        return at > latestAt || (at === latestAt && String(row.info.id) > String(latest.info.id)) ? row : latest;
     }, undefined);
 }
 async function readTurnResult(input) {
@@ -83,9 +83,9 @@ async function readTurnResult(input) {
         const rows = messageRows(response, input.sessionId);
         const user = rows.find((row) => row.info.role === "user" && row.info.id === input.messageID);
         if (user === undefined)
-            return undefined;
-        const userId = text(user?.info.id);
-        const assistant = newest(rows.filter((row) => row.info.role === "assistant" && row.info.parentID === userId));
+            return { kind: "failed", diagnostic: "OpenCode completed without the admitted user message" };
+        const userId = text(user.info.id);
+        const assistant = newest(rows.filter((row) => row.info.role === "assistant" && row.info.parentID === userId && row.info.summary !== true));
         const historyId = text(assistant?.info.id);
         if (input.state.failure !== undefined)
             return { kind: "failed", diagnostic: input.state.failure };
@@ -119,10 +119,6 @@ function scopedProperties(value, sessionId) {
     const properties = object(object(value)?.properties);
     return nativeSessionId(value) === sessionId ? properties : undefined;
 }
-function stopIterator(iterator) {
-    const stopped = iterator?.return?.(undefined);
-    void stopped?.catch(() => undefined);
-}
 function nativeProgress(type, properties, busy) {
     if (type === "session.idle")
         return { busy, terminal: busy };
@@ -137,48 +133,122 @@ function startsTurn(value, sessionId, messageID) {
     const info = object(object(event?.properties)?.info);
     return (event?.type === "message.updated" && info?.sessionID === sessionId && info.role === "user" && info.id === messageID);
 }
+function recognizeAdmission(value, sessionId, admission) {
+    const event = object(value);
+    const properties = object(event?.properties);
+    const info = object(properties?.info);
+    if (event?.type === "message.updated" &&
+        info?.sessionID === sessionId &&
+        info.role === "user" &&
+        typeof info.id === "string") {
+        admission.admit(info.id);
+    }
+}
+function observeEvent(input) {
+    const observedSessionId = nativeSessionId(input.value);
+    if (observedSessionId !== undefined && observedSessionId !== input.sessionId) {
+        return { active: input.active, busy: input.busy, terminal: false };
+    }
+    const event = object(input.value);
+    const properties = scopedProperties(input.value, input.sessionId);
+    if (properties === undefined) {
+        if (input.active)
+            mapEvent(input.value, input.events, input.state);
+        return { active: input.active, busy: input.busy, terminal: false };
+    }
+    const starts = !input.active && startsTurn(input.value, input.sessionId, input.messageID);
+    const active = input.active || starts;
+    const busy = starts ? false : input.busy;
+    recognizeAdmission(input.value, input.sessionId, input.admission);
+    const submittedError = event?.type === "session.error" && input.submissionState.started;
+    if (!active && !submittedError)
+        return { active, busy, terminal: false };
+    mapEvent(input.value, input.events, input.state);
+    if (event?.type === "session.error") {
+        input.admission.end();
+        return {
+            active,
+            busy,
+            terminal: true,
+            result: { kind: "failed", diagnostic: input.state.failure ?? diagnostic(properties.error) },
+        };
+    }
+    const progress = nativeProgress(event?.type, properties, busy);
+    return { active, busy: progress.busy, terminal: progress.terminal };
+}
 async function observeTurn(input) {
     let active = false;
     let busy = false;
     try {
         for (;;) {
-            const next = await input.iterator.next();
+            const next = await input.stream.next();
             if (next.done)
                 return { kind: "failed", diagnostic: "OpenCode event stream ended before Turn completion" };
-            const value = eventValue(next.value);
-            const observedSessionId = nativeSessionId(value);
-            if (observedSessionId !== undefined && observedSessionId !== input.sessionId)
-                continue;
-            const event = object(value);
-            const properties = scopedProperties(value, input.sessionId);
-            if (properties === undefined) {
-                if (active)
-                    mapEvent(value, input.events, input.state);
-                continue;
-            }
-            if (startsTurn(value, input.sessionId, input.messageID)) {
-                active = true;
-                busy = false;
-            }
-            const submittedError = event?.type === "session.error" && input.submissionState.started;
-            if (!active && !submittedError)
-                continue;
-            mapEvent(value, input.events, input.state);
-            if (event?.type === "session.error") {
-                return { kind: "failed", diagnostic: input.state.failure ?? diagnostic(properties.error) };
-            }
-            const progress = nativeProgress(event?.type, properties, busy);
-            busy = progress.busy;
-            if (!progress.terminal)
+            const observed = observeEvent({
+                value: eventValue(next.value),
+                sessionId: input.sessionId,
+                messageID: input.messageID,
+                active,
+                busy,
+                admission: input.admission,
+                events: input.events,
+                state: input.state,
+                submissionState: input.submissionState,
+            });
+            active = observed.active;
+            busy = observed.busy;
+            if (observed.result !== undefined)
+                return observed.result;
+            if (!observed.terminal)
                 continue;
-            const result = await readTurnResult(input);
-            if (result !== undefined)
-                return result;
+            input.admission.end();
+            return await readTurnResult({ ...input, messageID: input.admission.latest() });
         }
     }
     catch (error) {
         return { kind: "failed", diagnostic: `OpenCode event stream failed: ${diagnostic(error)}` };
     }
+    finally {
+        input.admission.end();
+    }
+}
+function liveAdmission(initial) {
+    let latest = initial;
+    let ended = false;
+    const pending = new Map();
+    const wait = (id) => {
+        if (ended)
+            return Promise.resolve({ kind: "turn-ended" });
+        return new Promise((resolve, reject) => {
+            pending.set(id, { resolve, reject });
+        });
+    };
+    return {
+        initial: wait(initial),
+        latest: () => latest,
+        open: () => !ended,
+        wait,
+        admit(id) {
+            const waiter = pending.get(id);
+            if (waiter === undefined || ended)
+                return;
+            pending.delete(id);
+            latest = id;
+            waiter.resolve({ kind: "accepted", fence: id });
+        },
+        fail(id, error) {
+            pending.get(id)?.reject(error);
+            pending.delete(id);
+        },
+        end() {
+            if (ended)
+                return;
+            ended = true;
+            for (const waiter of pending.values())
+                waiter.resolve({ kind: "turn-ended" });
+            pending.clear();
+        },
+    };
 }
 function terminalSettlement(events, close) {
     let finish;
@@ -186,8 +256,14 @@ function terminalSettlement(events, close) {
         let settlement;
         finish = (result) => {
             settlement ??= (async () => {
-                events.end();
+                // Whole closure is proved before narration ends. The driver therefore
+                // stays inside its Heart/control observation race while retirement is
+                // outstanding, so a rejected or unprovable closure still reaches attempt
+                // custody's bounded hung handling instead of parking on a pending
+                // completion. Ending narration first would move that await outside the
+                // driver's race and make the Body unresponsive to stop or Heart loss.
                 await close();
+                events.end();
                 resolve(result);
             })();
             return settlement;
@@ -195,6 +271,18 @@ function terminalSettlement(events, close) {
     });
     return { completion, finish };
 }
+/**
+ * One memoized whole-close: stream retirement and existing server retirement
+ * start together on every terminal path, so a live socket can never outwait the
+ * server's death.
+ */
+function wholeClosure(retireStream, closeServer) {
+    let closing;
+    return () => {
+        closing ??= Promise.all([retireStream(), closeServer()]).then(() => undefined);
+        return closing;
+    };
+}
 async function forceDisposeOpencode(abortController, close, finish) {
     abortController.abort();
     await close();
@@ -245,6 +333,46 @@ async function openDriveSession(runtime, input, resumeSessionId, signal) {
         throw new Error("OpenCode did not return a session id");
     return { session, sessionId };
 }
+function createLiveSession(input) {
+    let submissions = input.admission.initial.then(() => undefined);
+    const submit = (tell) => {
+        const submission = async () => {
+            if (!input.admission.open())
+                return { kind: "turn-ended" };
+            const receipt = input.admission.wait(tell.id);
+            void input.session
+                .promptAsync({
+                path: { id: input.sessionId },
+                query: { directory: input.cwd },
+                body: input.promptBody(tell.id, tell.text),
+                throwOnError: true,
+            })
+                .catch((error) => input.admission.fail(tell.id, error));
+            return await receipt;
+        };
+        const next = submissions.then(submission);
+        submissions = next.then(() => undefined, () => undefined);
+        return next;
+    };
+    return {
+        admission: { fence: input.sessionId },
+        events: input.events,
+        completion: input.completion,
+        tell: (tell) => submit({ ...tell, id: input.nextMessageId() }),
+        abort: async () => {
+            input.admission.end();
+            input.abortController.abort();
+            void input.session
+                .abort({ path: { id: input.sessionId }, query: { directory: input.cwd }, throwOnError: true })
+                .catch(() => undefined);
+            await input.finish({ kind: "failed", diagnostic: "OpenCode session interrupted" });
+        },
+        forceDispose: () => {
+            input.admission.end();
+            return forceDisposeOpencode(input.abortController, input.close, input.finish);
+        },
+    };
+}
 async function drive(execution, input, loader, custody) {
     admit(input.options);
     const signal = input.signal ?? new AbortController().signal;
@@ -257,27 +385,34 @@ async function drive(execution, input, loader, custody) {
     const runtime = await loadDriveRuntime(execution, input, abortController.signal, loader, (ready) => {
         closeOnce = ownRuntime(custody, ready);
     });
-    let iterator;
+    const stream = ownEventStream({
+        directory: input.cwd,
+        signal: abortController.signal,
+        ...(custody === undefined ? {} : { custody }),
+        subscribe: (request) => runtime.client.event.subscribe(request),
+    });
+    const wholeClose = wholeClosure(() => stream.retire(), () => closeOnce());
     try {
         const { session, sessionId } = await openDriveSession(runtime, input, resumeSessionId, abortController.signal);
         const events = new AgentEventChannel();
         const state = createEventState(sessionId);
-        const messageID = `msg_${randomUUID().replaceAll("-", "")}`;
+        const messageSequence = { value: 0 };
+        const nextMessageId = () => messageId(messageSequence.value++);
+        const messageID = nextMessageId();
+        const admission = liveAdmission(messageID);
         const submissionState = { started: false };
         events.emit({ type: "session", coordinate: coordinate(sessionId) });
-        const streamResult = await runtime.client.event.subscribe({ query: { directory: input.cwd } });
-        if (abortController.signal.aborted) {
-            await streamResult.stream[Symbol.asyncIterator]().return?.(undefined);
+        await stream.ready;
+        if (abortController.signal.aborted)
             abortController.signal.throwIfAborted();
-        }
-        iterator = streamResult.stream[Symbol.asyncIterator]();
-        const { completion, finish } = terminalSettlement(events, closeOnce);
+        const { completion, finish } = terminalSettlement(events, wholeClose);
         const observation = observeTurn({
-            iterator,
+            stream,
             session,
             sessionId,
             cwd: input.cwd,
             messageID,
+            admission,
             events,
             state,
             submissionState,
@@ -290,26 +425,27 @@ async function drive(execution, input, loader, custody) {
             throwOnError: true,
         });
         abortController.signal.throwIfAborted();
-        void observation.then(finish);
-        signal.removeEventListener("abort", abortSetup);
-        return {
-            admission: { fence: sessionId },
+        // The observer never awaits its own completion: finishing retires the whole
+        // stream, but the observer that invoked finish stays outside that wait. Its
+        // rejection is owned by attempt custody, not by an unobserved promise.
+        void observation.then(finish).catch(() => undefined);
+        return createLiveSession({
+            session,
+            sessionId,
+            cwd: input.cwd,
+            promptBody: (messageID, text) => promptBody({ ...input, body: text, launchTells: [] }, messageID),
+            admission,
+            nextMessageId,
             events,
             completion,
-            abort: async () => {
-                abortController.abort();
-                void session
-                    .abort({ path: { id: sessionId }, query: { directory: input.cwd }, throwOnError: true })
-                    .catch(() => undefined);
-                await finish({ kind: "failed", diagnostic: "OpenCode session interrupted" });
-            },
-            forceDispose: () => forceDisposeOpencode(abortController, closeOnce, finish),
-        };
+            abortController,
+            close: wholeClose,
+            finish,
+        });
     }
     catch (error) {
         signal.removeEventListener("abort", abortSetup);
-        stopIterator(iterator);
-        await closeOnce();
+        await wholeClose();
         throw error;
     }
 }

package/build/src/akuma/providers/opencode-sdk/session.d.ts

@@ -2,7 +2,24 @@ import type { OpencodeClient } from "@opencode-ai/sdk";
 import type { ResumeCoordinate } from "../../heart/index.js";
 import type { ProviderExecution } from "../../provider-recipe.js";
 export type OpencodeSdkSession = Pick<OpencodeClient["session"], "create" | "get" | "fork" | "abort" | "promptAsync" | "messages">;
-export type OpencodeSdkEvent = Pick<OpencodeClient["event"], "subscribe">;
+/**
+ * The adapter's own event subscription port. It carries the cancellation signal
+ * and the cancellable retry backoff the installed client honors at runtime,
+ * without naming the SDK's generated request type at the call site.
+ */
+export type OpencodeEventSubscriptionRequest = Readonly<{
+    directory: string;
+    /** Cancels the subscription's fetch, reader, and retry waiting. */
+    signal: AbortSignal;
+    /** Resolves without rejecting when `signal` aborts, and always clears its timer. */
+    sleep(milliseconds: number): Promise<void>;
+}>;
+type OpencodeEventSubscription = Readonly<{
+    stream: AsyncIterable<unknown>;
+}>;
+export type OpencodeSdkEvent = Readonly<{
+    subscribe(request: OpencodeEventSubscriptionRequest): Promise<OpencodeEventSubscription>;
+}>;
 export type OpencodeSdkLoader = (cwd: string, execution: ProviderExecution, signal: AbortSignal) => Promise<Readonly<{
     client: {
         session: OpencodeSdkSession;
@@ -12,10 +29,32 @@ export type OpencodeSdkLoader = (cwd: string, execution: ProviderExecution, sign
     ready?: Promise<void>;
 }>>;
 export declare const OPENCODE_SDK_PROVIDER: "opencode-sdk";
+/**
+ * Adapt the installed client's generated event endpoint to the adapter's
+ * subscription port.
+ *
+ * The generated per-endpoint `Options` type omits the SDK's runtime
+ * `sseSleepFn` option even though the client forwards every per-request key
+ * into `createSseClient`, so a caller cannot express a cancellable backoff
+ * through the published type. Declaring the port here keeps that one typing gap
+ * and its single adaptation at the SDK seam: no other module repeats a cast,
+ * the SDK's own parser and retry policy stay untouched, and an injected loader
+ * supplies the same port shape.
+ */
+export declare function opencodeEventPort(event: OpencodeClient["event"]): OpencodeSdkEvent;
+export declare function messageId(sequence?: number): string;
 export declare function parseModel(model: string): Readonly<{
     providerID: string;
     modelID: string;
 }>;
+/**
+ * Compose the config handed to a headless opencode server. The permission base
+ * layer fills only the classes the caller leaves unspecified: an explicit caller
+ * permission key wins per key and every non-permission key passes through
+ * untouched. A caller that supplies a non-object `permission` shorthand states
+ * the whole policy and keeps it.
+ */
+export declare function composeHeadlessPermissionConfig(config?: Readonly<Record<string, unknown>>): Record<string, unknown>;
 export type OpencodeRuntime = Readonly<{
     client: {
         session: OpencodeSdkSession;
@@ -32,3 +71,4 @@ export declare function loadOpencode(input: Readonly<{
     requests?: string;
 }>): Promise<OpencodeRuntime>;
 export declare function coordinate(sessionId: string): ResumeCoordinate;
+export {};

package/build/src/akuma/providers/opencode-sdk/session.js

@@ -1,14 +1,81 @@
 import net from "node:net";
+import { randomBytes } from "node:crypto";
 import { abortable } from "../../abort.js";
 import { akumaExecutionEnvironment } from "../execution-environment.js";
 import { spawnDetachedProcess } from "../../../runtime/proc/run.js";
 export const OPENCODE_SDK_PROVIDER = "opencode-sdk";
+/**
+ * Adapt the installed client's generated event endpoint to the adapter's
+ * subscription port.
+ *
+ * The generated per-endpoint `Options` type omits the SDK's runtime
+ * `sseSleepFn` option even though the client forwards every per-request key
+ * into `createSseClient`, so a caller cannot express a cancellable backoff
+ * through the published type. Declaring the port here keeps that one typing gap
+ * and its single adaptation at the SDK seam: no other module repeats a cast,
+ * the SDK's own parser and retry policy stay untouched, and an injected loader
+ * supplies the same port shape.
+ */
+export function opencodeEventPort(event) {
+    return {
+        subscribe: (request) => {
+            const adapted = {
+                query: { directory: request.directory },
+                signal: request.signal,
+            };
+            // Runtime-only key omitted from the generated Options type; the installed
+            // client forwards it to createSseClient unchanged.
+            adapted.sseSleepFn = request.sleep;
+            return event.subscribe(adapted);
+        },
+    };
+}
+export function messageId(sequence = 0) {
+    const timestamp = BigInt(new Date().getTime()) * 0x1000n + BigInt(sequence);
+    const bytes = Buffer.alloc(6);
+    bytes.writeUIntBE(Number(timestamp & 0xffffffffffffn), 0, 6);
+    const alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+    const suffix = [...randomBytes(14)].map((byte) => alphabet[byte % alphabet.length]).join("");
+    return `msg_${bytes.toString("hex")}${suffix}`;
+}
 export function parseModel(model) {
     const slash = model.indexOf("/");
     if (slash <= 0 || slash === model.length - 1)
         throw new Error("OpenCode model must be <provider>/<model>");
     return { providerID: model.slice(0, slash), modelID: model.slice(slash + 1) };
 }
+/**
+ * Permission classes whose upstream defaults can await a human reply. A headless
+ * server has no reply channel, so such a pending ask never settles.
+ *
+ * Verified against the installed opencode 1.18.33 agent permission ruleset: the
+ * primary agents start from `{"*":"allow"}` with `external_directory` and
+ * `doom_loop` set to ask, `read` set to ask for `.env` files, and `question`
+ * allowed (the question tool awaits an answer by semantics). Every other class
+ * matches the allow-all rule and cannot await.
+ */
+const HEADLESS_PERMISSION_BASE = Object.freeze({
+    external_directory: "allow",
+    doom_loop: "allow",
+    read: "allow",
+    question: "deny",
+});
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/**
+ * Compose the config handed to a headless opencode server. The permission base
+ * layer fills only the classes the caller leaves unspecified: an explicit caller
+ * permission key wins per key and every non-permission key passes through
+ * untouched. A caller that supplies a non-object `permission` shorthand states
+ * the whole policy and keeps it.
+ */
+export function composeHeadlessPermissionConfig(config) {
+    const permission = config?.permission;
+    if (permission !== undefined && !isRecord(permission))
+        return { ...config };
+    return { ...config, permission: { ...HEADLESS_PERMISSION_BASE, ...permission } };
+}
 async function waitReady(client, cwd, signal) {
     for (let attempt = 0; attempt < 100; attempt += 1) {
         if (signal.aborted)
@@ -67,7 +134,7 @@ export async function loadOpencode(input) {
         argv: [execution.executable ?? "opencode", "serve", "--hostname", "127.0.0.1", "--port", String(port)],
         cwd,
         env: akumaExecutionEnvironment(process.env, {
-            ...(execution.config === undefined ? {} : { OPENCODE_CONFIG_CONTENT: JSON.stringify(execution.config) }),
+            OPENCODE_CONFIG_CONTENT: JSON.stringify(composeHeadlessPermissionConfig(execution.config)),
             ...execution.env,
         }, requests),
         log: `${cwd}/.opencode.log`,
@@ -76,7 +143,7 @@ export async function loadOpencode(input) {
     const client = createOpencodeClient({ baseUrl: `http://127.0.0.1:${port}`, directory: cwd });
     let closing;
     const runtime = {
-        client,
+        client: { session: client.session, event: opencodeEventPort(client.event) },
         close: async () => {
             closing ??= owned.terminate();
             await closing;

package/build/src/akuma/providers/pi/events.js

@@ -146,7 +146,6 @@ function translateMessage(event, state) {
     const message = record(event.message);
     if (message?.role !== "assistant")
         return [];
-    state.assistantSeen = true;
     const translated = [];
     if (Array.isArray(message.content)) {
         for (const block of message.content) {
@@ -160,7 +159,11 @@ function translateMessage(event, state) {
         }
     }
     const text = textContent(message.content);
-    state.answer = text;
+    const terminal = message.stopReason !== "toolUse";
+    if (terminal) {
+        state.assistantSeen = true;
+        state.answer = text;
+    }
     // Gemini emits an empty text block alongside every tool-use message. It is
     // transport scaffolding, not narration; an ordinary terminal empty answer
     // remains public evidence.

package/build/src/akuma/providers/pi/index.d.ts

@@ -1,12 +1,11 @@
-import type { createAgentSession, createBashToolDefinition, DefaultResourceLoader, getAgentDir, ModelRuntime, SessionManager, CreateAgentSessionOptions } from "@earendil-works/pi-coding-agent";
+import type { createAgentSessionFromServices, createAgentSessionServices, createBashToolDefinition, getAgentDir, SessionManager } from "@earendil-works/pi-coding-agent";
 import type { ProviderExecution } from "../../provider-recipe.js";
 import { type ProviderAdapter } from "../../provider.js";
 export type PiSdk = Readonly<{
-    createAgentSession(options?: CreateAgentSessionOptions): ReturnType<typeof createAgentSession>;
+    createAgentSessionFromServices: typeof createAgentSessionFromServices;
+    createAgentSessionServices: typeof createAgentSessionServices;
     createBashToolDefinition: typeof createBashToolDefinition;
-    DefaultResourceLoader: typeof DefaultResourceLoader;
     getAgentDir: typeof getAgentDir;
-    ModelRuntime: typeof ModelRuntime;
     SessionManager: typeof SessionManager;
 }>;
 export declare function createPiProvider(execution?: ProviderExecution, load?: () => Promise<PiSdk>): ProviderAdapter;