larkin 0.4.1 → 0.4.5

package/dist/runtime/runtime-adapters.mjs

@@ -1,4 +1,4 @@
-import { spawn as nodeSpawn } from "node:child_process";
+import { spawn as nodeSpawn, spawnSync } from "node:child_process";
 import crypto from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
@@ -6,10 +6,14 @@ import { createInterface } from "node:readline";
 import { isPiThinkingLevel } from "./pi-model-catalog.mjs";
 import { PiRpcClient } from "./pi-rpc-client.mjs";
 import { internalCommandSpec } from "../app/internal-command.mjs";
-import { piAgentDirectory } from "./pi-provider-config.mjs";
+import { BUNDLED_PI_VERSION, piAgentDirectory } from "./pi-provider-config.mjs";
+import { recordPiRuntimeArtifactProvenance } from "./pi-artifact-provenance.mjs";
+import { traceProcessBoundary } from "../platform/process-boundary-trace.mjs";
 import { resolvePiSubagentExtensionArg } from "./pi-subagent-injection.mjs";
 import { resolvePiBashTimeoutExtensionArg } from "./pi-bash-timeout-injection.mjs";
 import { classifyRuntimePrerequisite, probeNativeRuntimeReadiness, providerAuthenticationFailureReadiness, RuntimePrerequisiteError, } from "./runtime-readiness.mjs";
+import { buildStrictProviderErrorInput, classifyStrictProviderError, INTERNAL_CONTEXT_WINDOW_PROJECTION_REASON, } from "./provider-error-classifier.mjs";
+import { assertEffectivePiCompactionSettings, assertNoProjectPiCompactionOverride, calculatePiCompactionSettings, parsePiExecutableVersion, prepareOwnedPiDirectory, readOwnedPiSettings, verifyPiCapabilities, writeOwnedPiSettings, } from "./pi-compaction-recovery.mjs";
 class EventSession {
     listeners = new Set();
     subscribe(listener) {
@@ -447,12 +451,15 @@ class PiSession extends EventSession {
     observedSubmitEpochs = new Set();
     observedAcceptedEpochs = new Set();
     observedCompletedEpochs = new Set();
+    observedAgentEndEpochs = new Set();
     firstOutputObserved = false;
     toolCallOpen = false;
+    piPolicyManaged;
     constructor(sdk, distribution) {
         super();
         this.sdk = sdk;
         this.distribution = distribution;
+        this.piPolicyManaged = sdk.policyManaged ?? typeof sdk.validatePolicy === "function";
         const result = sdk.subscribe?.((event) => this.onEvent(event));
         if (typeof result === "function")
             this.unsubscribe = result;
@@ -470,6 +477,25 @@ class PiSession extends EventSession {
     async prompt(input) { return this.enqueue(input, () => this.sdk.prompt(input.text)); }
     async busyInput(input) { return this.enqueue(input, () => this.sdk.steer(input.text)); }
     async cancel(_reason) { await this.sdk.abort(); }
+    async compact(customInstructions) {
+        if (!this.sdk.compact)
+            throw new Error("Pi compact RPC is unavailable");
+        await this.sdk.validatePolicy?.();
+        return this.sdk.compact(customInstructions);
+    }
+    async getContextUsage() {
+        if (!this.sdk.getSessionStats)
+            return null;
+        await this.sdk.validatePolicy?.();
+        const stats = await this.sdk.getSessionStats();
+        const usage = stats?.contextUsage;
+        const tokens = Number(usage?.tokens);
+        const contextWindow = Number(usage?.contextWindow);
+        if (!Number.isFinite(tokens) || tokens < 0 || !Number.isSafeInteger(contextWindow) || contextWindow <= 0) {
+            throw new Error("Pi get_session_stats returned invalid contextUsage");
+        }
+        return { tokens, contextWindow };
+    }
     async close(_reason) { this.unsubscribe?.(); await this.sdk.dispose?.(); }
     async enqueue(input, operation) {
         if (this.ownedInputIds.size === 0)
@@ -481,14 +507,15 @@ class PiSession extends EventSession {
         const ownsRpcObservation = !this.observedSubmitEpochs.has(epoch);
         if (ownsRpcObservation) {
             this.observedSubmitEpochs.add(epoch);
-            this.emit({ type: "runtime-observation", runtime: "pi", distribution: this.distribution, phase: "rpc_submit" });
+            this.emitObservation("rpc_submit");
         }
         try {
-            await operation();
+            const accepted = this.sdk.validatePolicy ? this.sdk.validatePolicy().then(operation) : operation();
+            await accepted;
             this.awaitingAcknowledgement.delete(input.inputId);
             if (ownsRpcObservation && !this.observedAcceptedEpochs.has(epoch)) {
                 this.observedAcceptedEpochs.add(epoch);
-                this.emit({ type: "runtime-observation", runtime: "pi", distribution: this.distribution, phase: "rpc_accepted" });
+                this.emitObservation("rpc_accepted");
             }
             return { status: "accepted", inputId: input.inputId };
         }
@@ -524,19 +551,23 @@ class PiSession extends EventSession {
             this.observedSubmitEpochs.clear();
             this.observedAcceptedEpochs.clear();
             this.observedCompletedEpochs.clear();
+            this.observedAgentEndEpochs.clear();
             this.activeEpoch = null;
             this.settleArmedEpoch = null;
             this.emit({ type: "error", message });
         }
-        else if (event?.type === "compaction_start" && this.awaitingAcknowledgement.size > 0) {
-            this.emit({ type: "runtime-observation", runtime: "pi", distribution: this.distribution, phase: "compaction_start" });
+        else if (event?.type === "compaction_start") {
+            this.emitObservation("compaction_start", event.reason === "manual" || event.reason === "threshold" || event.reason === "overflow" ? { reason: event.reason } : {});
         }
-        else if (event?.type === "compaction_end" && this.awaitingAcknowledgement.size > 0) {
-            this.emit({ type: "runtime-observation", runtime: "pi", distribution: this.distribution, phase: "compaction_end" });
+        else if (event?.type === "compaction_end") {
+            this.emitObservation("compaction_end", {
+                ...(event.reason === "manual" || event.reason === "threshold" || event.reason === "overflow" ? { reason: event.reason } : {}),
+                willRetry: event.willRetry === true, success: event.aborted !== true && event.result !== undefined,
+            });
         }
         else if ((event?.type === "auto_retry_start" || event?.type === "auto_retry_end"
             || String(event?.type || "").startsWith("summarization_retry_")) && this.awaitingAcknowledgement.size > 0) {
-            this.emit({ type: "runtime-observation", runtime: "pi", distribution: this.distribution, phase: "retry_progress" });
+            this.emitObservation("retry_progress");
         }
         else if (event?.type === "turn_start") {
             const epoch = this.oldestOwnedEpoch();
@@ -546,7 +577,7 @@ class PiSession extends EventSession {
             this.settleArmedEpoch = null;
             this.firstOutputObserved = false;
             this.toolCallOpen = false;
-            this.emit({ type: "runtime-observation", runtime: "pi", distribution: this.distribution, phase: "turn_start" });
+            this.emitObservation("turn_start");
             this.emit({ type: "turn-start", ...(Number.isInteger(event.turnIndex) ? { turnId: `pi-${event.turnIndex}` } : {}) });
         }
         else if (event?.type === "agent_end") {
@@ -557,9 +588,17 @@ class PiSession extends EventSession {
                 ? piAssistantProviderError(assistant)
                 : null;
             this.settleArmedEpoch = this.activeEpoch;
+            if (this.activeEpoch !== null && !this.observedAgentEndEpochs.has(this.activeEpoch)) {
+                this.observedAgentEndEpochs.add(this.activeEpoch);
+                this.emitObservation("agent_end", { willRetry: event.willRetry === true });
+            }
+            if (event.willRetry === true && this.finalAssistantError?.upstream.message === "Your input exceeds the context window of this model. Please adjust your input and try again.") {
+                this.emit({ type: "input-error", inputId: this.oldestOwnedInput(), retryable: true, willRetry: true,
+                    message: "Pi owns the context-overflow retry", errorCategory: "context_window" });
+            }
             if (event.willRetry !== true && this.activeEpoch !== null && !this.observedCompletedEpochs.has(this.activeEpoch)) {
                 this.observedCompletedEpochs.add(this.activeEpoch);
-                this.emit({ type: "runtime-observation", runtime: "pi", distribution: this.distribution, phase: "completed" });
+                this.emitObservation("completed");
             }
         }
         else if (event?.type === "agent_settled") {
@@ -576,7 +615,7 @@ class PiSession extends EventSession {
                 this.toolCallOpen = false;
                 this.emit({ type: "runtime-observation", runtime: "pi", distribution: this.distribution, phase: "tool_result" });
             }
-            this.emit({ type: "runtime-observation", runtime: "pi", distribution: this.distribution, phase: "settled" });
+            this.emitObservation("settled");
             const owned = [...this.ownedInputIds].filter((inputId) => this.inputEpochs.get(inputId) === epoch);
             if (error) {
                 const classified = classifyPiProviderError(error);
@@ -605,6 +644,7 @@ class PiSession extends EventSession {
             this.observedSubmitEpochs.delete(epoch);
             this.observedAcceptedEpochs.delete(epoch);
             this.observedCompletedEpochs.delete(epoch);
+            this.observedAgentEndEpochs.delete(epoch);
         }
         else if (event?.type === "tool_execution_start") {
             if (!this.firstOutputObserved) {
@@ -632,6 +672,20 @@ class PiSession extends EventSession {
             this.emit({ type: "activity", activity: kind, text: String(event.assistantMessageEvent.delta) });
         }
     }
+    emitObservation(phase, fields = {}) {
+        const inputId = this.oldestOwnedInput();
+        const observation = { type: "runtime-observation", runtime: "pi",
+            distribution: this.distribution, phase, ...fields };
+        // Correlation is host-internal metadata, not telemetry payload.
+        if (this.sessionId)
+            Object.defineProperty(observation, "sessionId", { value: this.sessionId, enumerable: false });
+        if (inputId)
+            Object.defineProperty(observation, "inputId", { value: inputId, enumerable: false });
+        this.emit(observation);
+    }
+    oldestOwnedInput() {
+        return this.ownedInputIds.values().next().value;
+    }
     oldestOwnedEpoch() {
         for (const inputId of this.ownedInputIds) {
             const epoch = this.inputEpochs.get(inputId);
@@ -675,6 +729,13 @@ export function classifyPiProviderError(error) {
     const errorType = "type" in error ? error.type : undefined;
     const reason = safeProviderText(upstream.message, "Pi provider request failed");
     const signal = new Set([String(upstream.code ?? "").trim().toLowerCase(), String(errorType ?? "").trim().toLowerCase()].filter(Boolean));
+    if (classifyStrictProviderError(buildStrictProviderErrorInput({
+        message: reason, type: errorType, upstream,
+    })) === "context_window")
+        return {
+            category: "context_window", reason: INTERNAL_CONTEXT_WINDOW_PROJECTION_REASON,
+            nextAction: "Start a fresh Runtime session, then replay the retained Inbox deliveries.",
+        };
     if (upstream.status === 402 || [...signal].some((value) => ["payment_required", "billing_hard_limit_reached", "insufficient_balance"].includes(value)))
         return {
             category: "billing", reason, nextAction: "Update the provider billing method or balance, then retry.",
@@ -746,6 +807,28 @@ export function createPiSessionManager(input) {
         throw error;
     }
 }
+async function discoverEffectivePiContextWindow(input, command, commandPrefix, requestedModel, env, spawn, rpcOptions) {
+    const probeArgs = [...commandPrefix, "--mode", "rpc", "--no-session", "--no-extensions",
+        ...(requestedModel ? ["--model", requestedModel] : [])];
+    const probe = spawn(command, probeArgs, {
+        cwd: input.workspaceDir,
+        env,
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    const client = new PiRpcClient(probe, rpcOptions);
+    try {
+        const state = await client.request("get_state");
+        const contextWindow = state.model?.contextWindow;
+        calculatePiCompactionSettings(contextWindow);
+        const model = state.model?.provider && state.model.id ? `${state.model.provider}/${state.model.id}` : null;
+        if (!model)
+            throw new Error("Pi isolated probe did not report an effective model");
+        return { model, contextWindow: contextWindow };
+    }
+    finally {
+        await client.close();
+    }
+}
 function writePrivateAtomic(file, content) {
     try {
         if (fs.lstatSync(file).isSymbolicLink())
@@ -770,11 +853,15 @@ function writePrivateAtomic(file, content) {
 }
 class PiRpcBackend {
     client;
+    policy;
+    policyManaged;
     sessionId;
     model;
     thinkingLevel;
-    constructor(client, state) {
+    constructor(client, state, policy) {
         this.client = client;
+        this.policy = policy;
+        this.policyManaged = Boolean(policy);
         this.sessionId = state.sessionId ?? null;
         if (state.model?.provider && state.model.id)
             this.model = {
@@ -787,6 +874,24 @@ class PiRpcBackend {
     prompt(text) { return this.client.request("prompt", { message: text }); }
     steer(text) { return this.client.request("steer", { message: text }); }
     abort() { return this.client.request("abort"); }
+    compact(customInstructions) { return this.client.requestCompact(customInstructions); }
+    getSessionStats() { return this.client.request("get_session_stats"); }
+    async validatePolicy() {
+        if (!this.policy)
+            return;
+        const state = await this.client.request("get_state");
+        const effectiveModel = state.model?.provider && state.model.id ? `${state.model.provider}/${state.model.id}` : null;
+        if (effectiveModel !== this.policy.model || state.model?.contextWindow !== this.policy.contextWindow) {
+            throw new Error("Pi model or context window changed after startup; compaction policy is no longer safe");
+        }
+        const ownedSettings = readOwnedPiSettings(this.policy.ownedPiDirectory);
+        assertEffectivePiCompactionSettings({ contextWindow: state.model?.contextWindow, compaction: {
+                enabled: state.autoCompactionEnabled,
+                reserveTokens: ownedSettings.compaction?.reserveTokens,
+                keepRecentTokens: ownedSettings.compaction?.keepRecentTokens,
+            } });
+    }
+    getState() { return this.client.request("get_state"); }
     dispose() { return this.client.close(); }
     subscribe(listener) {
         const offEvent = this.client.subscribe(listener);
@@ -809,8 +914,15 @@ export function resolvePiProcessExtensionArgs(input, resolvers = {}) {
         args.push("-e", bashTimeout);
     return args;
 }
-async function createPiRpcBackend(input, dependencies, spawn) {
+async function createPiRpcBackend(input, dependencies, spawn, productionSpawn = true) {
     const stateRoot = input.stateDir ?? path.join(input.workspaceDir, ".larkin");
+    const mergedEnv = { ...globalThis.process.env, ...dependencies.env, ...input.env, NO_COLOR: "1" };
+    assertNoProjectPiCompactionOverride(input.workspaceDir);
+    const ownedPiDirectory = mergedEnv.LARKIN_CONFIG_DIR
+        ? piAgentDirectory(mergedEnv.LARKIN_CONFIG_DIR, input.agentId)
+        : path.join(stateRoot, "pi-agent");
+    prepareOwnedPiDirectory(ownedPiDirectory);
+    traceProcessBoundary(mergedEnv, "pi-rpc:child-env", { configDir: mergedEnv.LARKIN_CONFIG_DIR, agentId: input.agentId, targetDir: ownedPiDirectory, childEnvConfigDir: mergedEnv.LARKIN_CONFIG_DIR || null, childEnvHome: mergedEnv.HOME || null });
     const runtimeDir = path.join(stateRoot, "runtime");
     fs.mkdirSync(runtimeDir, { recursive: true, mode: 0o700 });
     const promptFile = path.join(runtimeDir, "pi-standing-prompt.md");
@@ -824,28 +936,43 @@ async function createPiRpcBackend(input, dependencies, spawn) {
         ...(session.sessionFile ? ["--session", session.sessionFile] : []),
         ...(requestedModel ? ["--model", requestedModel] : []),
         ...(requestedEffort ? ["--thinking", requestedEffort] : [])];
-    const mergedEnv = { ...globalThis.process.env, ...dependencies.env, ...input.env, NO_COLOR: "1" };
     const builtin = mergedEnv.LARKIN_PI_DISTRIBUTION === "builtin";
     const builtinSpec = builtin ? internalCommandSpec("pi-rpc", [], mergedEnv) : null;
     const command = builtinSpec?.command ?? dependencies.piCommand ?? dependencies.env?.LARKIN_PI_COMMAND ?? process.env.LARKIN_PI_COMMAND ?? "pi";
-    const commandArgs = [...(builtinSpec?.args ?? []), ...args];
-    if (builtin) {
-        if (!mergedEnv.LARKIN_CONFIG_DIR)
-            throw new Error("内置 Pi 缺少 LARKIN_CONFIG_DIR");
-        mergedEnv.PI_CODING_AGENT_DIR = piAgentDirectory(mergedEnv.LARKIN_CONFIG_DIR, input.agentId);
+    const commandPrefix = builtinSpec?.args ?? dependencies.piCommandArgs ?? [];
+    const commandArgs = [...commandPrefix, ...args];
+    const reportedVersion = productionSpawn && !builtin
+        ? parsePiExecutableVersion(String(spawnSync(command, [...commandPrefix, "--version"], {
+            cwd: input.workspaceDir, env: mergedEnv, encoding: "utf8", timeout: 5_000,
+        }).stdout || ""))
+        : BUNDLED_PI_VERSION;
+    mergedEnv.PI_CODING_AGENT_DIR = ownedPiDirectory;
+    if (builtin)
         mergedEnv.PI_TELEMETRY = "0";
-    }
-    commandArgs.push(...(dependencies.resolvePiProcessExtensionArgs ?? resolvePiProcessExtensionArgs)({
+    const extensionArgs = (dependencies.resolvePiProcessExtensionArgs ?? resolvePiProcessExtensionArgs)({
         distribution: builtin ? "builtin" : "external",
         piCommand: command,
         env: mergedEnv,
         platform: process.platform,
-    }));
+    });
+    commandArgs.push(...extensionArgs);
+    let probedModel = null;
+    if (productionSpawn) {
+        // Pi reads compaction settings when the process starts. Probe the exact
+        // requested model first, then write the matching 15% reserve before the
+        // real session starts; no prompt, provider request, package, or extension
+        // is loaded by the probe.
+        probedModel = await discoverEffectivePiContextWindow(input, command, commandPrefix, requestedModel, mergedEnv, spawn, dependencies.piRpcClientOptions);
+        writeOwnedPiSettings(ownedPiDirectory, calculatePiCompactionSettings(probedModel.contextWindow));
+    }
+    const artifactEntriesBeforeSpawn = new Set(fs.readdirSync(ownedPiDirectory));
+    const artifactSpawnBoundary = Date.now();
     const child = spawn(command, commandArgs, {
         cwd: input.workspaceDir,
         env: mergedEnv,
         stdio: ["pipe", "pipe", "pipe"],
     });
+    traceProcessBoundary(mergedEnv, "pi-rpc:child-spawned", { configDir: mergedEnv.LARKIN_CONFIG_DIR, agentId: input.agentId, targetDir: ownedPiDirectory, childPid: child.pid ?? null });
     const client = new PiRpcClient(child, dependencies.piRpcClientOptions);
     try {
         const [state, available] = await Promise.all([
@@ -855,6 +982,24 @@ async function createPiRpcBackend(input, dependencies, spawn) {
         if (!available?.models?.length)
             throw new Error("Pi has no authenticated available models. Run the official `pi` login flow or configure provider credentials; Larkin will not create a fallback session.");
         const effectiveModel = state.model?.provider && state.model.id ? `${state.model.provider}/${state.model.id}` : null;
+        if (productionSpawn) {
+            if (!effectiveModel || !probedModel || effectiveModel !== probedModel.model
+                || state.model?.contextWindow !== probedModel.contextWindow) {
+                throw new Error("Pi model or context window changed between the isolated probe and runtime startup");
+            }
+            const ownedSettings = readOwnedPiSettings(ownedPiDirectory);
+            assertEffectivePiCompactionSettings({ contextWindow: state.model?.contextWindow, compaction: {
+                    enabled: state.autoCompactionEnabled,
+                    reserveTokens: ownedSettings.compaction?.reserveTokens,
+                    keepRecentTokens: ownedSettings.compaction?.keepRecentTokens,
+                } });
+            const handshake = state.compactionCapabilities;
+            verifyPiCapabilities({ distribution: builtin ? "builtin" : "external", version: reportedVersion,
+                contextWindow: state.model?.contextWindow, autoCompactionEnabled: state.autoCompactionEnabled,
+                reserveTokens: handshake?.reserveTokens, keepRecentTokens: handshake?.keepRecentTokens,
+                compactRpc: true, events: handshake?.events,
+                trustedProtocol: builtin });
+        }
         // 严格对账（Owner 决策）：模型必须来自 pi 的权威可用列表，不做后缀猜测——
         // 配置的模型与 pi 可用列表不符即报错，并在错误里列出可用模型。
         const availableEntries = (available.models ?? []).map((entry) => ({
@@ -867,7 +1012,10 @@ async function createPiRpcBackend(input, dependencies, spawn) {
         }
         if (requestedEffort && state.thinkingLevel !== requestedEffort)
             throw new Error(`Pi thinking level ${requestedEffort} was not accepted by effective model ${effectiveModel || "unknown"}`);
-        return new PiRpcBackend(client, state);
+        recordPiRuntimeArtifactProvenance(ownedPiDirectory, artifactEntriesBeforeSpawn, artifactSpawnBoundary);
+        return new PiRpcBackend(client, state, productionSpawn ? {
+            model: effectiveModel, contextWindow: state.model?.contextWindow, ownedPiDirectory,
+        } : undefined);
     }
     catch (error) {
         await client.close();
@@ -972,7 +1120,8 @@ export function createNativeRuntimeAdapter(id, dependencies = {}) {
         capabilities: CAPABILITIES[id],
         async probe(input) {
             const readiness = await probeNativeRuntimeReadiness({ runtime: id, agentId: input.agentId, cwd: input.workspaceDir,
-                env: { ...dependencies.env, ...input.env }, command: configuredCommand });
+                env: { ...dependencies.env, ...input.env }, command: configuredCommand,
+                ...(id === "pi" && dependencies.piCommandArgs ? { commandArgs: dependencies.piCommandArgs } : {}) });
             resolvedExecutable = readiness.state === "ready" ? readiness.executable ?? null : null;
             return readiness;
         },
@@ -988,7 +1137,7 @@ export function createNativeRuntimeAdapter(id, dependencies = {}) {
                     ? "builtin" : "external";
                 return new PiSession(await (dependencies.createPiSession
                     ? dependencies.createPiSession(input)
-                    : createPiRpcBackend(input, { ...dependencies, piCommand: resolvedExecutable }, spawn)), distribution);
+                    : createPiRpcBackend(input, { ...dependencies, piCommand: resolvedExecutable }, spawn, productionSpawn)), distribution);
             }
             if (id === "codex") {
                 const codexInput = dependencies.codexModelOverride?.trim()