@astrosheep/keiyaku 4.0.2 → 4.0.4

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

@@ -1,4 +1,5 @@
 import { noteEvent, unknownEvent, } from "../../provider.js";
+import { diffstatFromUnifiedPatch } from "../unified-patch.js";
 export const CODEX_NOTIFICATION_DISPOSITIONS = {
     "account/login/completed": "drop",
     "account/rateLimits/updated": "drop",
@@ -135,19 +136,6 @@ function fileChangeOp(value) {
         ? record.type
         : undefined;
 }
-function diffstatFromUnifiedPatch(patch) {
-    if (!patch.split("\n").some((line) => /^@@ -\d+(?:,\d+)? \+\d+(?:,\d+)? @@/u.test(line)))
-        return undefined;
-    let added = 0;
-    let removed = 0;
-    for (const line of patch.split("\n")) {
-        if (line.startsWith("+") && !line.startsWith("+++"))
-            added += 1;
-        if (line.startsWith("-") && !line.startsWith("---"))
-            removed += 1;
-    }
-    return { added, removed };
-}
 function itemChanges(item) {
     if (!Array.isArray(item.changes))
         return [];

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

@@ -1,4 +1,5 @@
 import type { ProviderAdapter } from "../../provider.js";
 import type { ProviderExecution } from "../../provider-recipe.js";
-import { type AcpDependencies } from "../acp/core.js";
+import { type AcpDependencies, type AcpToolInterpreter } from "../acp/core.js";
+export declare const interpretGrokTool: AcpToolInterpreter;
 export declare function createGrokBuildProvider(execution: ProviderExecution, dependencies?: AcpDependencies): ProviderAdapter;

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

@@ -1,5 +1,72 @@
-import { startAcpSession } from "../acp/core.js";
+import { startAcpSession, } from "../acp/core.js";
 const INTERJECT_METHOD = "x.ai/interject";
+function nonblank(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+function object(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function nativeName(update) {
+    const wire = update;
+    return nonblank(update.name) ?? nonblank(wire.toolName);
+}
+function readCall(name, input) {
+    if (name !== "read_file" && name !== "hashline_read")
+        return undefined;
+    const sourcePath = nonblank(input.target_file);
+    const capturedPath = name === "read_file" ? nonblank(input.path) : undefined;
+    const path = sourcePath ?? capturedPath;
+    return path === undefined ? undefined : { kind: "read", path };
+}
+function contentSearchCall(name, input) {
+    if (name !== "grep" && name !== "hashline_grep")
+        return undefined;
+    const query = nonblank(input.pattern);
+    if (query === undefined)
+        return undefined;
+    const path = nonblank(input.path);
+    const glob = nonblank(input.glob);
+    return {
+        kind: "search",
+        query,
+        scope: "content",
+        ...(path === undefined ? {} : { path }),
+        ...(glob === undefined ? {} : { glob }),
+    };
+}
+function runCall(name, input) {
+    if (name !== "run_terminal_cmd")
+        return undefined;
+    const command = nonblank(input.command);
+    return command === undefined ? undefined : { kind: "run", command };
+}
+function webSearchCall(name, input) {
+    if (name !== "web_search")
+        return undefined;
+    const query = nonblank(input.query);
+    return query === undefined ? undefined : { kind: "search", query, scope: "web" };
+}
+function fileChangeCall(name, input) {
+    if (name !== "search_replace")
+        return undefined;
+    const path = nonblank(input.file_path);
+    return path === undefined
+        ? undefined
+        : { kind: "fileChange", changes: [{ op: "unspecified", path }] };
+}
+export const interpretGrokTool = (update) => {
+    const name = nativeName(update);
+    const input = object(update.rawInput);
+    if (name === undefined || input === undefined)
+        return undefined;
+    return readCall(name, input)
+        ?? contentSearchCall(name, input)
+        ?? runCall(name, input)
+        ?? webSearchCall(name, input)
+        ?? fileChangeCall(name, input);
+};
 function optionAdmission(options) {
     if (options.network !== undefined) {
         return { kind: "refused", diagnostic: "Grok Build does not support the network option" };
@@ -59,7 +126,10 @@ export function createGrokBuildProvider(execution, dependencies = {}) {
             argv: argv(execution, input.options),
             ...(execution.env === undefined ? {} : { env: execution.env }),
         };
-        return withInterject(await startAcpSession(launch, input, dependencies));
+        return withInterject(await startAcpSession(launch, input, {
+            ...dependencies,
+            interpretTool: interpretGrokTool,
+        }));
     };
     return {
         confinement: () => ({ kind: "unconfined" }),

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

@@ -59,6 +59,61 @@ function diagnostic(value) {
 function positiveLine(value) {
     return typeof value === "number" && Number.isSafeInteger(value) && value >= 1 ? value : undefined;
 }
+function nonnegativeCount(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+}
+function diffstat(value) {
+    if (value === undefined)
+        return undefined;
+    const added = nonnegativeCount(value.additions);
+    const removed = nonnegativeCount(value.deletions);
+    return added === undefined || removed === undefined ? undefined : { added, removed };
+}
+function fileChange(changes) {
+    return changes.length === 0 ? undefined : { kind: "fileChange", changes };
+}
+function change(op, path, stats) {
+    return stats === undefined ? { op, path } : { op, path, diffstat: stats };
+}
+function editCall(input, metadata) {
+    const path = text(input?.filePath);
+    if (path === undefined)
+        return undefined;
+    return fileChange([change("update", path, diffstat(object(metadata?.filediff)))]);
+}
+function writeCall(input, metadata) {
+    const path = text(metadata?.filepath) ?? text(input?.filePath);
+    const op = metadata?.exists === false ? "add"
+        : metadata?.exists === true ? "update" : undefined;
+    return path === undefined || op === undefined ? undefined : fileChange([change(op, path, undefined)]);
+}
+function applyPatchFile(value) {
+    const file = object(value);
+    if (file === undefined)
+        return undefined;
+    const type = file.type;
+    const op = type === "add" ? "add"
+        : type === "delete" ? "delete"
+            : type === "update" || type === "modify" || type === "move"
+                ? "update" : undefined;
+    const path = type === "move" ? text(file.movePath) : text(file.filePath);
+    return op === undefined || path === undefined ? undefined : change(op, path, diffstat(file));
+}
+function applyPatchCall(metadata) {
+    if (!Array.isArray(metadata?.files))
+        return undefined;
+    return fileChange(metadata.files.flatMap((value) => {
+        const next = applyPatchFile(value);
+        return next === undefined ? [] : [next];
+    }));
+}
+function strongerCall(previous, next) {
+    if (next === undefined)
+        return previous;
+    if (previous?.kind === "fileChange" && next.kind !== "fileChange")
+        return previous;
+    return next;
+}
 function runCall(name, value) {
     return name === "bash" || name === "shell"
         ? { kind: "run", command: text(value?.command) ?? name }
@@ -96,8 +151,9 @@ function searchCall(name, value) {
         ...(scope === "content" && glob !== undefined ? { glob } : {}),
     };
 }
-function callFor(name, input) {
+function callFor(name, input, metadata) {
     const value = object(input);
+    const meta = object(metadata);
     const lower = name.toLowerCase();
     if (lower === "bash" || lower === "shell")
         return runCall(lower, value);
@@ -105,6 +161,12 @@ function callFor(name, input) {
         return readCall(lower, value);
     if (lower === "grep" || lower === "glob" || lower === "search")
         return searchCall(lower, value);
+    if (lower === "edit")
+        return editCall(value, meta) ?? { kind: "other", display: name };
+    if (lower === "write")
+        return writeCall(value, meta) ?? { kind: "other", display: name };
+    if (lower === "apply_patch")
+        return applyPatchCall(meta) ?? { kind: "other", display: name };
     return { kind: "other", display: name };
 }
 function belongs(part, state) {
@@ -139,12 +201,12 @@ function mapToolPart(part, events, state) {
     const toolState = object(part.state);
     if (id === undefined || name === undefined || toolState === undefined)
         return;
+    const next = callFor(name, toolState.input, toolState.metadata);
     if ((toolState.status === "pending" || toolState.status === "running")
         && !state.tools.has(id) && !state.completedTools.has(id)) {
-        const call = callFor(name, toolState.input);
-        if (call === undefined)
+        if (next === undefined)
             return;
-        const observed = { name, call };
+        const observed = { name, call: next };
         state.tools.set(id, observed);
         events.emit({ type: "tool", phase: "started", id, ...observed });
         return;
@@ -152,14 +214,17 @@ function mapToolPart(part, events, state) {
     if ((toolState.status !== "completed" && toolState.status !== "error") || state.completedTools.has(id))
         return;
     const started = state.tools.get(id);
-    const call = started?.call ?? callFor(name, toolState.input);
+    const call = strongerCall(started?.call, next);
     if (call === undefined)
         return;
-    const observed = started ?? { name, call };
+    const observed = { name: started?.name ?? name, call };
     if (!state.tools.has(id)) {
         state.tools.set(id, observed);
         events.emit({ type: "tool", phase: "started", id, ...observed });
     }
+    else {
+        state.tools.set(id, observed);
+    }
     state.completedTools.add(id);
     events.emit({
         type: "tool",

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

@@ -1,4 +1,5 @@
 import { noteEvent, unknownEvent } from "../../provider.js";
+import { diffstatFromUnifiedPatch } from "../unified-patch.js";
 export const PI_EVENT_DISPOSITIONS = {
     agent_end: "drop",
     agent_settled: "drop",
@@ -82,9 +83,21 @@ function searchCall(name, value) {
     };
 }
 function fileChangeCall(name, value) {
-    if ((name !== "edit" && name !== "write") || typeof value.path !== "string")
+    if (name !== "edit" || typeof value.path !== "string")
         return undefined;
-    return { kind: "fileChange", changes: [{ op: name === "write" ? "add" : "update", path: value.path }] };
+    return { kind: "fileChange", changes: [{ op: "update", path: value.path }] };
+}
+function refineEditCall(call, result) {
+    if (call.kind !== "fileChange")
+        return call;
+    const details = record(record(result)?.details);
+    if (typeof details?.patch !== "string")
+        return call;
+    const diffstat = diffstatFromUnifiedPatch(details.patch);
+    const change = call.changes[0];
+    if (diffstat === undefined || change === undefined)
+        return call;
+    return { kind: "fileChange", changes: [{ ...change, diffstat }] };
 }
 function toolCall(name, args) {
     const value = record(args) ?? {};
@@ -108,9 +121,10 @@ function translateToolEnd(event, state) {
     const started = state.tools.get(event.toolCallId);
     state.tools.delete(event.toolCallId);
     const name = started?.name ?? event.toolName;
+    const call = started?.call ?? { kind: "other", display: name };
     return [{
             type: "tool", phase: "completed", id: event.toolCallId, name,
-            call: started?.call ?? { kind: "other", display: name },
+            call: event.isError ? call : refineEditCall(call, event.result),
             result: { status: event.isError ? "error" : "ok" },
         }];
 }

package/build/src/akuma/providers/unified-patch.d.ts

@@ -0,0 +1,4 @@
+export declare function diffstatFromUnifiedPatch(patch: string): Readonly<{
+    added: number;
+    removed: number;
+}> | undefined;

package/build/src/akuma/providers/unified-patch.js

@@ -0,0 +1,14 @@
+export function diffstatFromUnifiedPatch(patch) {
+    const lines = patch.split("\n");
+    if (!lines.some((line) => /^@@ -\d+(?:,\d+)? \+\d+(?:,\d+)? @@/u.test(line)))
+        return undefined;
+    let added = 0;
+    let removed = 0;
+    for (const line of lines) {
+        if (line.startsWith("+") && !line.startsWith("+++"))
+            added += 1;
+        if (line.startsWith("-") && !line.startsWith("---"))
+            removed += 1;
+    }
+    return { added, removed };
+}

package/build/src/akuma/publication.d.ts

@@ -1,5 +1,5 @@
 import { type AllocatedAkuma } from "./identity.js";
-export declare const BIRTH_TIMEOUT_MS = 5000;
+export declare const BIRTH_TIMEOUT_MS = 30000;
 export declare function publishAkuma(input: Readonly<{
     worldPath: string;
     archetype: string;

package/build/src/akuma/publication.js

@@ -1,8 +1,8 @@
-import { HeldAkumaLeash, initializeHeart, readHeart, readSoul, } from "./heart/index.js";
+import { HeldAkumaLeash, initializeHeart, readHeart, readSeal, readSoul, } from "./heart/index.js";
 import { allocateAkumaDirectory, } from "./identity.js";
 import { abortableDelay } from "./abort.js";
 const POLL_MS = 25;
-export const BIRTH_TIMEOUT_MS = 5_000;
+export const BIRTH_TIMEOUT_MS = 30_000;
 function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -10,15 +10,38 @@ async function settleTimedOutBirth(paths) {
     const leash = await HeldAkumaLeash.try(paths);
     if (leash === null)
         return null;
-    const result = await leash.sealIfUnborn(paths, { evidence: "call-timeout", at: new Date().toISOString() });
-    if (result === "sealed")
-        throw new Error("Akuma body failed before birth");
-    leash.release();
+    let result;
+    try {
+        result = await leash.sealIfUnborn(paths, {
+            evidence: "call-timeout",
+            at: new Date().toISOString(),
+        });
+    }
+    finally {
+        leash.release();
+    }
+    if (result === "sealed") {
+        const seal = await readSeal(paths);
+        throw new Error(seal?.evidence === "call-timeout" || seal === null
+            ? "Akuma body failed before birth"
+            : seal.evidence);
+    }
     const soul = await readSoul(paths);
     if (soul === null)
         throw new Error("Akuma birth settled without a soul");
     return soul;
 }
+async function observedBirthFailure(paths) {
+    const leash = await HeldAkumaLeash.try(paths);
+    if (leash === null)
+        return null;
+    try {
+        return leash.readSeal()?.evidence ?? null;
+    }
+    finally {
+        leash.release();
+    }
+}
 async function awaitBirth(paths, signal) {
     const deadline = performance.now() + BIRTH_TIMEOUT_MS;
     for (;;) {
@@ -26,6 +49,9 @@ async function awaitBirth(paths, signal) {
         const soul = await readSoul(paths);
         if (soul !== null)
             return soul;
+        const failure = await observedBirthFailure(paths);
+        if (failure !== null)
+            throw new Error(failure);
         if (performance.now() >= deadline) {
             const settled = await settleTimedOutBirth(paths);
             if (settled !== null)
@@ -63,7 +89,10 @@ async function sealLocalFailure(allocated, error) {
         if (leash === null)
             return;
         try {
-            await leash.sealIfUnborn(allocated.paths, { evidence: diagnostic(error), at: new Date().toISOString() });
+            await leash.sealIfUnborn(allocated.paths, {
+                evidence: diagnostic(error),
+                at: new Date().toISOString(),
+            });
         }
         finally {
             leash.release();

package/build/src/akuma/requests.d.ts

@@ -1,12 +1,65 @@
-import { type RequestRecipe, type Soul } from "./heart/index.js";
+import { type KillEvidence, type RequestRecipe, type Soul } from "./heart/index.js";
 import { type AkuId, type AkumaPaths } from "./identity.js";
-type RequestClaim = Readonly<{
+type RequestClaimRecipe = Omit<RequestRecipe, "confinement">;
+type CallRequestClaim = Readonly<{
     id: string;
+    action: "akuma.call";
     world: string;
     archetype: string;
     body: string;
     cwd?: string;
-    recipe: RequestRecipe;
+    recipe: RequestClaimRecipe;
+}>;
+type WaitRequestClaim = Readonly<{
+    id: string;
+    action: "akuma.wait";
+    targets: readonly AkuId[];
+    completion: "any" | "all";
+    timeoutMs?: number;
+}>;
+type TellRequestClaim = Readonly<{
+    id: string;
+    action: "akuma.tell";
+    target: AkuId;
+    body: string;
+}>;
+type KillRequestClaim = Readonly<{
+    id: string;
+    action: "akuma.kill";
+    targets: readonly AkuId[];
+}>;
+type UpstreamRequestFailure = Readonly<{
+    kind: "akuma-not-born";
+    id: AkuId;
+}> | Readonly<{
+    kind: "failed";
+    diagnostic: string;
+}>;
+export type UpstreamRequestOutcome = Readonly<{
+    kind: "returned";
+    result: unknown;
+}> | Readonly<{
+    kind: "failed";
+    failure: UpstreamRequestFailure;
+}>;
+export type UpstreamExecutionPort = Readonly<{
+    wait(input: Omit<WaitRequestClaim, "id" | "action"> & Readonly<{
+        signal: AbortSignal;
+    }>): Promise<unknown>;
+    tell(input: Omit<TellRequestClaim, "id" | "action"> & Readonly<{
+        tellId: string;
+        recordedAt: string;
+        signal: AbortSignal;
+    }>): Promise<unknown>;
+    kill(input: Omit<KillRequestClaim, "id" | "action"> & Readonly<{
+        signal: AbortSignal;
+    }>): Promise<Readonly<{
+        result: unknown;
+        service: readonly Readonly<{
+            id: AkuId;
+            evidence: KillEvidence;
+        }>[];
+    }>>;
 }>;
 export type RequestChildLaunch = Readonly<{
     paths: AkumaPaths;
@@ -20,9 +73,21 @@ export declare class AkumaBodyRequestError extends Error {
     constructor(outcome: "refused" | "voided", diagnostic: string);
 }
 export declare function injectedBodyRequests(): string | null;
-export declare function requestBodyCall(input: RequestClaim & Readonly<{
+export declare function requestBodyCall(input: Omit<CallRequestClaim, "action"> & Readonly<{
     directory: string;
 }>): Promise<AkuId>;
+export declare function requestBodyWait(input: Omit<WaitRequestClaim, "action" | "id"> & Readonly<{
+    directory: string;
+    id?: string;
+}>): Promise<UpstreamRequestOutcome>;
+export declare function requestBodyTell(input: Omit<TellRequestClaim, "action" | "id"> & Readonly<{
+    directory: string;
+    id?: string;
+}>): Promise<UpstreamRequestOutcome>;
+export declare function requestBodyKill(input: Omit<KillRequestClaim, "action" | "id"> & Readonly<{
+    directory: string;
+    id?: string;
+}>): Promise<UpstreamRequestOutcome>;
 export declare class BodyRequestPump {
     private readonly input;
     readonly directory: string;
@@ -38,6 +103,7 @@ export declare class BodyRequestPump {
         bodySequence: number;
         now(): string;
         spawn(launch: RequestChildLaunch): Promise<void>;
+        upstream?: UpstreamExecutionPort;
         signal: AbortSignal;
     }>): Promise<BodyRequestPump>;
     private run;