@astrosheep/keiyaku 4.6.8 → 4.6.9

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

@@ -0,0 +1,9 @@
+import { type OpenCodeClient } from "@opencode/client";
+/** The matching native SDK owns the dialect; this attempt owns its HTTP connections. */
+export declare function createNativeClient(baseUrl: string, password: string): Readonly<{
+    sdk: OpenCodeClient;
+    subscribe(signal: AbortSignal): Promise<Readonly<{
+        stream: AsyncIterable<unknown>;
+    }>>;
+    close(): Promise<void>;
+}>;

package/build/src/akuma/providers/opencode-sdk/native-http.js

@@ -0,0 +1,69 @@
+import { OpenCode } from "@opencode/client";
+import { Agent } from "undici";
+import { object } from "../decode.js";
+/** The matching native SDK owns the dialect; this attempt owns its HTTP connections. */
+export function createNativeClient(baseUrl, password) {
+    const dispatcher = new Agent();
+    const controller = new AbortController();
+    // Node's fetch accepts an Undici dispatcher in addition to standard RequestInit.
+    // Keep that native extension at this one SDK seam.
+    const ownedFetch = (input, init) => {
+        controller.signal.throwIfAborted();
+        const options = {
+            ...init,
+            dispatcher,
+            signal: init?.signal == null ? controller.signal : AbortSignal.any([controller.signal, init.signal]),
+        };
+        return globalThis.fetch(input, options);
+    };
+    const sdk = OpenCode.make({
+        baseUrl,
+        fetch: ownedFetch,
+        headers: { authorization: `Basic ${Buffer.from(`opencode:${password}`).toString("base64")}` },
+    });
+    const subscribe = async (signal) => {
+        const iterator = sdk.event.subscribe({ signal })[Symbol.asyncIterator]();
+        try {
+            // The producer subscribes before emitting this frame. Headers alone are
+            // not a barrier against losing the opening native admission broadcast.
+            const connected = await iterator.next();
+            if (connected.done || object(connected.value)?.type !== "server.connected") {
+                throw new Error("OpenCode event feed did not confirm subscription");
+            }
+        }
+        catch (error) {
+            await iterator.return?.();
+            throw error;
+        }
+        return {
+            stream: {
+                [Symbol.asyncIterator]: () => ({
+                    next: async () => {
+                        const next = await iterator.next();
+                        // Effect stream-failure frames are not native events. The generated
+                        // SDK parser can yield their payload; never drop that into narration.
+                        if (!next.done && typeof object(next.value)?.type !== "string") {
+                            throw new Error("OpenCode native event feed failed");
+                        }
+                        return next;
+                    },
+                    return: () => iterator.return?.() ?? Promise.resolve({ done: true, value: undefined }),
+                }),
+            },
+        };
+    };
+    let closing;
+    return {
+        sdk,
+        subscribe,
+        close: () => {
+            closing ??= (async () => {
+                controller.abort();
+                // SDK iterator retirement is logical. Dispatcher destruction separately
+                // awaits closure of every socket, including requests aborted during setup.
+                await dispatcher.destroy();
+            })();
+            return closing;
+        },
+    };
+}

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

@@ -1,24 +1,49 @@
-import type { OpencodeClient } from "@opencode-ai/sdk";
+import type { SessionCreateInput, SessionSwitchModelInput } from "@opencode/client";
 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">;
-/**
- * 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 OpencodeSdkSession = Readonly<{
+    create(input: {
+        body: SessionCreateInput;
+    }): Promise<unknown>;
+    get(input: {
+        id: string;
+    }): Promise<unknown>;
+    switchModel(input: {
+        id: string;
+        model: SessionSwitchModelInput["model"];
+    }): Promise<unknown>;
+    instructions(input: {
+        id: string;
+        text: string;
+    }): Promise<unknown>;
+    active(): Promise<unknown>;
+    fork(input: {
+        id: string;
+        before: string;
+    }): Promise<unknown>;
+    interrupt(input: {
+        id: string;
+    }): Promise<unknown>;
+    prompt(input: {
+        id: string;
+        body: {
+            id: string;
+            text: string;
+        };
+    }): Promise<unknown>;
+    message(input: {
+        id: string;
+        messageID: string;
+    }): Promise<unknown>;
+}>;
 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>;
+    subscribe(request: OpencodeEventSubscriptionRequest): Promise<Readonly<{
+        stream: AsyncIterable<unknown>;
+    }>>;
 }>;
 export type OpencodeSdkLoader = (cwd: string, execution: ProviderExecution, signal: AbortSignal) => Promise<Readonly<{
     client: {
@@ -29,31 +54,11 @@ 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;
+    id: 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: {
@@ -62,6 +67,8 @@ export type OpencodeRuntime = Readonly<{
     };
     close: () => Promise<void>;
 }>;
+/** A successful HTML fallback, or a JSON response from another API, is not readiness. */
+export declare function waitReady(json: (path: string) => Promise<unknown>, signal: AbortSignal): Promise<void>;
 export declare function loadOpencode(input: Readonly<{
     execution: ProviderExecution;
     cwd: string;
@@ -71,4 +78,3 @@ 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

@@ -3,90 +3,59 @@ import { randomBytes } from "node:crypto";
 import { abortable } from "../../abort.js";
 import { akumaExecutionEnvironment } from "../execution-environment.js";
 import { spawnDetachedProcess } from "../../../runtime/proc/run.js";
-import { isRecord } from "../decode.js";
+import { object } from "../decode.js";
+import { createNativeClient } from "./native-http.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}`;
+    const timestamp = BigInt(Date.now()) * 0x1000n + BigInt(sequence);
+    return `msg_${timestamp.toString(16)}${randomBytes(14).toString("hex")}`;
 }
 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) };
+    return { providerID: model.slice(0, slash), id: 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",
-});
-/**
- * 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.
- */
+// v2.0.20 Agent.Info.default asks only for external_directory and env reads;
+// question separately requests permission before awaiting its form reply.
+const HEADLESS_PERMISSION_BASE = [
+    { action: "external_directory", resource: "*", effect: "allow" },
+    { action: "read", resource: "*", effect: "allow" },
+    { action: "question", resource: "*", effect: "deny" },
+];
 export function composeHeadlessPermissionConfig(config) {
-    const permission = config?.permission;
-    if (permission !== undefined && !isRecord(permission))
-        return { ...config };
-    return { ...config, permission: { ...HEADLESS_PERMISSION_BASE, ...permission } };
+    const permissions = config?.permissions;
+    if (permissions !== undefined && !Array.isArray(permissions))
+        throw new Error("OpenCode v2 permissions must be a ruleset");
+    const actions = new Set((permissions ?? []).map((rule) => object(rule)?.action));
+    return {
+        ...config,
+        permissions: [...HEADLESS_PERMISSION_BASE.filter((rule) => !actions.has(rule.action)), ...(permissions ?? [])],
+    };
 }
-async function waitReady(client, cwd, signal) {
+/** A successful HTML fallback, or a JSON response from another API, is not readiness. */
+export async function waitReady(json, signal) {
+    let last;
     for (let attempt = 0; attempt < 100; attempt += 1) {
-        if (signal.aborted)
-            throw new Error("OpenCode startup aborted");
+        signal.throwIfAborted();
         try {
-            await abortable(client.session.list({ query: { directory: cwd }, throwOnError: true }), signal);
+            const info = object(await abortable(json("/api/info"), signal));
+            if (typeof info?.version !== "string" ||
+                !info.version.startsWith("2.") ||
+                typeof info.pid !== "number" ||
+                !Array.isArray(info.urls) ||
+                typeof object(info.paths)?.tmp !== "string") {
+                throw new Error("OpenCode readiness requires native v2 server identity");
+            }
             return;
         }
-        catch {
+        catch (error) {
+            last = error;
+            signal.throwIfAborted();
             await new Promise((resolve) => setTimeout(resolve, 100));
         }
     }
-    throw new Error("OpenCode server did not become ready within 10000ms");
+    throw new Error(`OpenCode server did not become ready within 10000ms: ${String(last)}`);
 }
 async function availablePort() {
     return await new Promise((resolve, reject) => {
@@ -105,15 +74,17 @@ async function availablePort() {
 }
 export async function loadOpencode(input) {
     const { execution, cwd, signal, loader, onRuntime, requests } = input;
-    if (loader) {
-        const loaded = await abortable(loader(cwd, { ...execution, env: akumaExecutionEnvironment(process.env, execution.env, requests) }, signal), signal);
+    if (loader !== undefined) {
+        const loaded = await abortable(loader(cwd, {
+            ...execution,
+            env: akumaExecutionEnvironment(process.env, execution.env, requests),
+        }, signal), signal);
         let closing;
         const runtime = {
             client: loaded.client,
-            close: async () => {
-                closing ??= Promise.resolve(loaded.close?.()).then(() => undefined);
-                await closing;
-            },
+            close: () => (closing ??= Promise.resolve()
+                .then(() => loaded.close?.())
+                .then(() => undefined)),
         };
         onRuntime?.(runtime);
         try {
@@ -128,34 +99,56 @@ export async function loadOpencode(input) {
         }
     }
     const port = await availablePort();
+    signal.throwIfAborted();
+    const password = execution.env?.OPENCODE_PASSWORD ??
+        execution.env?.OPENCODE_SERVER_PASSWORD ??
+        randomBytes(32).toString("base64url");
+    const config = composeHeadlessPermissionConfig(execution.config);
     const owned = await spawnDetachedProcess({
         argv: [execution.executable ?? "opencode", "serve", "--hostname", "127.0.0.1", "--port", String(port)],
         cwd,
         env: akumaExecutionEnvironment(process.env, {
-            OPENCODE_CONFIG_CONTENT: JSON.stringify(composeHeadlessPermissionConfig(execution.config)),
+            OPENCODE_CONFIG_CONTENT: JSON.stringify(config),
             ...execution.env,
+            OPENCODE_PASSWORD: password,
+            OPENCODE_SERVER_PASSWORD: password,
         }, requests),
         log: `${cwd}/.opencode.log`,
     });
-    const { createOpencodeClient } = await import("@opencode-ai/sdk");
-    const client = createOpencodeClient({ baseUrl: `http://127.0.0.1:${port}`, directory: cwd });
+    const native = createNativeClient(`http://127.0.0.1:${port}`, password);
     let closing;
+    const options = { signal };
     const runtime = {
-        client: { session: client.session, event: opencodeEventPort(client.event) },
-        close: async () => {
-            closing ??= owned.terminate();
-            await closing;
+        client: {
+            session: {
+                create: async ({ body }) => ({ data: await native.sdk.session.create(body, options) }),
+                get: async ({ id }) => ({ data: await native.sdk.session.get({ sessionID: id }, options) }),
+                switchModel: ({ id, model }) => native.sdk.session.switchModel({ sessionID: id, model }, options),
+                instructions: ({ id, text }) => native.sdk.session.instructions.entry.put({ sessionID: id, key: "keiyaku.system", value: text }, options),
+                active: async () => ({ data: await native.sdk.session.active(options) }),
+                fork: async ({ id, before }) => ({ data: await native.sdk.session.fork({ sessionID: id, before }, options) }),
+                interrupt: ({ id }) => native.sdk.session.interrupt({ sessionID: id, resume: false }),
+                prompt: async ({ id, body }) => ({
+                    data: await native.sdk.session.prompt({ sessionID: id, ...body }, options),
+                }),
+                message: async ({ id, messageID }) => ({
+                    data: await native.sdk.session.message.get({ sessionID: id, messageID }, options),
+                }),
+            },
+            event: { subscribe: ({ signal }) => native.subscribe(signal) },
         },
+        close: () => (closing ??= Promise.all([native.close(), owned.terminate()]).then(() => undefined)),
     };
     onRuntime?.(runtime);
     try {
-        await waitReady(client, cwd, signal);
+        await waitReady(() => native.sdk.server.info({ signal }), signal);
+        signal.throwIfAborted();
+        return runtime;
     }
     catch (error) {
         await runtime.close();
         throw error;
     }
-    return runtime;
 }
 export function coordinate(sessionId) {
     return { sessionId };

package/build/src/akuma/providers/paseo/events.d.ts

@@ -1,5 +1,13 @@
 import type { AgentStreamEventPayload } from "@getpaseo/protocol/messages";
+import type { AgentRuntimeInfo } from "@getpaseo/protocol/agent-types";
 import { AgentEventChannel, type TurnResult } from "../../provider.js";
+/**
+ * The runtime's own confirmation at establishment, reported as a native
+ * provider model id. The installed Paseo wire carries no mid-attempt model
+ * change on this timeline subscription, so a later re-selection is not
+ * observable here and is never invented.
+ */
+export declare function paseoRuntimeModel(info: AgentRuntimeInfo | undefined): string | undefined;
 /** Live fragments belong to a canonical admitted turn, not agent-wide status. */
 export declare class PaseoTurn {
     readonly messageId: string;

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

@@ -1,4 +1,45 @@
 import { AgentEventChannel, otherToolCall } from "../../provider.js";
+import { stringValue } from "../decode.js";
+/**
+ * The runtime's own confirmation at establishment, reported as a native
+ * provider model id. The installed Paseo wire carries no mid-attempt model
+ * change on this timeline subscription, so a later re-selection is not
+ * observable here and is never invented.
+ */
+export function paseoRuntimeModel(info) {
+    const model = info?.model;
+    return typeof model === "string" && model.trim().length > 0 ? model : undefined;
+}
+/**
+ * The observed result text one native detail carries. A detail that observes no
+ * text stays absent; a present empty string remains observed and empty.
+ */
+function detailOutput(detail) {
+    switch (detail.type) {
+        case "shell":
+            return stringValue(detail.output);
+        case "read":
+        case "search":
+            return stringValue(detail.content);
+        case "fetch":
+            return stringValue(detail.result);
+        default:
+            return undefined;
+    }
+}
+/** The verified unified patch a completed edit detail observed, when it supplied one. */
+function detailPatch(detail) {
+    return detail.type === "edit" ? stringValue(detail.unifiedDiff) : undefined;
+}
+/** Attach the observed patch to the one change its correlated path already named. */
+function withObservedPatch(call, patch) {
+    if (call.kind !== "fileChange")
+        return call;
+    const change = call.changes[0];
+    if (patch === undefined || change === undefined || call.changes.length !== 1)
+        return call;
+    return { kind: "fileChange", changes: [{ ...change, patch }] };
+}
 function toolCall(item) {
     const detail = item.detail;
     switch (detail.type) {
@@ -25,18 +66,24 @@ function toolCall(item) {
 function timelineNarration(item, calls) {
     switch (item.type) {
         case "tool_call": {
-            const call = calls.get(item.callId) ?? (item.status === "running" ? toolCall(item) : otherToolCall(item.name));
+            const base = calls.get(item.callId) ?? (item.status === "running" ? toolCall(item) : otherToolCall(item.name));
+            const call = item.status === "running" ? base : withObservedPatch(base, detailPatch(item.detail));
             calls.set(item.callId, call);
-            return item.status === "running"
-                ? { type: "tool", phase: "started", id: item.callId, name: item.name, call }
-                : {
-                    type: "tool",
-                    phase: "completed",
-                    id: item.callId,
-                    name: item.name,
-                    call,
-                    result: { status: item.status === "completed" ? "ok" : "error" },
-                };
+            if (item.status === "running") {
+                return { type: "tool", phase: "started", id: item.callId, name: item.name, call };
+            }
+            const output = detailOutput(item.detail);
+            return {
+                type: "tool",
+                phase: "completed",
+                id: item.callId,
+                name: item.name,
+                call,
+                result: {
+                    status: item.status === "completed" ? "ok" : "error",
+                    ...(output === undefined ? {} : { output }),
+                },
+            };
         }
         case "error":
         case "notification":

package/build/src/akuma/providers/paseo/index.js

@@ -5,8 +5,9 @@ import { z } from "zod";
 import { DaemonClient } from "@getpaseo/client/internal/daemon-client";
 import { bindWsHandler, createWebSocketTransportFactory, defaultWebSocketFactory, } from "@getpaseo/client/internal/daemon-client-websocket-transport";
 import { abortable } from "../../abort.js";
+import { launchPrompt, modelEvent, } from "../../provider.js";
 import { AKUMA_REQUESTS_ENTRY_ENV, akumaExecutionEnvironment } from "../execution-environment.js";
-import { PaseoTurn } from "./events.js";
+import { PaseoTurn, paseoRuntimeModel } from "./events.js";
 import { providerLifecycle } from "../lifecycle.js";
 const configSchema = z
     .object({
@@ -169,6 +170,11 @@ async function applyOptions(client, agent, input, config) {
         (observed.agent.effectiveThinkingOptionId ?? observed.agent.runtimeInfo?.thinkingOptionId) !== effort) {
         throw new Error(`Paseo effort selection was not confirmed: ${effort}`);
     }
+    // The runtime's own answer names the model this agent will run, whether or
+    // not the caller requested one. The snapshot's top-level model may be a
+    // configured fallback rather than what the runtime loaded, so it is never
+    // runtime evidence; an unnamed runtime stays unknown and clears nothing.
+    return paseoRuntimeModel(observed.agent.runtimeInfo);
 }
 class PaseoDrive {
     client;
@@ -216,18 +222,16 @@ class PaseoDrive {
             }))
             : await this.existingAgent(coordinate, input.signal);
         this.agentId = agent.id;
-        await applyOptions(this.client, agent, input, config);
+        const startupModel = await applyOptions(this.client, agent, input, config);
         input.signal.throwIfAborted();
         const subscription = this.client.subscribeAgentTimeline(agent.id, (message) => this.receive(message));
         await abortable(subscription.ready, input.signal);
         this.turn.events.emit({ type: "session", coordinate: { sessionId: agent.id } });
+        if (startupModel !== undefined)
+            this.turn.events.emit(modelEvent(startupModel));
         // Native steer may still replace work if a human wins the check/send race.
         input.signal.throwIfAborted();
-        const parts = [input.body, ...input.launchTells.map((tell) => tell.text)];
-        if (input.schemaJson !== undefined) {
-            parts.push("Respond with JSON matching this JSON Schema and no other text:", input.schemaJson);
-        }
-        const prompt = parts.filter((text) => text.length > 0).join("\n\n");
+        const prompt = launchPrompt(input.body, input.launchTells, input.schemaJson);
         await setup(input.signal, () => {
             this.submitted = true;
             return this.client.sendMessage(agent.id, prompt, { messageId: this.turn.messageId, activeTurnBehavior: "steer" });

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

@@ -25,6 +25,8 @@ export declare const PI_EVENT_DISPOSITIONS: {
     readonly turn_end: "drop";
     readonly turn_start: "drop";
 };
+/** The model this native session will run, from its own selection. */
+export declare function piSessionModel(selected: unknown): string | undefined;
 export type PiEventState = {
     answer: string;
     assistantSeen: boolean;

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

@@ -1,5 +1,5 @@
-import { noteEvent, otherToolCall, unknownEvent } from "../../provider.js";
-import { nonblank, positiveLine, searchToolCall } from "../decode.js";
+import { modelEvent, noteEvent, otherToolCall, unknownEvent } from "../../provider.js";
+import { nonblank, observedTextContent, positiveLine, searchToolCall } from "../decode.js";
 import { diffstatFromUnifiedPatch } from "../unified-patch.js";
 export const PI_EVENT_DISPOSITIONS = {
     agent_end: "drop",
@@ -32,25 +32,25 @@ function record(value) {
         : null;
 }
 function textContent(content) {
-    if (typeof content === "string")
-        return content;
-    if (!Array.isArray(content))
-        return "";
-    return content
-        .map((block) => {
-        const value = record(block);
-        return value?.type === "text" && typeof value.text === "string" ? value.text : "";
-    })
-        .join("");
+    return observedTextContent(content) ?? "";
 }
 function hasTextContent(content) {
-    if (typeof content === "string")
-        return true;
-    return (Array.isArray(content) &&
-        content.some((block) => {
-            const value = record(block);
-            return value?.type === "text" && typeof value.text === "string";
-        }));
+    return observedTextContent(content) !== undefined;
+}
+/**
+ * Pi identifies a model as `<provider>/<id>`, the same convention its model
+ * option uses. The selected model and every recorded response carry both
+ * halves; a response without them names no model and stays unknown.
+ */
+function piModel(provider, id) {
+    const owner = nonblank(provider);
+    const name = nonblank(id);
+    return owner === undefined || name === undefined ? undefined : `${owner}/${name}`;
+}
+/** The model this native session will run, from its own selection. */
+export function piSessionModel(selected) {
+    const value = record(selected);
+    return piModel(value?.provider, value?.id);
 }
 function runCall(name, value) {
     return name === "bash" && typeof value.command === "string" ? { kind: "run", command: value.command } : undefined;
@@ -89,13 +89,14 @@ function refineEditCall(call, result) {
     if (call.kind !== "fileChange")
         return call;
     const details = record(record(result)?.details);
-    if (typeof details?.patch !== "string")
+    const patch = typeof details?.patch === "string" ? details.patch : undefined;
+    if (patch === undefined)
         return call;
-    const diffstat = diffstatFromUnifiedPatch(details.patch);
+    const diffstat = diffstatFromUnifiedPatch(patch);
     const change = call.changes[0];
-    if (diffstat === undefined || change === undefined)
+    if (change === undefined)
         return call;
-    return { kind: "fileChange", changes: [{ ...change, diffstat }] };
+    return { kind: "fileChange", changes: [{ ...change, ...(diffstat === undefined ? {} : { diffstat }), patch }] };
 }
 function toolCall(name, args) {
     const value = record(args) ?? {};
@@ -121,6 +122,7 @@ function translateToolEnd(event, state) {
     state.tools.delete(event.toolCallId);
     const name = started?.name ?? event.toolName;
     const call = started?.call ?? otherToolCall(name);
+    const output = observedTextContent(record(event.result)?.content);
     return [
         {
             type: "tool",
@@ -128,7 +130,10 @@ function translateToolEnd(event, state) {
             id: event.toolCallId,
             name,
             call: event.isError ? call : refineEditCall(call, event.result),
-            result: { status: event.isError ? "error" : "ok" },
+            result: {
+                status: event.isError ? "error" : "ok",
+                ...(output === undefined ? {} : { output }),
+            },
         },
     ];
 }
@@ -137,6 +142,9 @@ function translateMessage(event, state) {
     if (message?.role !== "assistant")
         return [];
     const translated = [];
+    const model = piModel(message.provider, message.model);
+    if (model !== undefined)
+        translated.push(modelEvent(model));
     if (Array.isArray(message.content)) {
         for (const block of message.content) {
             const value = record(block);