@astrosheep/keiyaku 4.0.4 → 4.0.6

package/build/src/akuma/providers/codex-app-server/index.js

@@ -182,6 +182,11 @@ async function startCodex(execution, input) {
         events,
         completion,
         abort: () => abortTurn(server, state, finish),
+        forceDispose: async () => {
+            if (!state.settled)
+                settle({ kind: "failed", diagnostic: "codex app-server force-disposed" });
+            await server.close(true);
+        },
         tell: (tell) => steerTurn(server, state, tell),
     };
 }
@@ -190,7 +195,6 @@ export function createCodexAppServerProvider(input = "codex") {
         ? { name: "codex-app-server", kind: "codex-app-server", executable: input }
         : input;
     return {
-        confinement: ({ cwd }) => ({ kind: "declared", writableRoots: [cwd] }),
         admitOptions(options) {
             return {
                 kind: "admitted",
@@ -203,4 +207,3 @@ export function createCodexAppServerProvider(input = "codex") {
         resume: (input) => startCodex(execution, input),
     };
 }
-export const codexAppServerProvider = createCodexAppServerProvider();

package/build/src/akuma/providers/grok-build/index.js

@@ -10,7 +10,7 @@ function object(value) {
 }
 function nativeName(update) {
     const wire = update;
-    return nonblank(update.name) ?? nonblank(wire.toolName);
+    return nonblank(update.name) ?? nonblank(update.title) ?? nonblank(wire.toolName);
 }
 function readCall(name, input) {
     if (name !== "read_file" && name !== "hashline_read")
@@ -132,7 +132,6 @@ export function createGrokBuildProvider(execution, dependencies = {}) {
         }));
     };
     return {
-        confinement: () => ({ kind: "unconfined" }),
         admitOptions: optionAdmission,
         start: async (input) => await drive(input),
         resume: async (input) => await drive(input),

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

@@ -1,6 +1,7 @@
 import type { ProviderAdapter } from "../provider.js";
 import { type ProviderExecution } from "../provider-recipe.js";
-export declare function resolveProviderExecution(input: unknown): Readonly<{
+export declare function decodeProviderExecution(input: unknown): ProviderExecution;
+export declare function resolveProviderExecution(input: unknown): Promise<Readonly<{
     execution: ProviderExecution;
     adapter: ProviderAdapter;
-}>;
+}>>;

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

@@ -1,50 +1,50 @@
 import { decodeProviderRecipe } from "../provider-recipe.js";
-import { createAcpProvider, decodeAcpConfig } from "./acp/index.js";
-import { claudeProvider, createClaudeProvider } from "./claude/index.js";
-import { createCodexAppServerProvider } from "./codex-app-server/index.js";
-import { createGrokBuildProvider } from "./grok-build/index.js";
-import { createOpencodeProvider } from "./opencode-sdk/index.js";
-import { createPiProvider } from "./pi/index.js";
-const PROVIDERS = {
-    claude: claudeProvider,
-};
-function providerConfig(execution) {
-    const { config, kind } = execution;
-    if (kind === "claude-agent-sdk" && config !== undefined)
-        throw new TypeError("provider execution config is unsupported by claude-agent-sdk");
-    if (kind === "opencode-sdk" && config !== undefined)
-        throw new TypeError("provider execution config is unsupported by opencode-sdk");
-    if (kind === "acp")
-        return decodeAcpConfig(config);
-    return config;
+import { decodeAcpConfig } from "./acp/config.js";
+export function decodeProviderExecution(input) {
+    const decoded = decodeProviderRecipe(input);
+    if ((decoded.kind === "claude-agent-sdk" || decoded.kind === "opencode-sdk") && decoded.config !== undefined) {
+        throw new TypeError(`provider execution config is unsupported by ${decoded.kind}`);
+    }
+    if (decoded.kind === "pi") {
+        if (decoded.executable !== undefined || decoded.config !== undefined) {
+            throw new TypeError("Pi provider does not support executable or config");
+        }
+        if (decoded.env !== undefined && Object.keys(decoded.env).length > 0) {
+            throw new TypeError("env injection not supported for provider pi");
+        }
+    }
+    if (decoded.kind === "grok-build" && decoded.config !== undefined) {
+        throw new TypeError("Grok Build does not support execution config");
+    }
+    const config = decoded.kind === "acp" ? decodeAcpConfig(decoded.config) : decoded.config;
+    return Object.freeze({
+        name: decoded.name,
+        kind: decoded.kind,
+        ...(decoded.executable === undefined ? {} : { executable: decoded.executable }),
+        ...(config === undefined ? {} : { config }),
+        ...(decoded.env === undefined ? {} : { env: decoded.env }),
+    });
 }
-function adapterFor(execution) {
+async function adapterFor(execution) {
     if (execution.kind === "acp")
-        return createAcpProvider(execution);
+        return (await import("./acp/index.js")).createAcpProvider(execution);
     if (execution.kind === "claude-agent-sdk") {
+        const { claudeProvider, createClaudeProvider } = await import("./claude/index.js");
         return execution.executable === undefined && execution.env === undefined
-            ? PROVIDERS.claude
+            ? claudeProvider
             : createClaudeProvider(async () => await import("@anthropic-ai/claude-agent-sdk"), execution);
     }
     if (execution.kind === "codex-app-server")
-        return createCodexAppServerProvider(execution);
+        return (await import("./codex-app-server/index.js")).createCodexAppServerProvider(execution);
     if (execution.kind === "grok-build")
-        return createGrokBuildProvider(execution);
+        return (await import("./grok-build/index.js")).createGrokBuildProvider(execution);
     if (execution.kind === "opencode-sdk")
-        return createOpencodeProvider(execution);
+        return (await import("./opencode-sdk/index.js")).createOpencodeProvider(execution);
     if (execution.kind === "pi")
-        return createPiProvider(execution);
+        return (await import("./pi/index.js")).createPiProvider(execution);
     throw new TypeError(`unknown Akuma provider kind ${execution.kind}`);
 }
-export function resolveProviderExecution(input) {
-    const decoded = decodeProviderRecipe(input);
-    const config = providerConfig(decoded);
-    const execution = Object.freeze({
-        name: decoded.name,
-        kind: decoded.kind,
-        ...(decoded.executable === undefined ? {} : { executable: decoded.executable }),
-        ...(config === undefined ? {} : { config }),
-        ...(decoded.env === undefined ? {} : { env: decoded.env }),
-    });
-    return Object.freeze({ execution, adapter: adapterFor(execution) });
+export async function resolveProviderExecution(input) {
+    const execution = decodeProviderExecution(input);
+    return Object.freeze({ execution, adapter: await adapterFor(execution) });
 }

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

@@ -1,33 +1,7 @@
-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 ProviderAdapter } from "../../provider.js";
+import type { ProviderExecution } 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

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { abortable } from "../../abort.js";
-import { AgentEventChannel } from "../../provider.js";
+import { AKUMA_REQUESTS_ENV, AgentEventChannel, } from "../../provider.js";
 import { createEventState, mapEvent } from "./events.js";
 import { coordinate, loadOpencode, OPENCODE_SDK_PROVIDER, parseModel } from "./session.js";
 function object(value) {
@@ -195,6 +195,11 @@ function terminalSettlement(events, close) {
     });
     return { completion, finish };
 }
+async function forceDisposeOpencode(abortController, close, finish) {
+    abortController.abort();
+    await close();
+    await finish({ kind: "failed", diagnostic: "OpenCode session force-disposed" });
+}
 async function drive(execution, input, loader) {
     admit(input.options);
     const signal = input.signal ?? new AbortController().signal;
@@ -205,7 +210,13 @@ async function drive(execution, input, loader) {
     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());
+    const runtime = await abortable(loadOpencode({
+        ...execution,
+        env: {
+            ...execution.env,
+            ...(input.requests === undefined ? {} : { [AKUMA_REQUESTS_ENV]: input.requests.dir }),
+        },
+    }, input.cwd, abortController.signal, loader), abortController.signal, async (late) => await late.close());
     let closing;
     let iterator;
     const closeOnce = () => {
@@ -250,6 +261,7 @@ async function drive(execution, input, loader) {
                 void session.abort({ path: { id: sessionId }, query: { directory: input.cwd }, throwOnError: true }).catch(() => undefined);
                 await finish({ kind: "failed", diagnostic: "OpenCode session interrupted" });
             },
+            forceDispose: () => forceDisposeOpencode(abortController, closeOnce, finish),
         };
     }
     catch (error) {
@@ -263,7 +275,6 @@ export function createOpencodeProvider(input = { name: OPENCODE_SDK_PROVIDER, ki
     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);
@@ -305,4 +316,3 @@ export function createOpencodeProvider(input = { name: OPENCODE_SDK_PROVIDER, ki
         },
     };
 }
-export const opencodeProvider = createOpencodeProvider();

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

@@ -1,9 +1,9 @@
-import { type OpencodeClient } from "@opencode-ai/sdk";
+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<{
+export type OpencodeSdkLoader = (cwd: string, execution: ProviderExecution) => Promise<Readonly<{
     client: {
         session: OpencodeSdkSession;
         event: OpencodeSdkEvent;

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

@@ -1,7 +1,6 @@
 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("/");
@@ -40,7 +39,7 @@ async function availablePort() {
 }
 export async function loadOpencode(execution, cwd, signal, loader) {
     if (loader) {
-        const loaded = await loader(cwd);
+        const loaded = await loader(cwd, execution);
         return { client: loaded.client, close: async () => { await loaded.close?.(); } };
     }
     const port = await availablePort();
@@ -50,6 +49,7 @@ export async function loadOpencode(execution, cwd, signal, loader) {
         env: { ...process.env, ...execution.env },
         log: `${cwd}/.opencode.log`,
     });
+    const { createOpencodeClient } = await import("@opencode-ai/sdk");
     const client = createOpencodeClient({ baseUrl: `http://127.0.0.1:${port}`, directory: cwd });
     try {
         await waitReady(client, cwd, signal);

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

@@ -1,4 +1,4 @@
-import { createAgentSession, DefaultResourceLoader, getAgentDir, ModelRuntime, SessionManager, type CreateAgentSessionOptions } from "@earendil-works/pi-coding-agent";
+import type { createAgentSession, DefaultResourceLoader, getAgentDir, ModelRuntime, SessionManager, CreateAgentSessionOptions } from "@earendil-works/pi-coding-agent";
 import type { ProviderExecution } from "../../provider-recipe.js";
 import { type ProviderAdapter } from "../../provider.js";
 export type PiSdk = Readonly<{

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

@@ -1,9 +1,8 @@
-import { createAgentSession, DefaultResourceLoader, getAgentDir, ModelRuntime, SessionManager, } from "@earendil-works/pi-coding-agent";
 import { abortable } from "../../abort.js";
-import { AgentEventChannel } from "../../provider.js";
+import { AKUMA_REQUESTS_ENV, AgentEventChannel, } from "../../provider.js";
 import { piTerminalFailure, translatePiEvent } from "./events.js";
 const PI_THINKING_LEVELS = new Set(["minimal", "low", "medium", "high", "xhigh", "max"]);
-const MODEL_PATTERN = /^[^/\s]+\/[^/\s]+$/u;
+const MODEL_PATTERN = /^[^/\s]+\/[^\s]+$/u;
 function diagnostic(error) { return error instanceof Error ? error.message : String(error); }
 function admitPiOptions(options) {
     if (options.network !== undefined)
@@ -41,6 +40,14 @@ async function piCreateOptions(sdk, input) {
         : "sessionFile" in input.session.coordinate
             ? sdk.SessionManager.open(input.session.coordinate.sessionFile)
             : (() => { throw new Error("Pi resume requires sessionFile"); })();
+    const customTools = input.requests === undefined || input.options.readonly === true
+        ? undefined
+        : [(await import("@earendil-works/pi-coding-agent")).createBashToolDefinition(input.cwd, {
+                spawnHook: (context) => ({
+                    ...context,
+                    env: { ...context.env, [AKUMA_REQUESTS_ENV]: input.requests.dir },
+                }),
+            })];
     return {
         cwd: input.cwd,
         sessionManager,
@@ -48,12 +55,19 @@ async function piCreateOptions(sdk, input) {
         ...(resourceLoader === undefined ? {} : { resourceLoader }),
         ...(input.options.effort === undefined ? {} : { thinkingLevel: input.options.effort }),
         ...(input.options.readonly === undefined ? {} : { tools: ["read", "grep", "find", "ls"] }),
+        ...(customTools === undefined ? {} : { customTools }),
     };
 }
 async function createPiSession(sdk, input, signal) {
     const setup = piCreateOptions(sdk, input).then(async (options) => await sdk.createAgentSession(options));
     return await abortable(setup, signal, (created) => created.session.dispose());
 }
+function forceDisposePi(dispose, settle, setAborting) {
+    setAborting();
+    dispose();
+    settle({ kind: "failed", diagnostic: "Pi session force-disposed" });
+    return Promise.resolve();
+}
 async function drivePi(sdk, input, signal) {
     const created = await createPiSession(sdk, input, signal);
     const native = created.session;
@@ -147,6 +161,7 @@ async function drivePi(sdk, input, signal) {
             })();
             return abortRequest;
         },
+        forceDispose: () => forceDisposePi(dispose, settle, () => { aborting = true; }),
     };
 }
 function piSessionFile(coordinate) {
@@ -162,8 +177,17 @@ async function forkPi(sdk, input) {
         throw new Error("Pi fork did not create a distinct child session file");
     return { session: { sessionFile: child } };
 }
-const defaultSdk = { createAgentSession, DefaultResourceLoader, getAgentDir, ModelRuntime, SessionManager };
-export function createPiProvider(execution = { name: "pi", kind: "pi" }, load = async () => defaultSdk) {
+async function loadPiSdk() {
+    const sdk = await import("@earendil-works/pi-coding-agent");
+    return {
+        createAgentSession: sdk.createAgentSession,
+        DefaultResourceLoader: sdk.DefaultResourceLoader,
+        getAgentDir: sdk.getAgentDir,
+        ModelRuntime: sdk.ModelRuntime,
+        SessionManager: sdk.SessionManager,
+    };
+}
+export function createPiProvider(execution = { name: "pi", kind: "pi" }, load = loadPiSdk) {
     if (execution.executable !== undefined || execution.config !== undefined) {
         throw new TypeError("Pi provider does not support executable or config");
     }
@@ -176,7 +200,6 @@ export function createPiProvider(execution = { name: "pi", kind: "pi" }, load =
         return drivePi(await abortable(load(), signal), input, signal);
     };
     return {
-        confinement: ({ cwd }) => ({ kind: "declared", writableRoots: [cwd] }),
         admitOptions: admitPiOptions,
         start: drive,
         resume: async (input) => {

package/build/src/akuma/request-serve.d.ts

@@ -0,0 +1,88 @@
+import { type KillEvidence, type Soul } from "./heart/index.js";
+import { type AkuId, type AkumaPaths } from "./identity.js";
+import { type TaskMutationRequest } from "../task/mutation.js";
+export type RequestChildLaunch = Readonly<{
+    paths: AkumaPaths;
+    seed: Omit<Soul, "createdAt">;
+    initialBody: string;
+}>;
+type UpstreamCall = Readonly<{
+    signal: AbortSignal;
+}>;
+type RequesterCall = UpstreamCall & Readonly<{
+    requester: AkuId;
+}>;
+type ContractCall = RequesterCall & Readonly<{
+    repoRoot: string;
+    contractId: string;
+}>;
+export type UpstreamExecutionPort = Readonly<{
+    wait(input: UpstreamCall & Readonly<{
+        targets: readonly AkuId[];
+        completion: "any" | "all";
+        timeoutMs?: number;
+    }>): Promise<unknown>;
+    tell(input: UpstreamCall & Readonly<{
+        target: AkuId;
+        body: string;
+        tellId: string;
+        recordedAt: string;
+    }>): Promise<unknown>;
+    kill(input: Readonly<{
+        targets: readonly AkuId[];
+        signal: AbortSignal;
+    }>): Promise<Readonly<{
+        result: unknown;
+        service: readonly Readonly<{
+            id: AkuId;
+            evidence: KillEvidence;
+        }>[];
+    }>>;
+    deliver(input: ContractCall & Readonly<{
+        message?: string;
+        includeDirty: boolean;
+        materializeConflict: boolean;
+    }>): Promise<Readonly<{
+        result: unknown;
+        deliveryFactId?: string;
+    }>>;
+    review(input: ContractCall & Readonly<{
+        verdict: "satisfied" | "unsatisfied";
+        summary?: string;
+    }>): Promise<Readonly<{
+        result: unknown;
+        reviewFactId?: string;
+    }>>;
+    task(input: RequesterCall & Readonly<{
+        world: string;
+        request: TaskMutationRequest;
+    }>): Promise<unknown>;
+}>;
+type PumpInput = Readonly<{
+    paths: AkumaPaths;
+    parent: Soul;
+    bodySequence: number;
+    now(): string;
+    spawn(launch: RequestChildLaunch): Promise<void>;
+    upstream?: UpstreamExecutionPort;
+    signal: AbortSignal;
+}>;
+export declare class BodyRequestPump {
+    private readonly input;
+    readonly directory: string;
+    readonly failure: Promise<never>;
+    private readonly closeSignal;
+    private readonly executionSignal;
+    private readonly handled;
+    private readonly running;
+    private readonly cancelBody;
+    private admissionClosed;
+    private constructor();
+    static open(input: PumpInput): Promise<BodyRequestPump>;
+    private run;
+    close(): Promise<void>;
+    stopAdmission(): void;
+}
+export declare function clearBodyRequestTransport(paths: AkumaPaths): Promise<void>;
+export declare function settleBodyRequests(paths: AkumaPaths, parent: Soul, now: () => string, signal?: AbortSignal): Promise<"settled" | "pending">;
+export {};