larkin 0.3.3 → 0.4.1

package/dist/runtime/runtime-host.mjs

@@ -2,6 +2,7 @@ import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import { agentCliPromptCapabilities } from "../agent/agent-cli-capabilities.mjs";
+import { isCanonicalInboxTarget, targetKeyOfInboxEnvelope } from "../agent/inbox-projection.mjs";
 import { SpanKind } from "@opentelemetry/api";
 import { classifyRuntimePrerequisite, providerAuthenticationFailureReadiness, RuntimePrerequisiteError, } from "./runtime-readiness.mjs";
 import { resolveOfficialLarkCli } from "../app/official-lark-cli.mjs";
@@ -19,6 +20,20 @@ export class RuntimeSessionResetError extends Error {
 const MAX_DELIVERIES = 2048;
 const now = () => new Date().toISOString();
 const isActiveDelivery = (status) => ["pending", "submitting", "accepted"].includes(status);
+const REPLAY_FAILURE_CODES = new Set([
+    "canonical_inbox_row_missing", "canonical_inbox_malformed", "duplicate_message_id",
+    "inbox_state_conflict", "delivery_target_conflict", "structured_target_invalid",
+    "structured_target_missing", "wake_reason_conflict",
+]);
+function replayFailureReason(code) {
+    return `Runtime delivery quarantined (${code}): no safe canonical Inbox target is available; the Inbox/ledger remain durable for operator recovery`;
+}
+function replayFailureCodeOf(record) {
+    if (record.status !== "error" || typeof record.reason !== "string")
+        return null;
+    const code = /^Runtime delivery quarantined \(([^)]+)\):/.exec(record.reason)?.[1];
+    return code && REPLAY_FAILURE_CODES.has(code) ? code : null;
+}
 function deliveryFile(agent) {
     return agent.config.stateDir ? path.join(agent.config.stateDir, "runtime-deliveries.json") : null;
 }
@@ -151,6 +166,81 @@ export function createRuntimeHost(options) {
         emitConsumed(agent, persist(agent));
         return agent.records.get(record.deliveryId) ?? record;
     };
+    const scrubQuarantinedInput = (record, reason) => {
+        const staleInput = record.input && typeof record.input === "object" ? record.input : null;
+        record.input = {
+            inputId: typeof staleInput?.inputId === "string" && staleInput.inputId ? staleInput.inputId : record.deliveryId,
+            deliveryId: record.deliveryId,
+            kind: "wake",
+            text: reason,
+            attempt: Number.isSafeInteger(staleInput?.attempt) && Number(staleInput?.attempt) >= 0 ? Number(staleInput.attempt) : 0,
+        };
+    };
+    /** Rebuild every submitted notice from canonical structured state, never persisted text. */
+    const prepareRecordInput = (agent, record, busy) => {
+        if (record.target !== undefined && (typeof record.target !== "string" || !isCanonicalInboxTarget(record.target))) {
+            return { status: "error", code: "structured_target_invalid", reason: replayFailureReason("structured_target_invalid") };
+        }
+        if (record.wakeReason !== undefined && typeof record.wakeReason !== "string") {
+            return { status: "error", code: "wake_reason_conflict", reason: replayFailureReason("wake_reason_conflict") };
+        }
+        let target = typeof record.target === "string" ? record.target : null;
+        let wakeReason = typeof record.wakeReason === "string" ? record.wakeReason : undefined;
+        if (agent.stateStore?.resolveInboxDeliverySource) {
+            let source;
+            try {
+                source = agent.stateStore.resolveInboxDeliverySource(record.messageId);
+            }
+            catch {
+                source = { status: "invalid", code: "canonical_inbox_malformed" };
+            }
+            if (source.status === "consumed")
+                return { status: "consumed" };
+            if (source.status === "missing" || source.status === "invalid") {
+                return { status: "error", code: source.code, reason: replayFailureReason(source.code) };
+            }
+            if (target && target !== source.target) {
+                return { status: "error", code: "delivery_target_conflict", reason: replayFailureReason("delivery_target_conflict") };
+            }
+            const canonicalWakeReason = typeof source.envelope.wake_reason === "string" ? source.envelope.wake_reason : undefined;
+            if (record.wakeReason !== undefined && wakeReason !== canonicalWakeReason) {
+                return { status: "error", code: "wake_reason_conflict", reason: replayFailureReason("wake_reason_conflict") };
+            }
+            target = source.target;
+            wakeReason = canonicalWakeReason;
+        }
+        if (!target)
+            return { status: "error", code: "structured_target_missing", reason: replayFailureReason("structured_target_missing") };
+        const staleInput = record.input && typeof record.input === "object" ? record.input : null;
+        const attempt = Number.isSafeInteger(staleInput?.attempt) && Number(staleInput?.attempt) >= 0 ? Number(staleInput.attempt) : 0;
+        const inputId = typeof staleInput?.inputId === "string" && staleInput.inputId ? staleInput.inputId : record.deliveryId;
+        record.target = target;
+        if (wakeReason)
+            record.wakeReason = wakeReason;
+        else
+            delete record.wakeReason;
+        record.input = {
+            inputId,
+            deliveryId: record.deliveryId,
+            kind: busy ? "inbox_update" : "wake",
+            text: options.promptBuilder.buildInboxNotice({ busy, count: 1, deliveryId: record.deliveryId, target,
+                ...(wakeReason ? { wakeReason } : {}) }),
+            attempt,
+        };
+        return { status: "ready", target };
+    };
+    const quarantineRecord = (agent, record, code) => {
+        const reason = replayFailureReason(code);
+        scrubQuarantinedInput(record, reason);
+        record.reason = reason;
+        record.retryable = false;
+        const finalRecord = setRecord(agent, record, "error");
+        if (finalRecord.status === "consumed")
+            return { status: "accepted", deliveryId: record.deliveryId };
+        emit({ type: "delivery", agentId: agent.config.agentId, deliveryId: record.deliveryId,
+            messageId: record.messageId, status: "error", reason });
+        return { status: "error", deliveryId: record.deliveryId, reason, retryable: false };
+    };
     const reconcileExternalConsumption = (agent) => {
         if (agent.stateStore) {
             agent.stateStore.withInboxTransaction(() => reconcileFile(agent, agent.stateStore.readJson("runtimeDeliveries", { version: 1, records: [] })));
@@ -307,6 +397,20 @@ export function createRuntimeHost(options) {
         if (!busy)
             agent.busy = true; // Reserve the turn before prompt() can yield.
         try {
+            const prepared = prepareRecordInput(agent, record, busy);
+            if (prepared.status === "consumed") {
+                if (!busy)
+                    agent.busy = false;
+                const consumedRecord = setRecord(agent, record, "consumed");
+                emit({ type: "delivery", agentId: agent.config.agentId, deliveryId: consumedRecord.deliveryId,
+                    messageId: consumedRecord.messageId, status: "consumed" });
+                return { status: "accepted", deliveryId: record.deliveryId };
+            }
+            if (prepared.status === "error") {
+                if (!busy)
+                    agent.busy = false;
+                return quarantineRecord(agent, record, prepared.code);
+            }
             const session = await ensureSession(agent);
             const submittingRecord = setRecord(agent, record, "submitting");
             if (submittingRecord.status === "consumed") {
@@ -799,7 +903,14 @@ export function createRuntimeHost(options) {
                         const deliveryFile = stateStore.readJson("runtimeDeliveries", { version: 1, records: [] });
                         if (!stateStore.readNdjson)
                             return deliveryFile;
-                        const inboxIds = new Set(stateStore.readNdjson("inbox").flatMap((row) => typeof row?.message_id === "string" ? [row.message_id] : []));
+                        let inboxRows;
+                        try {
+                            inboxRows = stateStore.readNdjson("inbox");
+                        }
+                        catch {
+                            return deliveryFile;
+                        }
+                        const inboxIds = new Set(inboxRows.flatMap((row) => typeof row?.message_id === "string" ? [row.message_id] : []));
                         let changed = false;
                         const records = deliveryFile.records.map((record) => {
                             const synthetic = /^(?:redeliver_|rem_|interaction_)/.test(record.messageId);
@@ -822,11 +933,34 @@ export function createRuntimeHost(options) {
                     stabilityTimer: null, recreateReason: null, stopped: false, disabledReason: null,
                     configurationRecovery: null, stateStore, readiness: null,
                     turnInProgress: false, turnHadFailure: false, turnHadAuthenticatedOutput: false, authFailureActive: false };
-                for (const record of agent.records.values())
-                    if (isActiveDelivery(record.status))
-                        record.status = "pending";
-                emitConsumed(agent, persist(agent));
+                const startupConsumed = [];
+                const startupQuarantined = [];
+                for (const record of agent.records.values()) {
+                    const existingQuarantine = replayFailureCodeOf(record);
+                    if (existingQuarantine) {
+                        startupQuarantined.push({ record, code: existingQuarantine });
+                        continue;
+                    }
+                    if (!isActiveDelivery(record.status))
+                        continue;
+                    record.status = "pending";
+                    const prepared = prepareRecordInput(agent, record, false);
+                    if (prepared.status === "consumed") {
+                        record.status = "consumed";
+                        record.updatedAt = now();
+                        startupConsumed.push(record);
+                    }
+                    else if (prepared.status === "error") {
+                        record.status = "error";
+                        record.updatedAt = now();
+                        scrubQuarantinedInput(record, prepared.reason);
+                        record.reason = prepared.reason;
+                        record.retryable = false;
+                        startupQuarantined.push({ record, code: prepared.code });
+                    }
+                }
                 managed.set(config.agentId, agent);
+                emitConsumed(agent, [...startupConsumed, ...persist(agent)]);
                 try {
                     await ensureSession(agent);
                     activeCount += 1;
@@ -844,6 +978,13 @@ export function createRuntimeHost(options) {
                     emit({ type: "agent-status", agentId: config.agentId, status: "error", error: reason,
                         ...(error instanceof RuntimePrerequisiteError ? { readiness: error.readiness } : {}) });
                 }
+                const visibleQuarantines = startupQuarantined.filter(({ record }) => agent.records.get(record.deliveryId)?.status === "error");
+                for (const { record, code } of visibleQuarantines)
+                    emit({ type: "delivery", agentId: config.agentId,
+                        deliveryId: record.deliveryId, messageId: record.messageId, status: "error", reason: replayFailureReason(code) });
+                if (visibleQuarantines.length)
+                    emit({ type: "agent-status", agentId: config.agentId, status: "error",
+                        error: `${visibleQuarantines.length} Runtime delivery record(s) quarantined; canonical Inbox recovery is required` });
                 agent.poller = setInterval(() => reconcileExternalConsumption(agent), 250);
                 agent.poller.unref?.();
             });
@@ -859,12 +1000,33 @@ export function createRuntimeHost(options) {
                 telemetry?.delivery(agentId, messageId, "error");
                 throw new Error(`unknown runtime Agent: ${agentId}`);
             }
+            let target;
+            try {
+                target = targetKeyOfInboxEnvelope(envelope);
+            }
+            catch (error) {
+                const reason = `Inbox target derivation failed: ${error instanceof Error ? error.message : String(error)}`;
+                const deliveryId = `invalid-target-${crypto.createHash("sha256").update(`${agentId}\0${messageId}`).digest("hex").slice(0, 24)}`;
+                telemetry?.delivery(agentId, messageId, "error");
+                emit({ type: "delivery", agentId, deliveryId, messageId, status: "error", reason });
+                return { status: "error", deliveryId, reason, retryable: false };
+            }
             reconcileExternalConsumption(agent);
             const existingId = agent.byMessage.get(messageId);
             if (existingId) {
                 const existing = agent.records.get(existingId);
                 if (existing?.status === "error") {
-                    existing.input.attempt += 1;
+                    if (existing.target && existing.target !== target)
+                        return quarantineRecord(agent, existing, "delivery_target_conflict");
+                    existing.target = target;
+                    if (typeof envelope.wake_reason === "string" && envelope.wake_reason)
+                        existing.wakeReason = envelope.wake_reason;
+                    else
+                        delete existing.wakeReason;
+                    const priorAttempt = existing.input && Number.isSafeInteger(existing.input.attempt) ? existing.input.attempt : 0;
+                    existing.input = existing.input && typeof existing.input === "object"
+                        ? { ...existing.input, attempt: priorAttempt + 1 }
+                        : { inputId: existing.deliveryId, deliveryId: existing.deliveryId, kind: "wake", text: "", attempt: priorAttempt + 1 };
                     delete existing.reason;
                     delete existing.retryable;
                     setRecord(agent, existing, "pending");
@@ -885,11 +1047,12 @@ export function createRuntimeHost(options) {
             }
             const deliveryId = crypto.randomUUID();
             const busy = agent.busy || agent.submitting;
+            const wakeReason = typeof envelope.wake_reason === "string" ? envelope.wake_reason : undefined;
             const input = { inputId: deliveryId, deliveryId, kind: busy ? "inbox_update" : "wake",
-                text: options.promptBuilder.buildInboxNotice({ busy, count: 1, deliveryId,
-                    ...(typeof envelope.target === "string" ? { target: envelope.target } : {}),
-                    ...(typeof envelope.wake_reason === "string" ? { wakeReason: envelope.wake_reason } : {}) }), attempt: 0 };
-            const record = { deliveryId, messageId, status: "pending", input, updatedAt: now() };
+                text: options.promptBuilder.buildInboxNotice({ busy, count: 1, deliveryId, target,
+                    ...(wakeReason ? { wakeReason } : {}) }), attempt: 0 };
+            const record = { deliveryId, messageId, status: "pending", input, target,
+                ...(wakeReason ? { wakeReason } : {}), updatedAt: now() };
             agent.records.set(deliveryId, record);
             agent.byMessage.set(messageId, deliveryId);
             persist(agent);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "larkin",
-  "version": "0.3.3",
+  "version": "0.4.1",
   "private": false,
   "larkinPackageRole": "npm-published",
   "files": [