larkin 0.4.29 → 0.5.1

package/dist/runtime/runtime-host.mjs

@@ -6,8 +6,7 @@ import { auditReminderDelivery } from "../agent/reminder-delivery-audit.mjs";
 import { isCanonicalInboxTarget, targetKeyOfInboxEnvelope } from "../agent/inbox-projection.mjs";
 import { SpanKind } from "@opentelemetry/api";
 import { buildStrictProviderErrorInput, classifyStrictProviderError } from "./provider-error-classifier.mjs";
-import { authFailureAppliesTo, classifyPiMissingCredentialRejection, classifyRuntimePrerequisite, configuredProviderId, isBuiltinPiDistribution, missingProviderCredentialReadiness, parsePersistedAuthFailure, providerAuthenticationFailureReadiness, readinessForPersistedAuthFailure, safeProviderId, RuntimePrerequisiteError, } from "./runtime-readiness.mjs";
-import { officialPiHasStoredProvider } from "./pi-official-auth.mjs";
+import { authFailureAppliesTo, classifyPiMissingCredentialRejection, classifyRuntimePrerequisite, configuredProviderId, missingProviderCredentialReadiness, parsePersistedAuthFailure, providerAuthenticationFailureReadiness, readinessForPersistedAuthFailure, safeProviderId, RuntimePrerequisiteError, } from "./runtime-readiness.mjs";
 import { resolveOfficialLarkCli } from "../app/official-lark-cli.mjs";
 import { assertAgentWorkspaceBound, managedLarkCliEnv } from "../app/agent-lark-cli-workspace.mjs";
 import { isPiNativeCompactionRequired, PiCompactionBreaker, PiCompactionRecoveryMachine, } from "./pi-compaction-recovery.mjs";
@@ -94,37 +93,23 @@ function persistPreviousSession(agent, previous) {
         // In-memory ref still holds for this process; restart will miss it only if this write failed.
     }
 }
-function isBuiltinPiAgent(agent) {
-    return agent.adapter.id === "pi"
-        && (isBuiltinPiDistribution(agent.config.piDistribution) || agent.config.runtime === "builtin-pi");
-}
 function authFailureScopeOf(agent) {
     return {
         runtime: agent.config.runtime,
         model: agent.config.model,
-        piDistribution: agent.config.piDistribution,
         adapterId: agent.adapter.id,
     };
 }
 function currentAuthFailure(agent) {
     if (!agent.authFailureActive)
         return null;
-    const kind = agent.authFailureKind
-        ?? (agent.authFailureProvider ? "missing-provider" : "generic");
-    if (kind === "missing-provider") {
-        if (!agent.authFailureProvider)
-            return null;
-        return { kind: "missing-provider", runtime: "pi", piDistribution: "builtin", provider: agent.authFailureProvider };
-    }
     const runtime = agent.adapter.id === "codex" || agent.adapter.id === "claude" || agent.adapter.id === "pi"
         ? agent.adapter.id : null;
     if (!runtime)
         return null;
     return {
-        kind: "generic",
+        kind: agent.authFailureKind === "missing-provider" ? "missing-provider" : "generic",
         runtime,
-        ...(runtime === "pi" && (agent.config.piDistribution === "builtin" || agent.config.piDistribution === "external")
-            ? { piDistribution: agent.config.piDistribution } : {}),
         provider: agent.authFailureProvider,
     };
 }
@@ -335,7 +320,6 @@ export function createRuntimeHost(options) {
             } : {}),
             LARKIN_CONFIG_DIR: process.env.LARKIN_CONFIG_DIR,
             LARKIN_HOME: process.env.LARKIN_HOME,
-            ...(config.piDistribution ? { LARKIN_PI_DISTRIBUTION: config.piDistribution } : {}),
             LARKIN_STATE_DIR: effectivePiStateDir(config),
             ...(process.env.HOME ? { HOME: process.env.HOME } : {}),
             ...(process.env.SHELL ? { SHELL: process.env.SHELL } : {}),
@@ -597,10 +581,6 @@ export function createRuntimeHost(options) {
                 messageId: record.messageId, status: "consumed" });
         }
     };
-    const ownedConfigDir = () => {
-        const value = process.env.LARKIN_CONFIG_DIR?.trim();
-        return value || null;
-    };
     const projectAuthFailure = (agent, readiness, failure) => {
         agent.authFailureActive = true;
         agent.authFailureKind = failure.kind;
@@ -618,12 +598,7 @@ export function createRuntimeHost(options) {
         if (agent.authFailureKind !== "missing-provider" || !agent.authFailureProvider)
             return true;
         const failure = currentAuthFailure(agent);
-        if (!failure || !authFailureAppliesTo(authFailureScopeOf(agent), failure))
-            return false;
-        const configDir = ownedConfigDir();
-        if (!configDir)
-            return false;
-        return officialPiHasStoredProvider(configDir, agent.config.agentId, agent.authFailureProvider);
+        return Boolean(failure && authFailureAppliesTo(authFailureScopeOf(agent), failure));
     };
     const resultFor = (agent, record, result) => {
         if (result.status === "accepted") {
@@ -638,12 +613,12 @@ export function createRuntimeHost(options) {
                     deliveryId: record.deliveryId, messageId: record.messageId, status: "accepted" });
             return { status: "accepted", deliveryId: record.deliveryId };
         }
-        const missing = result.status === "rejected" && isBuiltinPiAgent(agent)
+        const missing = result.status === "rejected" && agent.adapter.id === "pi"
             ? classifyPiMissingCredentialRejection(result.reason)
             : null;
         if (missing) {
             const readiness = missingProviderCredentialReadiness(agent.adapter.id, missing.provider);
-            const reason = readiness.reason ?? `Provider ${missing.provider} is missing from this Agent's official credential store.`;
+            const reason = readiness.reason ?? result.reason;
             if (record.status !== "error") {
                 record.reason = reason;
                 record.retryable = false;
@@ -1620,26 +1595,30 @@ export function createRuntimeHost(options) {
                 record.errorCategory = classifiedCategory;
             else
                 delete record.errorCategory;
-            const missing = event.errorCategory === "auth" && !event.retryable && isBuiltinPiAgent(agent)
+            const missing = agent.adapter.id === "pi"
                 ? classifyPiMissingCredentialRejection(event.upstream?.message)
                     ?? classifyPiMissingCredentialRejection(event.message)
                 : null;
-            if (missing)
+            if (missing) {
+                record.retryable = false;
+                record.errorCategory = "auth";
                 record.authProvider = missing.provider;
-            const finalRecord = setRecord(agent, record, event.retryable ? "pending" : "error");
+            }
+            const terminal = Boolean(missing) || !event.retryable;
+            const finalRecord = setRecord(agent, record, terminal ? "error" : "pending");
             if (finalRecord.status !== "consumed")
                 emit({ type: "delivery", agentId: agent.config.agentId,
                     deliveryId: record.deliveryId, messageId: record.messageId,
-                    status: event.retryable ? "deferred" : "error", reason: event.message });
-            if (event.errorCategory === "auth" && !event.retryable) {
-                const readiness = missing
-                    ? missingProviderCredentialReadiness(agent.adapter.id, missing.provider)
-                    : providerAuthenticationFailureReadiness(agent.adapter.id, event.upstream?.provider);
-                projectAuthFailure(agent, readiness, missing
-                    ? { kind: "missing-provider", provider: missing.provider }
-                    : { kind: "generic", provider: genericAuthProvider(agent, event.upstream) });
-            }
-            if (event.retryable && !agent.busy && !agent.turnInProgress)
+                    status: terminal ? "error" : "deferred", reason: event.message });
+            if (missing) {
+                const readiness = missingProviderCredentialReadiness(agent.adapter.id, missing.provider);
+                projectAuthFailure(agent, readiness, { kind: "missing-provider", provider: missing.provider });
+            }
+            else if (event.errorCategory === "auth" && !event.retryable) {
+                const readiness = providerAuthenticationFailureReadiness(agent.adapter.id, event.upstream?.provider);
+                projectAuthFailure(agent, readiness, { kind: "generic", provider: genericAuthProvider(agent, event.upstream) });
+            }
+            if (!terminal && event.retryable && !agent.busy && !agent.turnInProgress)
                 void retryPending(agent);
         }
         else if (event.type === "configuration-error") {
@@ -1914,7 +1893,6 @@ export function createRuntimeHost(options) {
                         && authFailureAppliesTo({
                             runtime: config.runtime,
                             model: config.model,
-                            piDistribution: config.piDistribution,
                             adapterId: adapter.id,
                         }, previousFailure));
                     const candidate = {

package/dist/runtime/runtime-model-catalog.cjs

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CURRENT_RUNTIME_MODELS = void 0;
-// Authored catalog keys are adapter ids only. builtin-pi is a user-facing sibling, not a stored runtime.
+// Authored catalog keys are adapter ids only.
 // Pi, Codex and Claude replace these placeholders/fallbacks at runtime with their machine-readable catalogs.
 // Claude's supported stdin control-channel list is the live authority; its entries below
 // remain explicit compatibility candidates for config loading and discovery failures.

package/dist/runtime/runtime-model-catalog.mjs

@@ -1,4 +1,4 @@
-// Authored catalog keys are adapter ids only. builtin-pi is a user-facing sibling, not a stored runtime.
+// Authored catalog keys are adapter ids only.
 // Pi, Codex and Claude replace these placeholders/fallbacks at runtime with their machine-readable catalogs.
 // Claude's supported stdin control-channel list is the live authority; its entries below
 // remain explicit compatibility candidates for config loading and discovery failures.

package/dist/runtime/runtime-readiness.cjs

@@ -38,25 +38,22 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RuntimePrerequisiteError = void 0;
 exports.safeProviderId = safeProviderId;
-exports.isBuiltinPiDistribution = isBuiltinPiDistribution;
 exports.configuredProviderId = configuredProviderId;
 exports.parsePersistedAuthFailure = parsePersistedAuthFailure;
 exports.authFailureAppliesTo = authFailureAppliesTo;
 exports.readinessForPersistedAuthFailure = readinessForPersistedAuthFailure;
 exports.classifyPiMissingCredentialRejection = classifyPiMissingCredentialRejection;
+exports.runtimeInstallNextAction = runtimeInstallNextAction;
+exports.runtimeLoginNextAction = runtimeLoginNextAction;
 exports.providerAuthenticationFailureReadiness = providerAuthenticationFailureReadiness;
 exports.missingProviderCredentialReadiness = missingProviderCredentialReadiness;
 exports.resolveRuntimeExecutable = resolveRuntimeExecutable;
 exports.classifyRuntimePrerequisite = classifyRuntimePrerequisite;
 exports.probeNativeRuntimeReadiness = probeNativeRuntimeReadiness;
 const node_fs_1 = __importDefault(require("node:fs"));
-const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const node_child_process_1 = require("node:child_process");
-const root_layout_js_1 = require("../platform/root-layout.cjs");
-const builtin_pi_assets_js_1 = require("./builtin-pi-assets.cjs");
-const pi_provider_config_js_1 = require("./pi-provider-config.cjs");
-const process_boundary_trace_js_1 = require("../platform/process-boundary-trace.cjs");
+const pi_compaction_recovery_js_1 = require("./pi-compaction-recovery.cjs");
 function safeProviderId(value) {
     const provider = typeof value === "string" ? value.trim() : "";
     return /^[A-Za-z0-9][A-Za-z0-9._-]{0,79}$/.test(provider) ? provider : null;
@@ -64,9 +61,6 @@ function safeProviderId(value) {
 function safeProviderLabel(value) {
     return safeProviderId(value);
 }
-function isBuiltinPiDistribution(value) {
-    return value === "builtin";
-}
 /** Model ids are `provider/model`; only the provider prefix is used for scope. */
 function configuredProviderId(model) {
     const value = typeof model === "string" ? model.trim() : "";
@@ -89,53 +83,20 @@ function parsePersistedAuthFailure(state) {
         const provider = safeProviderId(failure.provider);
         if (kind === "missing-provider" && !provider)
             return null;
-        const piDistribution = failure.piDistribution === "builtin" || failure.piDistribution === "external"
-            ? failure.piDistribution : undefined;
-        return {
-            kind,
-            runtime,
-            ...(piDistribution ? { piDistribution } : {}),
-            provider,
-        };
+        return { kind, runtime, provider };
     }
     const legacy = safeProviderId(record.authFailureProvider);
-    return legacy
-        ? { kind: "missing-provider", runtime: "pi", piDistribution: "builtin", provider: legacy }
-        : null;
+    return legacy ? { kind: "missing-provider", runtime: "pi", provider: legacy } : null;
 }
 function currentAdapterId(current) {
-    return current.adapterId ?? (current.runtime === "builtin-pi" ? "pi" : current.runtime);
-}
-function currentIsBuiltinPi(current) {
-    return currentAdapterId(current) === "pi"
-        && (isBuiltinPiDistribution(current.piDistribution) || current.runtime === "builtin-pi");
+    return current.adapterId ?? current.runtime;
 }
-/**
- * Missing-provider and known-provider generic markers apply only to that provider.
- * Generic without a provider is conservative fallback: it still binds runtime /
- * builtin distribution, but cannot reject an A→B model switch because the
- * upstream provider was genuinely unavailable.
- */
 function authFailureAppliesTo(current, failure) {
-    if (failure.kind === "missing-provider") {
-        return currentIsBuiltinPi(current)
-            && failure.runtime === "pi"
-            && failure.piDistribution === "builtin"
-            && Boolean(failure.provider)
-            && configuredProviderId(current.model) === failure.provider;
-    }
     if (failure.runtime !== currentAdapterId(current))
         return false;
-    if (failure.runtime === "pi") {
-        const persistedBuiltin = failure.piDistribution === "builtin";
-        if (currentIsBuiltinPi(current) !== persistedBuiltin)
-            return false;
-    }
     if (!failure.provider)
         return true;
     const currentProvider = configuredProviderId(current.model);
-    if (currentIsBuiltinPi(current))
-        return currentProvider === failure.provider;
     return currentProvider ? currentProvider === failure.provider : true;
 }
 function readinessForPersistedAuthFailure(failure) {
@@ -154,6 +115,20 @@ function classifyPiMissingCredentialRejection(message) {
     const provider = match ? safeProviderLabel(match[2]) : null;
     return provider && match ? { provider, diagnostic: `${match[1]} ${provider}` } : null;
 }
+function runtimeInstallNextAction(runtime) {
+    if (runtime === "pi")
+        return "Install Pi and ensure `pi` is on PATH, or set LARKIN_PI_COMMAND.";
+    if (runtime === "codex")
+        return "Install Codex and ensure `codex` is on PATH, or set LARKIN_CODEX_COMMAND.";
+    return "Install Claude Code and ensure `claude` is on PATH, or set LARKIN_CLAUDE_COMMAND.";
+}
+function runtimeLoginNextAction(runtime) {
+    if (runtime === "pi")
+        return "Log in with the external `pi` CLI, then retry.";
+    if (runtime === "codex")
+        return "Run `codex login`, then retry.";
+    return "Run `claude login`, then retry.";
+}
 function providerAuthenticationFailureReadiness(runtime, provider) {
     const label = safeProviderLabel(provider);
     return {
@@ -162,23 +137,20 @@ function providerAuthenticationFailureReadiness(runtime, provider) {
         reason: label
             ? `Provider ${label} API-key authentication failed during a Runtime turn.`
             : "Configured provider API-key authentication failed during a Runtime turn.",
-        nextAction: "Check the provider login or API-key resolver command, then retry the Agent turn.",
+        nextAction: runtimeLoginNextAction(runtime),
     };
 }
-/** P0 分类；Pi nextAction 共用 UX preset 恢复文案，不写官方 provider ID。 */
 function missingProviderCredentialReadiness(runtime, provider) {
     const label = safeProviderLabel(provider);
     return {
         runtime,
         state: "unauthenticated",
         reason: label
-            ? `Provider ${label} is missing from this Agent's official credential store.`
-            : "The configured provider is missing from this Agent's official credential store.",
-        nextAction: runtime === "pi"
-            ? (0, pi_provider_config_js_1.builtinPiProviderRecoveryNextAction)({ providerId: label ?? undefined })
-            : label
-                ? `Add the missing ${label} credential to this Agent's official store, then retry the Agent turn.`
-                : "Add the missing provider credential to this Agent's official store, then retry the Agent turn.",
+            ? `Provider ${label} is not authenticated for this runtime.`
+            : "The configured provider is not authenticated for this runtime.",
+        nextAction: runtime === "pi" && label
+            ? `Log in with the external \`pi\` CLI for provider ${label}, then retry.`
+            : runtimeLoginNextAction(runtime),
     };
 }
 class RuntimePrerequisiteError extends Error {
@@ -211,27 +183,37 @@ function classifyRuntimePrerequisite(runtime, error, executable) {
     const reason = (error instanceof Error ? error.message : String(error)).replace(/[\r\n]+/g, " ").slice(0, 500);
     if (/ENOENT|not found|no such file|spawn .* failed/i.test(reason))
         return {
-            runtime, state: "missing", ...(executable ? { executable } : {}), reason,
-            nextAction: runtime === "pi" ? "Install Pi and ensure `pi` is on PATH, or set LARKIN_PI_COMMAND." : `Install ${runtime} and ensure it is on PATH.`,
+            runtime, state: "missing", ...(executable ? { executable } : {}),
+            reason: `${runtime} is not installed`,
+            nextAction: runtimeInstallNextAction(runtime),
         };
     if (/no authenticated available models|login|credential|unauthenticated|unauthorized|oauth/i.test(reason))
         return {
             runtime, state: "unauthenticated", ...(executable ? { executable } : {}), reason,
-            // 此分类没有 distribution：外部 Pi 不能指向 Dashboard / pi-auth login。
+            nextAction: runtimeLoginNextAction(runtime),
+        };
+    if (/older than the minimum|not a supported version(?: line)?|version output must contain exactly one/i.test(reason)) {
+        return {
+            runtime, state: "incompatible", ...(executable ? { executable } : {}), reason,
             nextAction: runtime === "pi"
-                ? "Run the official `pi` login flow, then retry."
-                : `Authenticate ${runtime}, then retry.`,
+                ? `Upgrade pi to ${pi_compaction_recovery_js_1.MINIMUM_PI_VERSION} or newer`
+                : `Upgrade ${runtime}, then retry.`,
         };
-    if (/protocol (?:version )?(?:mismatch|unsupported|incompatible)|unsupported (?:rpc|protocol|schema)|schema (?:mismatch|incompatible)|requires (?:a )?newer version/i.test(reason))
+    }
+    if (/protocol (?:version )?(?:mismatch|unsupported|incompatible)|unsupported (?:rpc|protocol|schema)|schema (?:mismatch|incompatible)|requires (?:a )?newer version/i.test(reason)) {
         return {
             runtime, state: "incompatible", ...(executable ? { executable } : {}), reason,
-            nextAction: runtime === "pi" ? "Upgrade local Pi to a version that supports the documented RPC protocol." : `Upgrade ${runtime}, then retry.`,
+            nextAction: runtime === "pi"
+                ? "Upgrade local Pi to a version that supports the documented RPC protocol."
+                : `Upgrade ${runtime}, then retry.`,
         };
-    if (/timeout|timed out|unexpected EOF|\bEOF\b|TLS|ECONNRESET|socket hang up|network|temporar(?:y|ily)|unavailable/i.test(reason))
+    }
+    if (/timeout|timed out|unexpected EOF|\bEOF\b|TLS|ECONNRESET|socket hang up|network|temporar(?:y|ily)|unavailable/i.test(reason)) {
         return {
             runtime, state: "unavailable", ...(executable ? { executable } : {}), reason,
             nextAction: `Retry ${runtime}; Larkin will use its bounded Runtime recreate/backoff policy.`,
         };
+    }
     return {
         runtime, state: "unavailable", ...(executable ? { executable } : {}), reason,
         nextAction: `Retry ${runtime}; the failure is not proven to be a protocol incompatibility.`,
@@ -254,47 +236,30 @@ function executableVersion(executable, env, commandArgs = []) {
 }
 /** Resolve and handshake through each runtime's structured native control protocol. */
 async function probeNativeRuntimeReadiness(options) {
-    let env = { ...process.env, ...options.env };
-    const piDistribution = options.runtime === "pi" ? (0, builtin_pi_assets_js_1.piChildDistributionFromOverrides)(options.env) : "external";
-    if (options.runtime === "pi" && piDistribution !== "builtin") {
-        if (env.LARKIN_PI_DISTRIBUTION === "builtin")
-            delete env.LARKIN_PI_DISTRIBUTION;
-        env = (0, builtin_pi_assets_js_1.applyPiPackageDirForChild)(env, { distribution: "external" });
+    const env = { ...process.env, ...options.env };
+    const command = selectedCommand(options);
+    const executable = resolveRuntimeExecutable(command, env);
+    if (!executable) {
+        return {
+            runtime: options.runtime,
+            state: "missing",
+            reason: `${options.runtime} is not installed`,
+            nextAction: runtimeInstallNextAction(options.runtime),
+        };
     }
-    if (options.runtime === "pi" && piDistribution === "builtin") {
+    let version = executableVersion(executable, env, options.commandArgs);
+    if (options.runtime === "pi") {
         try {
-            if (!options.agentId || !env.LARKIN_CONFIG_DIR)
-                throw new Error("内置 Pi readiness 缺少 Agent/config identity");
-            (0, pi_provider_config_js_1.assertBuiltinPiAgentDirectory)((0, pi_provider_config_js_1.piAgentDirectory)(env.LARKIN_CONFIG_DIR, options.agentId));
-            return { runtime: "pi", state: "ready", executable: process.execPath, version: `official-pi ${pi_provider_config_js_1.BUNDLED_PI_VERSION} (bundled)` };
+            const probe = (0, node_child_process_1.spawnSync)(executable, [...options.commandArgs ?? [], "--version"], {
+                env, encoding: "utf8", timeout: 5_000, maxBuffer: 64 * 1024,
+            });
+            version = (0, pi_compaction_recovery_js_1.parsePiExecutableVersion)(String(probe.stdout || ""));
         }
         catch (error) {
-            (0, process_boundary_trace_js_1.traceProcessBoundary)(env, "readiness:builtin-pi-failure", { configDir: env.LARKIN_CONFIG_DIR, agentId: options.agentId, targetDir: options.agentId && env.LARKIN_CONFIG_DIR ? (0, pi_provider_config_js_1.piAgentDirectory)(env.LARKIN_CONFIG_DIR, options.agentId) : undefined, error });
-            return { runtime: "pi", state: "unauthenticated", reason: error instanceof Error ? error.message : String(error),
-                nextAction: (0, pi_provider_config_js_1.builtinPiProviderRecoveryNextAction)({ agentId: options.agentId }) };
+            const classified = classifyRuntimePrerequisite("pi", error, executable);
+            return { ...classified, executable, ...(version ? { version } : {}) };
         }
     }
-    const command = selectedCommand(options);
-    const executable = resolveRuntimeExecutable(command, env);
-    if (!executable)
-        return {
-            runtime: options.runtime, state: "missing",
-            reason: `${command} executable was not found`,
-            nextAction: options.runtime === "pi"
-                ? "Install Pi and ensure `pi` is on PATH, or set LARKIN_PI_COMMAND."
-                : `Install ${options.runtime} and ensure it is on PATH.`,
-        };
-    const piAgentId = options.agentId;
-    if (options.runtime === "pi" && !piAgentId) {
-        return {
-            runtime: "pi",
-            state: "unavailable",
-            executable,
-            reason: "Pi catalog readiness requires Agent ID",
-            nextAction: "Retry setup or start so Larkin can probe the Agent-owned Pi provider directory.",
-        };
-    }
-    const version = executableVersion(executable, env, options.commandArgs);
     try {
         if (options.runtime === "pi") {
             const { discoverPiModelCatalog } = await Promise.resolve().then(() => __importStar(require("./pi-model-catalog.cjs")));
@@ -303,7 +268,6 @@ async function probeNativeRuntimeReadiness(options) {
                 command: executable,
                 commandArgs: options.commandArgs,
                 env,
-                agentDir: (0, pi_provider_config_js_1.ownedPiCatalogAgentDir)((0, root_layout_js_1.resolveConfigDir)(env, node_os_1.default.homedir()), piAgentId),
             });
         }
         else if (options.runtime === "codex") {