@astrosheep/keiyaku 4.0.0 → 4.0.2

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

@@ -0,0 +1,33 @@
+import { type ProviderAdapter, type Session } from "../../provider.js";
+import type { ResumeCoordinate } from "../../heart/index.js";
+import type { ProviderExecution, ProviderOptions } from "../../provider-recipe.js";
+import { type OpencodeSdkLoader } from "./session.js";
+export type OpencodeProviderTestOptions = Readonly<{
+    loader?: OpencodeSdkLoader;
+}>;
+export declare function createOpencodeProvider(input?: ProviderExecution | OpencodeProviderTestOptions): ProviderAdapter;
+export declare const opencodeProvider: Readonly<{
+    confinement(input: Readonly<{
+        cwd: string;
+        options: ProviderOptions;
+    }>): import("../../heart/facts.js").Confinement;
+    admitOptions(options: ProviderOptions): import("../../provider.js").ProviderOptionAdmission;
+    fork?(input: Readonly<{
+        session: ResumeCoordinate;
+        at: string;
+        cwd: string;
+    }>): Promise<Readonly<{
+        session: ResumeCoordinate;
+    }>>;
+    start(input: import("../../provider.js").DriveInput & Readonly<{
+        session: Readonly<{
+            kind: "fresh";
+        }>;
+    }>): Promise<Session>;
+    resume?(input: import("../../provider.js").DriveInput & Readonly<{
+        session: Readonly<{
+            kind: "resume";
+            coordinate: ResumeCoordinate;
+        }>;
+    }>): Promise<Session>;
+}>;

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

@@ -0,0 +1,308 @@
+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 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 coordinateValue.sessionId;
+}
+function admit(options) {
+    if (options.network !== undefined)
+        throw new Error("OpenCode does not support explicit network");
+    if (options.model !== undefined)
+        parseModel(options.model);
+}
+function eventValue(value) {
+    if (typeof value !== "string")
+        return value;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        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 abortController = new AbortController();
+    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.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");
+        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 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: sessionId },
+            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" });
+            },
+        };
+    }
+    catch (error) {
+        signal.removeEventListener("abort", abortSetup);
+        stopIterator(iterator);
+        await closeOnce();
+        throw error;
+    }
+}
+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;
+    return {
+        confinement: ({ cwd }) => ({ kind: "declared", writableRoots: [cwd] }),
+        admitOptions(options) {
+            try {
+                admit(options);
+            }
+            catch (error) {
+                return { kind: "refused", diagnostic: diagnostic(error) };
+            }
+            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),
+        fork: async (input) => {
+            const sessionId = opencodeSessionId(input.session);
+            const runtime = await loadOpencode(execution, input.cwd, new AbortController().signal, loader);
+            try {
+                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) };
+            }
+            finally {
+                await runtime.close();
+            }
+        },
+    };
+}
+export const opencodeProvider = createOpencodeProvider();

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

@@ -0,0 +1,26 @@
+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: {
+        session: OpencodeSdkSession;
+        event: OpencodeSdkEvent;
+    };
+    close?: () => Promise<void> | void;
+}>>;
+export declare const OPENCODE_SDK_PROVIDER: "opencode-sdk";
+export declare function parseModel(model: string): Readonly<{
+    providerID: string;
+    modelID: string;
+}>;
+export type OpencodeRuntime = Readonly<{
+    client: {
+        session: OpencodeSdkSession;
+        event: OpencodeSdkEvent;
+    };
+    close: () => Promise<void>;
+}>;
+export declare function loadOpencode(execution: ProviderExecution, cwd: string, signal: AbortSignal, loader?: OpencodeSdkLoader): Promise<OpencodeRuntime>;
+export declare function coordinate(sessionId: string): ResumeCoordinate;

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

@@ -0,0 +1,63 @@
+import net from "node:net";
+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) {
+    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) };
+}
+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 abortable(client.session.list({ query: { directory: cwd }, throwOnError: true }), signal);
+            return;
+        }
+        catch {
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+    }
+    throw new Error("OpenCode server did not become ready within 10000ms");
+}
+async function availablePort() {
+    return await new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.once("error", reject);
+        server.listen(0, "127.0.0.1", () => {
+            const address = server.address();
+            if (address === null || typeof address === "string") {
+                server.close();
+                reject(new Error("OpenCode port unavailable"));
+                return;
+            }
+            server.close((error) => error === undefined ? resolve(address.port) : reject(error));
+        });
+    });
+}
+export async function loadOpencode(execution, cwd, signal, loader) {
+    if (loader) {
+        const loaded = await loader(cwd);
+        return { client: loaded.client, close: async () => { await loaded.close?.(); } };
+    }
+    const port = await availablePort();
+    const owned = await spawnDetachedProcess({
+        argv: [execution.executable ?? "opencode", "serve", "--hostname", "127.0.0.1", "--port", String(port)],
+        cwd,
+        env: { ...process.env, ...execution.env },
+        log: `${cwd}/.opencode.log`,
+    });
+    const client = createOpencodeClient({ baseUrl: `http://127.0.0.1:${port}`, directory: cwd });
+    try {
+        await waitReady(client, cwd, signal);
+    }
+    catch (error) {
+        await owned.terminate();
+        throw error;
+    }
+    return { client, close: async () => { await owned.terminate(); } };
+}
+export function coordinate(sessionId) { return { sessionId }; }

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

@@ -0,0 +1,33 @@
+import type { AgentSessionEvent } from "@earendil-works/pi-coding-agent";
+import { type AgentEvent, type ToolCall } from "../../provider.js";
+export declare const PI_EVENT_DISPOSITIONS: {
+    readonly agent_end: "drop";
+    readonly agent_settled: "drop";
+    readonly agent_start: "drop";
+    readonly auto_retry_end: "drop";
+    readonly auto_retry_start: "note";
+    readonly compaction_end: "note";
+    readonly compaction_start: "drop";
+    readonly entry_appended: "drop";
+    readonly message_end: "message";
+    readonly message_start: "drop";
+    readonly message_update: "drop";
+    readonly queue_update: "drop";
+    readonly session_info_changed: "drop";
+    readonly thinking_level_changed: "drop";
+    readonly tool_execution_end: "tool-end";
+    readonly tool_execution_start: "tool-start";
+    readonly tool_execution_update: "drop";
+    readonly turn_end: "drop";
+    readonly turn_start: "drop";
+};
+export type PiEventState = {
+    answer: string;
+    assistantSeen: boolean;
+    tools: Map<string, Readonly<{
+        name: string;
+        call: ToolCall;
+    }>>;
+};
+export declare function translatePiEvent(event: AgentSessionEvent, state: PiEventState): readonly AgentEvent[];
+export declare function piTerminalFailure(messages: readonly unknown[]): string | null;

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

@@ -0,0 +1,166 @@
+import { noteEvent, unknownEvent } from "../../provider.js";
+export const PI_EVENT_DISPOSITIONS = {
+    agent_end: "drop",
+    agent_settled: "drop",
+    agent_start: "drop",
+    auto_retry_end: "drop",
+    auto_retry_start: "note",
+    compaction_end: "note",
+    compaction_start: "drop",
+    entry_appended: "drop",
+    message_end: "message",
+    message_start: "drop",
+    message_update: "drop",
+    queue_update: "drop",
+    session_info_changed: "drop",
+    thinking_level_changed: "drop",
+    tool_execution_end: "tool-end",
+    tool_execution_start: "tool-start",
+    tool_execution_update: "drop",
+    turn_end: "drop",
+    turn_start: "drop",
+};
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? 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("");
+}
+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";
+    });
+}
+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) ?? {};
+    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")
+        return [noteEvent(`Retrying request ${event.attempt}/${event.maxAttempts}: ${event.errorMessage}`)];
+    return event.errorMessage === undefined ? [] : [noteEvent(event.errorMessage)];
+}
+function translateToolStart(event, state) {
+    const call = toolCall(event.toolName, event.args);
+    state.tools.set(event.toolCallId, { name: event.toolName, call });
+    return [{ type: "tool", phase: "started", id: event.toolCallId, name: event.toolName, call }];
+}
+function translateToolEnd(event, state) {
+    const started = state.tools.get(event.toolCallId);
+    state.tools.delete(event.toolCallId);
+    const name = started?.name ?? event.toolName;
+    return [{
+            type: "tool", phase: "completed", id: event.toolCallId, name,
+            call: started?.call ?? { kind: "other", display: name },
+            result: { status: event.isError ? "error" : "ok" },
+        }];
+}
+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) {
+            const value = record(block);
+            if (value?.type === "thinking" &&
+                value.redacted !== true &&
+                typeof value.thinking === "string" &&
+                value.thinking.trim().length > 0) {
+                translated.push({ type: "thought", text: value.thinking });
+            }
+        }
+    }
+    const text = textContent(message.content);
+    state.answer = text;
+    if (hasTextContent(message.content)) {
+        translated.push({ type: "assistant", text });
+    }
+    return translated;
+}
+export function translatePiEvent(event, state) {
+    const disposition = PI_EVENT_DISPOSITIONS[event.type];
+    if (disposition === "drop")
+        return [];
+    if (disposition === "note")
+        return translateNote(event);
+    if (disposition === "tool-start")
+        return translateToolStart(event, state);
+    if (disposition === "tool-end")
+        return translateToolEnd(event, state);
+    if (disposition === "message")
+        return translateMessage(event, state);
+    return [unknownEvent(event.type)];
+}
+export function piTerminalFailure(messages) {
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const message = record(messages[index]);
+        if (message?.role !== "assistant")
+            continue;
+        if (message.stopReason !== "error")
+            return null;
+        return typeof message.errorMessage === "string" && message.errorMessage.trim().length > 0
+            ? message.errorMessage : "Pi provider ended with an error";
+    }
+    return null;
+}

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

@@ -0,0 +1,11 @@
+import { createAgentSession, DefaultResourceLoader, getAgentDir, ModelRuntime, SessionManager, type CreateAgentSessionOptions } 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>;
+    DefaultResourceLoader: typeof DefaultResourceLoader;
+    getAgentDir: typeof getAgentDir;
+    ModelRuntime: typeof ModelRuntime;
+    SessionManager: typeof SessionManager;
+}>;
+export declare function createPiProvider(execution?: ProviderExecution, load?: () => Promise<PiSdk>): ProviderAdapter;