@astrosheep/keiyaku 4.6.7 → 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,92 +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 { 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) };
-}
-/**
- * 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);
+    return { providerID: model.slice(0, slash), id: model.slice(slash + 1) };
 }
-/**
- * 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) => {
@@ -107,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 {
@@ -130,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

@@ -0,0 +1,33 @@
+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;
+    readonly events: AgentEventChannel;
+    readonly admission: Promise<string>;
+    readonly completion: Promise<TurnResult>;
+    private admit;
+    private rejectAdmission;
+    private finish;
+    private rejectCompletion;
+    private turnId;
+    private readonly messages;
+    private readonly messagesById;
+    private readonly calls;
+    private answer;
+    private assistantContiguous;
+    settled: boolean;
+    terminal: boolean;
+    constructor(messageId: string);
+    receive(event: AgentStreamEventPayload): void;
+    private appendAssistant;
+    fail(error: unknown): void;
+}

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

@@ -0,0 +1,204 @@
+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) {
+        case "shell":
+            return { kind: "run", command: detail.command };
+        case "read":
+            return {
+                kind: "read",
+                path: detail.filePath,
+                ...(detail.offset === undefined ? {} : { offset: detail.offset }),
+                ...(detail.limit === undefined ? {} : { limit: detail.limit }),
+            };
+        case "edit":
+        case "write":
+            return { kind: "fileChange", changes: [{ op: "unspecified", path: detail.filePath }] };
+        case "search":
+            return { kind: "search", query: detail.query, scope: detail.toolName === "web_search" ? "web" : "content" };
+        case "unknown":
+            return otherToolCall(item.name, detail.input);
+        default:
+            return otherToolCall(item.name);
+    }
+}
+function timelineNarration(item, calls) {
+    switch (item.type) {
+        case "tool_call": {
+            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);
+            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":
+            return { type: "note", text: item.message };
+        case "compaction":
+            return { type: "note", text: `Context compaction ${item.status}` };
+        case "reasoning":
+        case "user_message":
+        case "assistant_message":
+            return undefined;
+        default:
+            return { type: "unknown", kind: item.type };
+    }
+}
+/** Live fragments belong to a canonical admitted turn, not agent-wide status. */
+export class PaseoTurn {
+    messageId;
+    events = new AgentEventChannel();
+    admission;
+    completion;
+    admit;
+    rejectAdmission;
+    finish;
+    rejectCompletion;
+    turnId;
+    messages = [];
+    messagesById = new Map();
+    calls = new Map();
+    answer = "";
+    assistantContiguous = false;
+    settled = false;
+    terminal = false;
+    constructor(messageId) {
+        this.messageId = messageId;
+        this.admission = new Promise((resolve, reject) => {
+            this.admit = resolve;
+            this.rejectAdmission = reject;
+        });
+        this.completion = new Promise((resolve, reject) => {
+            this.finish = resolve;
+            this.rejectCompletion = reject;
+        });
+        void this.admission.catch(() => undefined);
+        void this.completion.catch(() => undefined);
+    }
+    receive(event) {
+        if (this.settled)
+            return;
+        if (event.type === "timeline" &&
+            event.item.type === "user_message" &&
+            event.item.clientMessageId === this.messageId) {
+            if (event.turnId === undefined)
+                return this.fail(new Error("Paseo native admission omitted turnId"));
+            if (this.turnId !== undefined) {
+                if (this.turnId !== event.turnId)
+                    this.fail(new Error("Paseo canonical admission changed native turn"));
+                return;
+            }
+            this.turnId = event.turnId;
+            this.admit(event.turnId);
+            return;
+        }
+        if (!("turnId" in event) || this.turnId === undefined || event.turnId !== this.turnId)
+            return;
+        if (event.type === "timeline") {
+            if (event.item.type === "assistant_message")
+                this.appendAssistant(event.item);
+            else {
+                this.assistantContiguous = false;
+                const narration = timelineNarration(event.item, this.calls);
+                if (narration !== undefined)
+                    this.events.emit(narration);
+            }
+        }
+        else if (event.type === "turn_completed") {
+            this.settled = true;
+            this.finish({
+                kind: "answered",
+                answer: this.answer,
+                historyId: this.turnId,
+            });
+        }
+        else if (event.type === "turn_failed" || event.type === "turn_canceled") {
+            this.settled = true;
+            this.finish({ kind: "failed", diagnostic: event.type === "turn_failed" ? event.error : event.reason });
+        }
+        if (this.settled) {
+            this.terminal = true;
+            for (const message of this.messages)
+                this.events.emit({ type: "assistant", text: message.text });
+        }
+    }
+    appendAssistant(item) {
+        // Native final text is the last contiguous assistant segment; narration keeps all messages.
+        this.answer = this.assistantContiguous ? this.answer + item.text : item.text;
+        const previous = item.messageId === undefined
+            ? this.assistantContiguous
+                ? this.messages.at(-1)
+                : undefined
+            : this.messagesById.get(item.messageId);
+        this.assistantContiguous = true;
+        if (previous !== undefined)
+            previous.text += item.text;
+        else {
+            const message = { ...(item.messageId === undefined ? {} : { id: item.messageId }), text: item.text };
+            this.messages.push(message);
+            if (item.messageId !== undefined)
+                this.messagesById.set(item.messageId, message);
+        }
+    }
+    fail(error) {
+        if (this.settled)
+            return;
+        this.settled = true;
+        this.rejectAdmission(error);
+        this.rejectCompletion(error);
+    }
+}

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

@@ -0,0 +1,9 @@
+import { DaemonClient, type DaemonClientConfig } from "@getpaseo/client/internal/daemon-client";
+import { type ProviderAdapter } from "../../provider.js";
+import type { ProviderExecution } from "../../provider-recipe.js";
+type PaseoClient = Pick<DaemonClient, "connect" | "close" | "createAgent" | "fetchAgent" | "setAgentModel" | "listProviderModels" | "setAgentThinkingOption" | "sendMessage" | "cancelAgent" | "subscribeAgentTimeline" | "subscribeConnectionStatus">;
+export type PaseoDependencies = Readonly<{
+    createClient?(config: DaemonClientConfig): PaseoClient;
+}>;
+export declare function createPaseoProvider(execution: ProviderExecution, dependencies?: PaseoDependencies): ProviderAdapter;
+export {};