@astrosheep/keiyaku 4.0.1 → 4.0.2

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

@@ -1,31 +1,33 @@
+import { randomUUID } from "node:crypto";
+import { abortable } from "../../abort.js";
 import { AgentEventChannel } from "../../provider.js";
 import { createEventState, mapEvent } from "./events.js";
 import { coordinate, loadOpencode, OPENCODE_SDK_PROVIDER, parseModel } from "./session.js";
-function diagnostic(error) { return error instanceof Error ? error.message : String(error); }
-function opencodeSessionId(coordinate) {
-    if (!("sessionId" in coordinate) || coordinate.sessionId === undefined) {
+function object(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value : undefined;
+}
+function text(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+function diagnostic(error) {
+    const value = object(error);
+    const nested = object(value?.data);
+    return text(nested?.message) ?? text(value?.message) ?? String(error);
+}
+function opencodeSessionId(coordinateValue) {
+    if (!("sessionId" in coordinateValue) || coordinateValue.sessionId === undefined) {
         throw new Error("OpenCode resume requires sessionId");
     }
-    return coordinate.sessionId;
+    return coordinateValue.sessionId;
 }
 function admit(options) {
-    if (options.access !== undefined)
-        throw new Error("OpenCode does not support explicit access");
     if (options.network !== undefined)
         throw new Error("OpenCode does not support explicit network");
-    if (options.systemPrompt !== undefined && options.systemPrompt.length > 0) {
-        throw new Error("OpenCode V2 does not expose an enforceable system prompt option");
-    }
-    if (options.effort !== undefined && options.model === undefined) {
-        throw new Error("OpenCode effort requires an explicit model");
-    }
     if (options.model !== undefined)
-        parseModel(options.model, options.effort);
+        parseModel(options.model);
 }
 function eventValue(value) {
-    const envelope = objectData(value);
-    if (envelope !== undefined && typeof envelope.data === "string")
-        return eventValue(envelope.data);
     if (typeof value !== "string")
         return value;
     try {
@@ -35,135 +37,228 @@ function eventValue(value) {
         return { type: value };
     }
 }
+function promptBody(input, messageID) {
+    const model = input.options.model === undefined ? undefined : parseModel(input.options.model);
+    const promptText = [input.body, ...input.launchTells.map((tell) => tell.text)]
+        .filter((part) => part.length > 0)
+        .join("\n\n");
+    return {
+        messageID,
+        ...(model === undefined ? {} : { model }),
+        ...(input.options.effort === undefined ? {} : { variant: input.options.effort }),
+        ...(input.options.systemPrompt === undefined ? {} : { system: input.options.systemPrompt }),
+        parts: [{ type: "text", text: promptText }],
+    };
+}
+function messageRows(value, sessionId) {
+    const response = object(value);
+    const rows = Array.isArray(response?.data) ? response.data : Array.isArray(value) ? value : [];
+    return rows.flatMap((row) => {
+        const entry = object(row);
+        const info = object(entry?.info);
+        if (info?.sessionID !== sessionId)
+            return [];
+        return [{ info, parts: Array.isArray(entry?.parts) ? entry.parts : [] }];
+    });
+}
+function newest(rows) {
+    return rows.reduce((latest, row) => {
+        if (latest === undefined)
+            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;
+    }, undefined);
+}
+async function readTurnResult(input) {
+    try {
+        const response = await input.session.messages({
+            path: { id: input.sessionId },
+            query: { directory: input.cwd },
+            throwOnError: true,
+        });
+        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));
+        const historyId = text(assistant?.info.id);
+        if (input.state.failure !== undefined)
+            return { kind: "failed", diagnostic: input.state.failure };
+        if (assistant === undefined)
+            return { kind: "failed", diagnostic: "OpenCode completed without a native assistant answer" };
+        if (assistant.info.error !== undefined)
+            return { kind: "failed", diagnostic: diagnostic(assistant.info.error) };
+        const answer = assistant.parts
+            .map((part) => object(part))
+            .filter((part) => part?.type === "text")
+            .map((part) => part?.text)
+            .filter((part) => typeof part === "string")
+            .join("\n\n");
+        return historyId === undefined ? { kind: "answered", answer } : { kind: "answered", answer, historyId };
+    }
+    catch (error) {
+        return { kind: "failed", diagnostic: diagnostic(error) };
+    }
+}
+function nativeSessionId(value) {
+    const event = object(value);
+    const properties = object(event?.properties);
+    const direct = text(properties?.sessionID);
+    if (direct !== undefined)
+        return direct;
+    const info = object(properties?.info);
+    const part = object(properties?.part);
+    return text(info?.sessionID) ?? text(part?.sessionID);
+}
+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 };
+    if (type !== "session.status")
+        return { busy, terminal: false };
+    const status = object(properties.status)?.type;
+    const nextBusy = busy || status === "busy";
+    return { busy: nextBusy, terminal: status === "idle" && nextBusy };
+}
+function startsTurn(value, sessionId, messageID) {
+    const event = object(value);
+    const info = object(object(event?.properties)?.info);
+    return event?.type === "message.updated"
+        && info?.sessionID === sessionId
+        && info.role === "user"
+        && info.id === messageID;
+}
+async function observeTurn(input) {
+    let active = false;
+    let busy = false;
+    try {
+        for (;;) {
+            const next = await input.iterator.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)
+                continue;
+            const result = await readTurnResult(input);
+            if (result !== undefined)
+                return result;
+        }
+    }
+    catch (error) {
+        return { kind: "failed", diagnostic: `OpenCode event stream failed: ${diagnostic(error)}` };
+    }
+}
+function terminalSettlement(events, close) {
+    let finish;
+    const completion = new Promise((resolve) => {
+        let settlement;
+        finish = (result) => {
+            settlement ??= (async () => {
+                events.end();
+                await close();
+                resolve(result);
+            })();
+            return settlement;
+        };
+    });
+    return { completion, finish };
+}
 async function drive(execution, input, loader) {
     admit(input.options);
+    const signal = input.signal ?? new AbortController().signal;
     const resumeSessionId = input.session.kind === "resume"
         ? opencodeSessionId(input.session.coordinate)
         : undefined;
-    const events = new AgentEventChannel();
-    const state = createEventState();
     const abortController = new AbortController();
-    const runtime = await loadOpencode(execution, input.cwd, abortController.signal, loader);
-    let closed = false;
-    const closeOnce = async () => {
-        if (closed)
-            return;
-        closed = true;
-        await runtime.close();
+    const abortSetup = () => abortController.abort(signal.reason);
+    signal.addEventListener("abort", abortSetup, { once: true });
+    signal.throwIfAborted();
+    const runtime = await abortable(loadOpencode(execution, input.cwd, abortController.signal, loader), abortController.signal, async (late) => await late.close());
+    let closing;
+    let iterator;
+    const closeOnce = () => {
+        closing ??= runtime.close();
+        return closing;
     };
     try {
-        const session = runtime.client.v2.session;
-        const model = input.options.model === undefined ? undefined : parseModel(input.options.model, input.options.effort);
-        const response = input.session.kind === "fresh"
-            ? await session.create({ location: { directory: input.cwd }, ...(model === undefined ? {} : { model }) }, { throwOnError: true })
-            : await session.get({ sessionID: resumeSessionId }, { throwOnError: true });
-        const responseData = objectData(objectData(response)?.data);
-        const info = objectData(responseData?.data) ?? responseData;
-        const sessionId = textData(info?.id) ?? resumeSessionId;
+        const session = runtime.client.session;
+        const sessionResponse = await abortable(input.session.kind === "fresh"
+            ? session.create({ query: { directory: input.cwd }, throwOnError: true })
+            : session.get({ path: { id: resumeSessionId }, query: { directory: input.cwd }, throwOnError: true }), abortController.signal);
+        const info = object(object(sessionResponse)?.data) ?? object(sessionResponse);
+        const sessionId = text(info?.id) ?? resumeSessionId;
         if (sessionId === undefined)
             throw new Error("OpenCode did not return a session id");
-        if (input.session.kind === "resume" && model !== undefined) {
-            await session.switchModel({ sessionID: sessionId, model }, { throwOnError: true });
-        }
+        const events = new AgentEventChannel();
+        const state = createEventState(sessionId);
+        const messageID = `msg_${randomUUID().replaceAll("-", "")}`;
+        const submissionState = { started: false };
         events.emit({ type: "session", coordinate: coordinate(sessionId) });
-        const streamResult = await session.events({ sessionID: sessionId });
-        const iterator = streamResult.stream[Symbol.asyncIterator]();
-        const promptText = [input.body, ...input.launchTells.map((tell) => tell.text)].filter((part) => part.length > 0).join("\n\n");
-        const promptResponse = await session.prompt({ sessionID: sessionId, prompt: { text: promptText } }, { throwOnError: true });
-        const fence = admittedFence(sessionId, promptResponse);
-        let settled = false;
-        let settle;
-        const completion = new Promise((resolve) => { settle = resolve; });
-        const finish = async (result) => {
-            if (settled)
-                return;
-            settled = true;
-            events.end();
-            try {
-                await closeOnce();
-                settle(result);
-            }
-            catch (error) {
-                settle({ kind: "failed", diagnostic: `OpenCode cleanup failed: ${diagnostic(error)}` });
-            }
-        };
-        void (async () => {
-            try {
-                await consumeSession(session, sessionId, iterator, state, events);
-                const messages = await session.messages({ sessionID: sessionId, order: "desc", limit: 32 }, { throwOnError: true });
-                const final = messages.data.data.find((message) => message.type === "assistant");
-                const answer = final?.type === "assistant" ? final.content.filter((part) => part.type === "text").map((part) => part.text).join("\n\n") : state.answer.join("\n\n");
-                const historyId = final?.type === "assistant" ? textData(final.id) : undefined;
-                if (state.failure !== undefined || final?.type === "assistant" && final.error !== undefined)
-                    await finish({ kind: "failed", diagnostic: state.failure ?? diagnostic(final?.type === "assistant" ? final.error : undefined) });
-                else if (historyId === undefined) {
-                    await finish({ kind: "failed", diagnostic: "OpenCode completed without a native assistant answer/history point" });
-                }
-                else
-                    await finish({ kind: "answered", answer, historyId });
-            }
-            catch (error) {
-                await finish({ kind: "failed", diagnostic: diagnostic(error) });
-            }
-        })();
+        const streamResult = await abortable(runtime.client.event.subscribe({ query: { directory: input.cwd } }), abortController.signal, async (late) => { await late.stream[Symbol.asyncIterator]().return?.(undefined); });
+        iterator = streamResult.stream[Symbol.asyncIterator]();
+        const { completion, finish } = terminalSettlement(events, closeOnce);
+        const observation = observeTurn({
+            iterator, session, sessionId, cwd: input.cwd, messageID, events, state, submissionState,
+        });
+        submissionState.started = true;
+        await abortable(session.promptAsync({
+            path: { id: sessionId },
+            query: { directory: input.cwd },
+            body: promptBody(input, messageID),
+            throwOnError: true,
+        }), abortController.signal);
+        void observation.then(finish);
+        signal.removeEventListener("abort", abortSetup);
         return {
-            admission: { fence },
+            admission: { fence: sessionId },
             events,
             completion,
             abort: async () => {
                 abortController.abort();
-                void session.interrupt({ sessionID: sessionId }, { throwOnError: true }).catch(() => undefined);
+                void session.abort({ path: { id: sessionId }, query: { directory: input.cwd }, throwOnError: true }).catch(() => undefined);
                 await finish({ kind: "failed", diagnostic: "OpenCode session interrupted" });
             },
         };
     }
     catch (error) {
-        try {
-            await closeOnce();
-        }
-        catch (cleanupError) {
-            throw new Error(`OpenCode setup failed: ${diagnostic(error)}; cleanup failed: ${diagnostic(cleanupError)}`);
-        }
+        signal.removeEventListener("abort", abortSetup);
+        stopIterator(iterator);
+        await closeOnce();
         throw error;
     }
 }
-function objectData(value) { return value !== null && typeof value === "object" ? value : undefined; }
-function textData(value) { return typeof value === "string" && value.trim().length > 0 ? value : undefined; }
-function admittedFence(sessionId, response) {
-    const outer = objectData(response);
-    const envelope = objectData(outer?.data);
-    const admission = objectData(envelope?.data) ?? envelope;
-    const id = textData(admission?.id);
-    const sequence = typeof admission?.admittedSeq === "number" && Number.isSafeInteger(admission.admittedSeq)
-        ? admission.admittedSeq : undefined;
-    if (id === undefined && sequence === undefined)
-        throw new Error("OpenCode did not return prompt admission evidence");
-    return `${sessionId}:${sequence ?? id}`;
-}
-async function consumeSession(session, sessionId, iterator, state, events) {
-    const stream = (async () => {
-        for (;;) {
-            const next = await iterator.next();
-            if (next.done)
-                return;
-            mapEvent(eventValue(next.value), events, state);
-        }
-    })();
-    stream.catch(() => undefined);
-    await session.wait({ sessionID: sessionId }, { throwOnError: true });
-    await iterator.return?.();
-    await stream;
-    let after;
-    for (;;) {
-        const history = await session.history({ sessionID: sessionId, limit: 200, ...(after === undefined ? {} : { after }) }, { throwOnError: true });
-        for (const event of history.data.data)
-            mapEvent(event, events, state);
-        const latest = history.data.data.at(-1)?.durable?.seq;
-        if (!history.data.hasMore || latest === undefined || latest === after)
-            return;
-        after = latest;
-    }
-}
 export function createOpencodeProvider(input = { name: OPENCODE_SDK_PROVIDER, kind: "opencode-sdk" }) {
     const execution = "kind" in input ? input : { name: OPENCODE_SDK_PROVIDER, kind: "opencode-sdk" };
     const loader = "loader" in input ? input.loader : undefined;
@@ -176,7 +271,16 @@ export function createOpencodeProvider(input = { name: OPENCODE_SDK_PROVIDER, ki
             catch (error) {
                 return { kind: "refused", diagnostic: diagnostic(error) };
             }
-            return { kind: "admitted", options: Object.freeze({ ...options }) };
+            return {
+                kind: "admitted",
+                options: Object.freeze({ ...options }),
+                ...(options.readonly === undefined ? {} : {
+                    readonly: {
+                        enforcement: "none",
+                        diagnostic: "OpenCode V1 cannot remove task-surface mutation capabilities",
+                    },
+                }),
+            };
         },
         start: (input) => drive(execution, input, loader),
         resume: (input) => drive(execution, input, loader),
@@ -184,12 +288,13 @@ export function createOpencodeProvider(input = { name: OPENCODE_SDK_PROVIDER, ki
             const sessionId = opencodeSessionId(input.session);
             const runtime = await loadOpencode(execution, input.cwd, new AbortController().signal, loader);
             try {
-                const fork = runtime.client.session?.fork;
-                if (fork === undefined)
-                    throw new Error("OpenCode fork is unavailable");
-                const result = objectData(await fork({ sessionID: sessionId, messageID: input.at }));
-                const data = objectData(result?.data);
-                const id = textData(data?.id);
+                const result = await runtime.client.session.fork({
+                    path: { id: sessionId },
+                    query: { directory: input.cwd },
+                    body: { messageID: input.at },
+                });
+                const info = object(object(result)?.data) ?? object(result);
+                const id = text(info?.id);
                 if (id === undefined || id === sessionId)
                     throw new Error("OpenCode fork returned an invalid session id");
                 return { session: coordinate(id) };

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

@@ -1,39 +1,24 @@
-import { type OpencodeClient } from "@opencode-ai/sdk/v2";
-import { type ProviderExecution, type ResumeCoordinate } from "../../heart/index.js";
-export type OpencodeSdkSession = Pick<OpencodeClient["v2"]["session"], "create" | "get" | "prompt" | "events" | "history" | "messages" | "interrupt" | "switchModel" | "wait">;
+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">;
 export type OpencodeSdkLoader = (cwd: string) => Promise<Readonly<{
     client: {
-        v2: {
-            session: OpencodeSdkSession;
-            model?: Pick<OpencodeClient["v2"]["model"], "list">;
-        };
-        session?: {
-            fork(params: {
-                sessionID: string;
-                messageID: string;
-            }): Promise<unknown>;
-        };
+        session: OpencodeSdkSession;
+        event: OpencodeSdkEvent;
     };
     close?: () => Promise<void> | void;
 }>>;
 export declare const OPENCODE_SDK_PROVIDER: "opencode-sdk";
-export declare function parseModel(model: string, effort?: string): Readonly<{
+export declare function parseModel(model: string): Readonly<{
     providerID: string;
-    id: string;
-    variant?: string;
+    modelID: string;
 }>;
 export type OpencodeRuntime = Readonly<{
     client: {
-        v2: {
-            session: OpencodeSdkSession;
-            model?: Pick<OpencodeClient["v2"]["model"], "list">;
-        };
-        session?: {
-            fork(params: {
-                sessionID: string;
-                messageID: string;
-            }): Promise<unknown>;
-        };
+        session: OpencodeSdkSession;
+        event: OpencodeSdkEvent;
     };
     close: () => Promise<void>;
 }>;

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

@@ -1,19 +1,20 @@
 import net from "node:net";
-import { spawnDetachedProcess, putDownProcessTree } from "../../../runtime/proc/run.js";
-import { createOpencodeClient } from "@opencode-ai/sdk/v2";
+import { abortable } from "../../abort.js";
+import { spawnDetachedProcess } from "../../../runtime/proc/run.js";
+import { createOpencodeClient } from "@opencode-ai/sdk";
 export const OPENCODE_SDK_PROVIDER = "opencode-sdk";
-export function parseModel(model, effort) {
+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), id: model.slice(slash + 1), ...(effort === undefined ? {} : { variant: effort }) };
+    return { providerID: model.slice(0, slash), modelID: model.slice(slash + 1) };
 }
 async function waitReady(client, cwd, signal) {
     for (let attempt = 0; attempt < 100; attempt += 1) {
         if (signal.aborted)
             throw new Error("OpenCode startup aborted");
         try {
-            await client.v2.model.list({ location: { directory: cwd } }, { throwOnError: true });
+            await abortable(client.session.list({ query: { directory: cwd }, throwOnError: true }), signal);
             return;
         }
         catch {
@@ -43,10 +44,10 @@ export async function loadOpencode(execution, cwd, signal, loader) {
         return { client: loaded.client, close: async () => { await loaded.close?.(); } };
     }
     const port = await availablePort();
-    const collar = await spawnDetachedProcess({
+    const owned = await spawnDetachedProcess({
         argv: [execution.executable ?? "opencode", "serve", "--hostname", "127.0.0.1", "--port", String(port)],
         cwd,
-        env: { ...process.env, ...(execution.env ?? {}) },
+        env: { ...process.env, ...execution.env },
         log: `${cwd}/.opencode.log`,
     });
     const client = createOpencodeClient({ baseUrl: `http://127.0.0.1:${port}`, directory: cwd });
@@ -54,9 +55,9 @@ export async function loadOpencode(execution, cwd, signal, loader) {
         await waitReady(client, cwd, signal);
     }
     catch (error) {
-        await putDownProcessTree(collar);
+        await owned.terminate();
         throw error;
     }
-    return { client, close: async () => { await putDownProcessTree(collar); } };
+    return { client, close: async () => { await owned.terminate(); } };
 }
 export function coordinate(sessionId) { return { sessionId }; }

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

@@ -42,19 +42,57 @@ function hasTextContent(content) {
         return value?.type === "text" && typeof value.text === "string";
     });
 }
+function positiveLine(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 1 ? value : undefined;
+}
+function optionalText(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+function runCall(name, value) {
+    return name === "bash" && typeof value.command === "string"
+        ? { kind: "run", command: value.command }
+        : undefined;
+}
+function readCall(name, value) {
+    if (name !== "read" || typeof value.path !== "string")
+        return undefined;
+    const offset = positiveLine(value.offset);
+    const limit = positiveLine(value.limit);
+    return {
+        kind: "read",
+        path: value.path,
+        ...(offset === undefined ? {} : { offset }),
+        ...(limit === undefined ? {} : { limit }),
+    };
+}
+function searchCall(name, value) {
+    if (name !== "grep" && name !== "find")
+        return undefined;
+    const query = value.pattern ?? value.query;
+    if (typeof query !== "string")
+        return undefined;
+    const path = optionalText(value.path);
+    const glob = optionalText(value.glob);
+    return {
+        kind: "search",
+        query,
+        scope: name === "find" ? "files" : "content",
+        ...(path === undefined ? {} : { path }),
+        ...(name === "grep" && glob !== undefined ? { glob } : {}),
+    };
+}
+function fileChangeCall(name, value) {
+    if ((name !== "edit" && name !== "write") || typeof value.path !== "string")
+        return undefined;
+    return { kind: "fileChange", changes: [{ op: name === "write" ? "add" : "update", path: value.path }] };
+}
 function toolCall(name, args) {
     const value = record(args) ?? {};
-    if (name === "bash" && typeof value.command === "string")
-        return { kind: "run", command: value.command };
-    if (name === "read" && typeof value.path === "string")
-        return { kind: "read", path: value.path };
-    if ((name === "grep" || name === "find") && typeof (value.pattern ?? value.query) === "string") {
-        return { kind: "search", query: (value.pattern ?? value.query) };
-    }
-    if ((name === "edit" || name === "write") && typeof value.path === "string") {
-        return { kind: "fileChange", changes: [{ op: name === "write" ? "add" : "update", path: value.path }] };
-    }
-    return { kind: "other", display: name };
+    return runCall(name, value)
+        ?? readCall(name, value)
+        ?? searchCall(name, value)
+        ?? fileChangeCall(name, value)
+        ?? { kind: "other", display: name };
 }
 function translateNote(event) {
     if (event.type === "auto_retry_start")

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

@@ -1,5 +1,5 @@
 import { createAgentSession, DefaultResourceLoader, getAgentDir, ModelRuntime, SessionManager, type CreateAgentSessionOptions } from "@earendil-works/pi-coding-agent";
-import type { ProviderExecution } from "../../heart/index.js";
+import type { ProviderExecution } from "../../provider-recipe.js";
 import { type ProviderAdapter } from "../../provider.js";
 export type PiSdk = Readonly<{
     createAgentSession(options?: CreateAgentSessionOptions): ReturnType<typeof createAgentSession>;