@astrosheep/keiyaku 1.0.0 → 1.0.2

package/build/agents/providers/pi.js

@@ -3,6 +3,8 @@ import { FlowError } from "../../flow-error.js";
 import { appendDebugLog } from "../../telemetry/debug-log.js";
 import { SUBAGENT_SESSION_VERSION } from "../session.js";
 import { createProjectionDriver } from "../harness/execution-handle.js";
+import { activityCallFromNamedTool, boundActivityExcerpt, diffstatFromUnifiedPatch } from "../harness/activity-values.js";
+import { AGENT_THOUGHT_TEXT_MAX_CHARS } from "../harness/events.js";
 import { createAbortError, emitProviderEvidence, sha256Utf8 } from "../harness/runtime.js";
 import { SubagentFailure, } from "../types.js";
 /** Opaque Pi resume handle: exact session file path (UUID alone is ambiguous). */
@@ -13,6 +15,34 @@ export const piSessionSchema = z.object({
 const PI_PROVIDER = "pi";
 /** Exact model shape: `<provider>/<id>` (single slash separating non-empty sides). */
 const PI_MODEL_PATTERN = /^[^/]+\/[^/]+$/;
+const PI_ACKNOWLEDGED_UNPERSISTED = new Set(["message_update", "queue_update"]);
+const PI_MAPPED = new Set([
+    "agent_start",
+    "agent_end",
+    "turn_start",
+    "turn_end",
+    "message_start",
+    "message_end",
+    "tool_execution_start",
+    "tool_execution_update",
+    "tool_execution_end",
+    "compaction_start",
+    "compaction_end",
+    "session_info_changed",
+    "thinking_level_changed",
+    "auto_retry_start",
+    "auto_retry_end",
+]);
+function piIngressDisposition(type) {
+    if (PI_ACKNOWLEDGED_UNPERSISTED.has(type))
+        return "acknowledged-unpersisted";
+    if (PI_MAPPED.has(type))
+        return "mapped";
+    return "unknown";
+}
+function toPiSdkThinkingLevel(effort) {
+    return effort; // opacity boundary
+}
 let piSdkLoader;
 const importPiSdk = new Function("specifier", "return import(specifier)");
 async function loadPiSdk() {
@@ -39,7 +69,7 @@ export function parsePiModelRef(model) {
     };
 }
 function extractAssistantText(event) {
-    if (event.type === "message_update" || event.type === "message_end") {
+    if (event.type === "message_end") {
         const message = event.message;
         if (message?.role !== "assistant")
             return undefined;
@@ -58,7 +88,9 @@ function extractContentText(content) {
         .map((block) => {
         if (typeof block === "string")
             return block;
-        if (block && typeof block === "object" && "text" in block) {
+        if (block &&
+            typeof block === "object" &&
+            block.type === "text") {
             const candidate = block.text;
             return typeof candidate === "string" ? candidate : "";
         }
@@ -68,15 +100,123 @@ function extractContentText(content) {
         .trim();
     return text || undefined;
 }
+function emitPiThoughts(builder, event, turnOrdinal, messageOrdinal) {
+    if (event.type !== "message_end")
+        return;
+    const message = event.message;
+    if (message?.role !== "assistant" || !Array.isArray(message.content))
+        return;
+    message.content.forEach((block, blockIndex) => {
+        if (!block || typeof block !== "object")
+            return;
+        const record = block;
+        if (record.type !== "thinking" || record.redacted === true)
+            return;
+        if (typeof record.thinking !== "string" || record.thinking.trim().length === 0)
+            return;
+        const truncated = record.thinking.length > AGENT_THOUGHT_TEXT_MAX_CHARS;
+        builder.emit({
+            type: "thought",
+            id: `t${turnOrdinal}:m${messageOrdinal}:b${blockIndex}`,
+            text: record.thinking.slice(0, AGENT_THOUGHT_TEXT_MAX_CHARS),
+            final: true,
+            ...(truncated ? { truncated: true } : {}),
+        });
+    });
+}
+function piRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function piCallFacts(args) {
+    const value = piRecord(args);
+    if (!value)
+        return {};
+    return {
+        ...(typeof value.command === "string" ? { command: value.command } : {}),
+        ...(typeof value.description === "string" ? { description: value.description } : {}),
+        ...(typeof value.path === "string" ? { path: value.path } : {}),
+        ...(typeof value.offset === "number" && Number.isFinite(value.offset) ? { offset: value.offset } : {}),
+        ...(typeof value.limit === "number" && Number.isFinite(value.limit) ? { limit: value.limit } : {}),
+        ...(typeof value.query === "string" ? { query: value.query } : {}),
+    };
+}
+function piResult(value, isError) {
+    const payload = piRecord(value);
+    const content = Array.isArray(payload?.content)
+        ? payload.content.flatMap((entry) => {
+            const block = piRecord(entry);
+            return block?.type === "text" && typeof block.text === "string" ? [block.text] : [];
+        }).join("\n")
+        : undefined;
+    const details = piRecord(payload?.details);
+    const diffstat = typeof details?.patch === "string" ? diffstatFromUnifiedPatch(details.patch) : undefined;
+    return {
+        status: isError ? "error" : "ok",
+        ...(content ? { message: boundActivityExcerpt(content) } : {}),
+        ...(diffstat ? { diffstat } : {}),
+    };
+}
+function piActivityBody(event, calls) {
+    if (event.type !== "tool_execution_start" &&
+        event.type !== "tool_execution_update" &&
+        event.type !== "tool_execution_end") {
+        return undefined;
+    }
+    if (typeof event.toolCallId !== "string" || typeof event.toolName !== "string")
+        return undefined;
+    const phase = event.type === "tool_execution_start"
+        ? "started"
+        : event.type === "tool_execution_update"
+            ? "updated"
+            : "completed";
+    if (event.type === "tool_execution_start") {
+        calls.set(event.toolCallId, activityCallFromNamedTool(event.toolName, piCallFacts(event.args)));
+    }
+    const call = calls.get(event.toolCallId) ?? (event.type === "tool_execution_end"
+        ? { kind: "other", display: event.toolName }
+        : activityCallFromNamedTool(event.toolName, piCallFacts(event.args)));
+    if (event.type === "tool_execution_end")
+        calls.delete(event.toolCallId);
+    return {
+        type: "activity",
+        phase,
+        id: event.toolCallId,
+        tool: event.toolName,
+        call,
+        ...(event.type === "tool_execution_start"
+            ? {}
+            : { result: piResult(event.type === "tool_execution_update" ? event.partialResult : event.result, event.type === "tool_execution_end" && event.isError) }),
+    };
+}
+function piUsageBody(event) {
+    if (event.type !== "message_end")
+        return undefined;
+    const message = event.message;
+    if (message?.role !== "assistant")
+        return undefined;
+    const usage = message.usage;
+    if (!usage || typeof usage.input !== "number" || typeof usage.output !== "number")
+        return undefined;
+    return {
+        type: "usage",
+        inputTokens: usage.input,
+        outputTokens: usage.output,
+        ...(typeof usage.cacheRead === "number" ? { cachedInputTokens: usage.cacheRead } : {}),
+        ...(typeof usage.cost?.total === "number" ? { costUsd: usage.cost.total } : {}),
+        ...(typeof message.responseModel === "string"
+            ? { model: message.responseModel }
+            : typeof message.model === "string"
+                ? { model: message.model }
+                : {}),
+    };
+}
 /** True when native messages prove the run stopped via abort (stopReason aborted). */
 function agentEndLooksAborted(event) {
-    if (event.aborted === true)
-        return true;
-    if (event.stopReason === "aborted")
-        return true;
-    const messages = event.messages;
-    if (!Array.isArray(messages))
+    if (event.type !== "agent_end")
         return false;
+    const messages = event.messages;
     for (let i = messages.length - 1; i >= 0; i -= 1) {
         const message = messages[i];
         if (!message || message.role !== "assistant")
@@ -88,6 +228,24 @@ function agentEndLooksAborted(event) {
     }
     return false;
 }
+/** Returns the terminal Pi provider error, if the final assistant message ended in error. */
+function agentEndProviderError(event) {
+    if (event.type !== "agent_end")
+        return undefined;
+    const messages = event.messages;
+    for (let i = messages.length - 1; i >= 0; i -= 1) {
+        const message = messages[i];
+        if (!message || message.role !== "assistant")
+            continue;
+        if (message.stopReason !== "error")
+            return undefined;
+        if (typeof message.errorMessage === "string" && message.errorMessage.trim()) {
+            return message.errorMessage;
+        }
+        return `${PI_PROVIDER} provider error (stopReason error)`;
+    }
+    return undefined;
+}
 function normalizeClearQueue(result) {
     if (Array.isArray(result))
         return result;
@@ -112,39 +270,83 @@ function buildPiSessionOutcome(session, finalMessage) {
 }
 function bindPiSessionEvents(session, builder, options, steerControl, state, setTurnOrdinal, settle) {
     return session.subscribe((event) => {
-        builder.emit({ type: "output", value: event });
-        const assistantText = extractAssistantText(event);
-        if (assistantText) {
-            state.lastAssistantMessage = assistantText;
-            builder.emit({ type: "message", text: assistantText });
-        }
-        if (event.type === "turn_end" && !state.abortIntent) {
-            state.turnOrdinal += 1;
-            setTurnOrdinal(state.turnOrdinal);
-            const checkpoint = { fence: { kind: "ordinal", ordinal: state.turnOrdinal } };
-            // Evidence identifies the native turn_end before the synchronous pump can
-            // consume tells at this checkpoint.
-            if (options.onEvidence) {
-                emitProviderEvidence(options.onEvidence, { type: "checkpoint", provider: PI_PROVIDER, ...checkpoint, source: "notification" }, (text) => builder.emit({ type: "diagnostic", text }));
+        builder.ingress(PI_PROVIDER, event.type, event, piIngressDisposition(event.type), () => {
+            if (event.type === "agent_start") {
+                builder.emit({ type: "turn", phase: "started" });
             }
-            // Sync checkpoint window: claim/steer must run before returning from turn_end.
-            options.onSyncCheckpoint?.(steerControl, checkpoint);
-        }
-        if (event.type !== "agent_end" || state.settled) {
-            return;
-        }
-        if (state.abortIntent || agentEndLooksAborted(event)) {
-            settle.reject(createAbortError(`${PI_PROVIDER} exec cancelled by client`));
-            return;
-        }
-        const outcome = buildPiSessionOutcome(session, state.lastAssistantMessage);
-        if (outcome instanceof SubagentFailure) {
-            builder.emit({ type: "fail", message: outcome.message });
-            settle.reject(outcome);
-            return;
-        }
-        builder.emit({ type: "done", finalMessage: outcome.finalMessage, session: outcome.session });
-        settle.resolve(outcome);
+            if (event.type === "turn_start") {
+                state.thoughtTurnOrdinal += 1;
+                state.assistantMessageOrdinal = -1;
+                state.activeAssistantMessageOrdinal = undefined;
+            }
+            if (event.type === "message_start") {
+                const message = event.message;
+                if (message?.role === "assistant") {
+                    state.assistantMessageOrdinal += 1;
+                    state.activeAssistantMessageOrdinal = state.assistantMessageOrdinal;
+                }
+            }
+            const activity = piActivityBody(event, state.activityCalls);
+            if (activity)
+                builder.emit(activity);
+            if (event.type === "message_end") {
+                const message = event.message;
+                if (message?.role === "assistant") {
+                    if (state.activeAssistantMessageOrdinal === undefined) {
+                        state.assistantMessageOrdinal += 1;
+                        state.activeAssistantMessageOrdinal = state.assistantMessageOrdinal;
+                    }
+                    emitPiThoughts(builder, event, state.thoughtTurnOrdinal, state.activeAssistantMessageOrdinal);
+                    state.activeAssistantMessageOrdinal = undefined;
+                }
+            }
+            const assistantText = extractAssistantText(event);
+            if (assistantText) {
+                state.lastAssistantMessage = assistantText;
+                builder.emit({ type: "message", text: assistantText });
+            }
+            const usage = piUsageBody(event);
+            if (usage)
+                builder.emit(usage);
+            if (event.type === "turn_end" && !state.abortIntent) {
+                state.turnOrdinal += 1;
+                setTurnOrdinal(state.turnOrdinal);
+                const checkpoint = { fence: { kind: "ordinal", ordinal: state.turnOrdinal } };
+                // Evidence identifies the native turn_end before the synchronous pump can
+                // consume tells at this checkpoint.
+                if (options.onEvidence) {
+                    emitProviderEvidence(options.onEvidence, { type: "checkpoint", provider: PI_PROVIDER, ...checkpoint, source: "notification" }, (text) => builder.emit({ type: "diagnostic", text }));
+                }
+                // Sync checkpoint window: claim/steer must run before returning from turn_end.
+                options.onSyncCheckpoint?.(steerControl, checkpoint);
+            }
+            if (event.type !== "agent_end" || state.settled) {
+                return;
+            }
+            if (state.abortIntent || agentEndLooksAborted(event)) {
+                settle.reject(createAbortError(`${PI_PROVIDER} exec cancelled by client`));
+                return;
+            }
+            if (event.willRetry) {
+                return;
+            }
+            const providerError = agentEndProviderError(event);
+            if (providerError) {
+                const failure = new SubagentFailure("SUBAGENT_EXEC_ERROR", providerError);
+                builder.emit({ type: "fail", message: failure.message });
+                settle.reject(failure);
+                return;
+            }
+            const outcome = buildPiSessionOutcome(session, state.lastAssistantMessage);
+            if (outcome instanceof SubagentFailure) {
+                builder.emit({ type: "fail", message: outcome.message });
+                settle.reject(outcome);
+                return;
+            }
+            builder.emit({ type: "turn", phase: "completed" });
+            builder.emit({ type: "done", finalMessage: outcome.finalMessage, session: outcome.session });
+            settle.resolve(outcome);
+        });
     });
 }
 export async function startPi(prompt, cwd, options = {}) {
@@ -201,7 +403,7 @@ export async function startPi(prompt, cwd, options = {}) {
     const created = await sdk.createAgentSession({
         cwd,
         sessionManager,
-        ...(options.thinkingLevel ? { thinkingLevel: options.thinkingLevel } : {}),
+        ...(options.thinkingLevel ? { thinkingLevel: toPiSdkThinkingLevel(options.thinkingLevel) } : {}),
         ...(model ? { model, authStorage, modelRegistry } : {}),
         ...(resourceLoader ? { resourceLoader } : {}),
     });
@@ -210,6 +412,7 @@ export async function startPi(prompt, cwd, options = {}) {
         emitProviderEvidence(options.onEvidence, { type: "session", provider: PI_PROVIDER, sessionId: session.sessionId, ...(session.sessionFile ? { sessionFile: session.sessionFile } : {}) }, reportEvidenceDiagnostic);
     session.setSteeringMode("one-at-a-time");
     let submittedAtTurn = 0;
+    let emitTurnStarted;
     const enqueue = async (tell) => {
         // Acceptance into volatile queue only. text is core-rendered; send byte-for-byte.
         if (options.onEvidence)
@@ -217,9 +420,10 @@ export async function startPi(prompt, cwd, options = {}) {
         if (tell.effort) {
             if (!session.setThinkingLevel)
                 throw new Error(`${PI_PROVIDER} session does not support thinking level control`);
-            session.setThinkingLevel(tell.effort === "max" ? "xhigh" : tell.effort);
+            session.setThinkingLevel(toPiSdkThinkingLevel(tell.effort));
         }
         await session.steer(tell.text);
+        emitTurnStarted?.();
         if (options.onEvidence)
             emitProviderEvidence(options.onEvidence, { type: "ack", provider: PI_PROVIDER, fence: { kind: "ordinal", ordinal: submittedAtTurn }, outbound: "steer" }, reportEvidenceDiagnostic);
         return { fence: { kind: "ordinal", ordinal: submittedAtTurn } };
@@ -247,6 +451,8 @@ export async function startPi(prompt, cwd, options = {}) {
             return;
         }
         abortRequested = (async () => {
+            // Publish abortRequested before clearQueue can synchronously emit queue_update.
+            await Promise.resolve();
             try {
                 session.clearQueue();
                 await session.abort();
@@ -261,12 +467,15 @@ export async function startPi(prompt, cwd, options = {}) {
     };
     return createProjectionDriver({
         steerMode: "mid-execution",
+        initialTurn: options.initialTurn,
         enqueue,
+        onIngress: options.onIngress,
         async abort() {
             await requestAbort({ abortIntent: true, settled: false });
         },
         async run(builder) {
             reportEvidenceDiagnostic = () => builder.emit({ type: "diagnostic", text: "provider evidence callback failed" });
+            emitTurnStarted = () => builder.emit({ type: "turn", phase: "started" });
             while (pendingEvidenceDiagnostics > 0) {
                 pendingEvidenceDiagnostics -= 1;
                 reportEvidenceDiagnostic();
@@ -276,6 +485,9 @@ export async function startPi(prompt, cwd, options = {}) {
                 lastAssistantMessage: "",
                 settled: false,
                 turnOrdinal: 0,
+                thoughtTurnOrdinal: 0,
+                assistantMessageOrdinal: -1,
+                activityCalls: new Map(),
             };
             let settleOutcome;
             const outcome = new Promise((resolve, reject) => {

package/build/agents/selector_v2.js

@@ -0,0 +1,122 @@
+import { getConfig } from "../config/env.js";
+import { loadAkumaCatalogV2, } from "../config/akuma-loader_v2.js";
+import { assertSettingsKnobUsable, loadKeiyakuSettings, resolveDefaultAgentName, } from "../config/settings.js";
+import { FlowError } from "../flow-error.js";
+const ACCESS_VALUES = ["read", "write", "auto"];
+const NETWORK_VALUES = ["disabled", "enabled"];
+const SUPPORTED_EXPLICIT = {
+    "codex-sdk": {
+        access: new Set(ACCESS_VALUES),
+        network: new Set(NETWORK_VALUES),
+        webSearch: new Set(["disabled"]),
+    },
+    "codex-app-server": {
+        access: new Set(["write"]),
+        network: new Set(NETWORK_VALUES),
+        webSearch: new Set(),
+    },
+    "claude-agent-sdk": {
+        access: new Set(ACCESS_VALUES),
+        network: new Set(),
+        webSearch: new Set(["disabled"]),
+    },
+    "opencode-sdk": {
+        access: new Set(),
+        network: new Set(),
+        webSearch: new Set(),
+    },
+    pi: {
+        access: new Set(),
+        network: new Set(),
+        webSearch: new Set(),
+    },
+};
+export function formatAvailableAgentNamesV2(names) {
+    if (names.length === 0)
+        return "(none configured)";
+    return [...names].sort().join(", ");
+}
+/**
+ * Reject the first present portable-policy axis that the adapter kind does not
+ * support. Omitted axes are always legal and are never filled with defaults.
+ */
+export function assertPortablePolicySupported(adapter, policy) {
+    const supported = SUPPORTED_EXPLICIT[adapter];
+    const checks = [
+        ["access", policy.access],
+        ["network", policy.network],
+        ["webSearch", policy.webSearch],
+    ];
+    for (const [knob, value] of checks) {
+        if (value === undefined)
+            continue;
+        const allowed = supported[knob];
+        if (!allowed.has(value)) {
+            throw new FlowError("UNSUPPORTED_POLICY", `Provider kind '${adapter}' does not support ${knob} '${value}'.`);
+        }
+    }
+}
+function isValidAkumaCandidate(candidate) {
+    return !("reason" in candidate && candidate.reason !== undefined) && candidate.profile !== undefined && candidate.body !== undefined;
+}
+function freezeResolvedProfile(profile) {
+    if (profile.effortOptions === undefined) {
+        return Object.freeze({ ...profile });
+    }
+    return Object.freeze({
+        ...profile,
+        effortOptions: Object.freeze([...profile.effortOptions]),
+    });
+}
+export async function selectSubagentV2(agentName, cwd) {
+    const loaded = await loadKeiyakuSettings(cwd);
+    assertSettingsKnobUsable(loaded, "agents");
+    const settings = loaded.knobs;
+    const requested = agentName?.trim();
+    if (!requested && !getConfig().subagent.nameOverride) {
+        assertSettingsKnobUsable(loaded, "default");
+    }
+    const selected = requested || getConfig().subagent.nameOverride || resolveDefaultAgentName(settings);
+    const catalog = await loadAkumaCatalogV2(cwd);
+    const availableNames = Object.keys(catalog.selected);
+    const candidate = catalog.selected[selected];
+    if (candidate === undefined) {
+        throw new FlowError("UNKNOWN_SUBAGENT", `Unknown agent '${selected}'. Expected one of: ${formatAvailableAgentNamesV2(availableNames)}`);
+    }
+    if (!isValidAkumaCandidate(candidate)) {
+        throw new FlowError("INVALID_SETTINGS", `Akuma '${selected}' is invalid: ${candidate.reason}`);
+    }
+    const instanceName = candidate.profile.provider;
+    const providerCandidate = loaded.providerInstances.selected[instanceName];
+    if (providerCandidate === undefined) {
+        throw new FlowError("INVALID_SETTINGS", `Akuma '${selected}' references missing provider instance '${instanceName}'.`);
+    }
+    if (!("instance" in providerCandidate) || providerCandidate.instance === undefined) {
+        throw new FlowError("INVALID_SETTINGS", `Akuma '${selected}' references invalid provider instance '${instanceName}': ${providerCandidate.reason}`);
+    }
+    const providerInstance = providerCandidate.instance;
+    const adapter = providerInstance.kind;
+    assertPortablePolicySupported(adapter, {
+        ...(candidate.profile.access !== undefined ? { access: candidate.profile.access } : {}),
+        ...(candidate.profile.network !== undefined ? { network: candidate.profile.network } : {}),
+        ...(candidate.profile.webSearch !== undefined ? { webSearch: candidate.profile.webSearch } : {}),
+    });
+    const profile = freezeResolvedProfile({
+        provider: instanceName,
+        adapter,
+        providerSource: providerCandidate.source,
+        providerInstance,
+        ...(candidate.profile.description !== undefined ? { description: candidate.profile.description } : {}),
+        ...(candidate.profile.model !== undefined ? { model: candidate.profile.model } : {}),
+        ...(candidate.profile.effort !== undefined ? { effort: candidate.profile.effort } : {}),
+        ...(candidate.profile.effortOptions !== undefined ? { effortOptions: candidate.profile.effortOptions } : {}),
+        ...(candidate.profile.access !== undefined ? { access: candidate.profile.access } : {}),
+        ...(candidate.profile.network !== undefined ? { network: candidate.profile.network } : {}),
+        ...(candidate.profile.webSearch !== undefined ? { webSearch: candidate.profile.webSearch } : {}),
+    });
+    return Object.freeze({
+        name: selected,
+        definition: candidate,
+        profile,
+    });
+}