larkin 0.3.3 → 0.4.1

package/dist/feishu/host-shell.mjs

@@ -160,6 +160,16 @@ export function createHostShell({ env = process.env, runtimeHost, channelPackage
         return store;
     };
     const hostState = new HostStateProjection(stateStore, log);
+    const recordInboundDeliveryFailure = (agent, code) => {
+        const at = new Date().toISOString();
+        const reason = "Inbound Runtime delivery failed non-retryably; durable Inbox/ledger state is retained for recovery.";
+        const nextAction = "Inspect the delivery/status error, correct the Runtime or canonical Inbox state, then restart to replay safely.";
+        hostState.updateStatus(agent, {
+            inboundDeliveryHealth: { state: "error", code, at, reason, nextAction },
+            runtimeReadiness: { runtime: agent.runtime, state: "incompatible", reason, nextAction },
+        });
+        hostState.recordStatusError(agent, `${reason} ${nextAction} code=${code}`);
+    };
     const agentStates = new Map();
     const saveAgentState = (record) => {
         try {
@@ -295,6 +305,7 @@ export function createHostShell({ env = process.env, runtimeHost, channelPackage
             return;
         }
         const telemetryMessageId = String(event.message_id || event.event_id || eventKey);
+        let canonicalInboxDurable = false;
         if (wake)
             telemetry?.beginMessage(agent.agentId, telemetryMessageId);
         if (event.event_id)
@@ -305,58 +316,76 @@ export function createHostShell({ env = process.env, runtimeHost, channelPackage
                     senderIdentity.ensureChatNames(agent, event.chat_id, 3_000),
                     event._sender_is_bot ? Promise.resolve(null) : senderIdentity.ensureSenderSignature(agent, event.sender_id, 3_000),
                 ]);
-                const envelope = envelopeProjector.projectInbound(agent, event, { anchorReply: wake, names, signature });
-                envelope.target = targetKeyOfInboxEnvelope({ ...envelope, chat_id: event.chat_id, thread_id: event.thread_id });
+                const projected = envelopeProjector.projectInbound(agent, event, { anchorReply: wake, names, signature });
+                projected.target = targetKeyOfInboxEnvelope({ ...projected, chat_id: event.chat_id, thread_id: event.thread_id });
                 if (wake)
-                    envelope.wake = true;
-                const inboxEnvelope = projectInboxEnvelope(envelope, {
+                    projected.wake = true;
+                const candidate = projectInboxEnvelope(projected, {
                     chat_id: event.chat_id,
                     thread_id: event.thread_id,
                     ...(event.create_time !== undefined ? { create_time: String(event.create_time) } : {}),
                     sender_id: event.sender_id,
-                    content: String(envelope.content ?? event.content ?? ""),
+                    content: String(projected.content ?? event.content ?? ""),
                 });
+                let append;
                 try {
-                    stateStore(agent).appendNdjson("inbox", inboxEnvelope);
+                    append = stateStore(agent).appendCanonicalInboxOnce(candidate);
                 }
                 catch (error) {
                     throw new Error(`inbox 写失败: ${errorMessage(error)}`);
                 }
-                // An event becomes permanently seen only after its canonical Inbox append
-                // is durable. Failures remain eligible for same-process redelivery.
+                canonicalInboxDurable = true;
+                // An event becomes permanently transport-seen only after the canonical
+                // append/dedupe decision is durable. Agent model-seen state is untouched.
                 if (event.event_id)
                     seenEventIds.add(eventKey);
-                hostState.appendConversation(agent, {
-                    direction: "in", from: envelope.sender_name, senderType: envelope.sender_type,
-                    target: targetFor(event).target, wake, text: event.content, messageId: envelope.message_id,
-                    at: envelope.timestamp || new Date().toISOString(),
-                });
-                return envelope;
+                if (append.status === "duplicate_consumed")
+                    return null;
+                const inboxEnvelope = append.envelope;
+                if (append.status === "appended")
+                    hostState.appendConversation(agent, {
+                        direction: "in", from: inboxEnvelope.sender_name, senderType: inboxEnvelope.sender_type,
+                        target: String(inboxEnvelope.target || targetFor(event).target), wake, text: event.content, messageId: inboxEnvelope.message_id,
+                        at: inboxEnvelope.timestamp || new Date().toISOString(),
+                    });
+                return inboxEnvelope;
             };
-            const envelope = wake && telemetry
+            const inboxEnvelope = wake && telemetry
                 ? await telemetry.phase(telemetryMessageId, "feishu.receive", SpanKind.CONSUMER, receive)
                 : await receive();
-            if (!wake)
+            if (!wake || !inboxEnvelope)
                 return;
-            const receipt = await runtimeHost.deliver(agent.agentId, envelope);
-            if (receipt.status === "accepted" || receipt.status === "duplicate" || receipt.status === "deferred") {
+            const receipt = await runtimeHost.deliver(agent.agentId, inboxEnvelope);
+            if (receipt.status === "error") {
+                recordInboundDeliveryFailure(agent, "non_retryable_receipt");
                 hostState.appendStatusLog(agent, "deliverLog", {
-                    from: envelope.sender_name,
-                    target: targetFor(event).target,
-                    excerpt: safeConversationExcerpt(event.content, 180),
-                    at: new Date().toISOString(),
-                }, 30);
-                if (envelope.sender_type === "human" || envelope.sender_type === "agent")
-                    processingEyes.add(agent, String(envelope.message_id || ""));
-                if (receipt.status === "deferred")
-                    log(`Runtime 暂缓投递，消息保留在 inbox seq=${envelope.seq}: ${receipt.reason}`);
+                    at: new Date().toISOString(), status: "error",
+                    reason: "non-retryable Runtime delivery error; durable recovery state retained",
+                }, 80);
+                return;
             }
+            hostState.appendStatusLog(agent, "deliverLog", {
+                from: inboxEnvelope.sender_name,
+                target: String(inboxEnvelope.target || targetFor(event).target),
+                excerpt: safeConversationExcerpt(event.content, 180),
+                at: new Date().toISOString(),
+            }, 30);
+            if (inboxEnvelope.sender_type === "human" || inboxEnvelope.sender_type === "agent")
+                processingEyes.add(agent, String(inboxEnvelope.message_id || ""));
+            if (receipt.status === "deferred")
+                log(`Runtime 暂缓投递，消息保留在 inbox seq=${inboxEnvelope.seq}: ${receipt.reason}`);
         }
         catch (error) {
             if (wake)
                 telemetry?.delivery(agent.agentId, telemetryMessageId, "error");
-            log(`onFeishuMessage 异常 agent=${agent.name}: ${error instanceof Error ? error.stack || error.message : String(error)}`);
-            hostState.recordStatusError(agent, `onFeishuMessage: ${errorMessage(error)}`);
+            if (canonicalInboxDurable) {
+                log(`onFeishuMessage Runtime delivery failed agent=${agent.name}; canonical Inbox retained`);
+                recordInboundDeliveryFailure(agent, "runtime_delivery_exception");
+            }
+            else {
+                log(`onFeishuMessage 异常 agent=${agent.name}: ${error instanceof Error ? error.stack || error.message : String(error)}`);
+                hostState.recordStatusError(agent, `onFeishuMessage: ${errorMessage(error)}`);
+            }
         }
         finally {
             if (event.event_id)
@@ -1201,9 +1230,14 @@ export function createHostShell({ env = process.env, runtimeHost, channelPackage
             return;
         }
         if (message.type === "delivery") {
+            if (message.status === "error")
+                recordInboundDeliveryFailure(agent, "runtime_delivery_event");
             hostState.appendStatusLog(agent, "deliverLog", {
                 at: new Date().toISOString(), deliveryId: message.deliveryId, messageId: message.messageId,
-                status: message.status, ...(message.reason ? { reason: safeConversationExcerpt(message.reason, 120) } : {}),
+                status: message.status,
+                ...(message.status === "error"
+                    ? { reason: "non-retryable Runtime delivery error; durable recovery state retained" }
+                    : (message.reason ? { reason: safeConversationExcerpt(message.reason, 120) } : {})),
             }, 80);
             return;
         }
@@ -1226,7 +1260,8 @@ export function createHostShell({ env = process.env, runtimeHost, channelPackage
                 hostState.recordStatusError(agent, `auth: ${readiness.reason}; ${readiness.nextAction}`);
             }
             else {
-                hostState.recordStatusError(agent, `${message.event.errorCategory || "provider"}: ${message.event.message}${message.event.nextAction ? `; ${message.event.nextAction}` : ""}`);
+                const category = message.event.errorCategory || "provider";
+                hostState.recordStatusError(agent, `${category}: Runtime input failed ${message.event.retryable ? "retryably" : "non-retryably"}; inspect delivery health and Runtime/provider configuration`);
             }
         }
     };

package/dist/runtime/runtime-host.cjs

@@ -9,6 +9,7 @@ const node_crypto_1 = __importDefault(require("node:crypto"));
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const agent_cli_capabilities_js_1 = require("../agent/agent-cli-capabilities.cjs");
+const inbox_projection_js_1 = require("../agent/inbox-projection.cjs");
 const api_1 = require("@opentelemetry/api");
 const runtime_readiness_js_1 = require("./runtime-readiness.cjs");
 const official_lark_cli_js_1 = require("../app/official-lark-cli.cjs");
@@ -27,6 +28,20 @@ exports.RuntimeSessionResetError = RuntimeSessionResetError;
 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 ? node_path_1.default.join(agent.config.stateDir, "runtime-deliveries.json") : null;
 }
@@ -159,6 +174,81 @@ 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" || !(0, inbox_projection_js_1.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: [] })));
@@ -315,6 +405,20 @@ 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") {
@@ -807,7 +911,14 @@ 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);
@@ -830,11 +941,34 @@ 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;
@@ -852,6 +986,13 @@ function createRuntimeHost(options) {
                     emit({ type: "agent-status", agentId: config.agentId, status: "error", error: reason,
                         ...(error instanceof runtime_readiness_js_1.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?.();
             });
@@ -867,12 +1008,33 @@ function createRuntimeHost(options) {
                 telemetry?.delivery(agentId, messageId, "error");
                 throw new Error(`unknown runtime Agent: ${agentId}`);
             }
+            let target;
+            try {
+                target = (0, inbox_projection_js_1.targetKeyOfInboxEnvelope)(envelope);
+            }
+            catch (error) {
+                const reason = `Inbox target derivation failed: ${error instanceof Error ? error.message : String(error)}`;
+                const deliveryId = `invalid-target-${node_crypto_1.default.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");
@@ -893,11 +1055,12 @@ function createRuntimeHost(options) {
             }
             const deliveryId = node_crypto_1.default.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);