larkin 0.3.3 → 0.4.2

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,16 +1230,24 @@ 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;
         }
         if (message.type === "session") {
             const record = agentStates.get(agent.agentId);
             if (record && record.state.sessions[message.runtime] !== message.sessionId) {
-                record.state.sessions[message.runtime] = message.sessionId;
+                if (message.sessionId)
+                    record.state.sessions[message.runtime] = message.sessionId;
+                else
+                    delete record.state.sessions[message.runtime];
                 saveAgentState(record);
                 log(`持久化 agent=${agent.name} runtime=${message.runtime} sessionId=${message.sessionId}`);
             }
@@ -1226,7 +1263,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`);
             }
         }
     };
@@ -1357,6 +1395,74 @@ export function createHostShell({ env = process.env, runtimeHost, channelPackage
                     : unavailable ? "reset committed but Runtime/channel readiness is unavailable"
                         : "reset committed but readiness did not converge before timeout" };
         },
+        async recoverSession(agentId, reason, waitReadyMs = 30_000) {
+            const agent = agents.find((candidate) => candidate.agentId === agentId);
+            if (!agent)
+                throw Object.assign(new Error(`未知 Agent: ${agentId}`), { code: "unknown_agent" });
+            if (reason !== "context-overflow")
+                throw Object.assign(new Error("unsupported recovery reason"), { code: "recovery_refused" });
+            if (!runtimeHost.recoverSession)
+                throw Object.assign(new Error("Runtime session recovery 尚未就绪"), { code: "recovery_unavailable" });
+            const connectionState = (status = hostState.readStatus(agent)) => {
+                const connectedAt = Date.parse(String(status.connectedAt || ""));
+                const channelConnected = Number.isFinite(connectedAt) && connectedAt >= Date.parse(daemonStartedAt) - 1000;
+                return { channelConnected, reconnecting: isChannelReconnecting(status) };
+            };
+            const readinessProjection = () => {
+                const status = hostState.readStatus(agent);
+                const turns = status.session && typeof status.session === "object"
+                    ? Math.max(0, Number(status.session.turns) || 0) : 0;
+                const runtimeReady = Boolean(status.runtimeReadiness && typeof status.runtimeReadiness === "object"
+                    && status.runtimeReadiness.state === "ready");
+                const pendingCount = stateStore(agent).withInboxTransaction(() => stateStore(agent).readNdjson("inbox").length);
+                return { turns, runtimeReady, ...connectionState(status), pendingCount };
+            };
+            const initialProjection = readinessProjection();
+            if (!initialProjection.channelConnected)
+                throw Object.assign(new Error(`Agent ${agentId} channel is not connected`), { code: "channel_unavailable", ...initialProjection });
+            if (initialProjection.reconnecting)
+                throw Object.assign(new Error(`Agent ${agentId} channel is reconnecting`), { code: "channel_reconnecting", ...initialProjection });
+            let recovery;
+            try {
+                recovery = await runtimeHost.recoverSession(agentId, reason);
+            }
+            catch (error) {
+                throw Object.assign(error instanceof Error ? error : new Error(String(error)), readinessProjection());
+            }
+            const record = agentStates.get(agentId);
+            try {
+                if (record) {
+                    if (recovery.sessionId)
+                        record.state.sessions[agent.runtime] = recovery.sessionId;
+                    else
+                        delete record.state.sessions[agent.runtime];
+                    record.store.writeJson("agentState", record.state);
+                }
+            }
+            catch (error) {
+                const projection = readinessProjection();
+                return { recoveryCommitted: true, generationChanged: recovery.generationChanged, sessionChanged: recovery.sessionChanged,
+                    ...projection, rearmedCount: recovery.rearmedCount, replayStatus: "pending", remainingPendingCount: projection.pendingCount,
+                    readyForFreshScenario: false, inboundObserved: false, code: "state_persistence_failed",
+                    error: "recovery committed but Agent session state persistence failed" };
+            }
+            const deadline = Date.now() + Math.max(0, waitReadyMs);
+            let projection = readinessProjection();
+            do {
+                projection = readinessProjection();
+                if (projection.turns === 0 && projection.runtimeReady && projection.channelConnected && !projection.reconnecting)
+                    break;
+                if (Date.now() >= deadline)
+                    break;
+                await new Promise((resolve) => setTimeout(resolve, Math.min(25, Math.max(1, deadline - Date.now()))));
+            } while (true);
+            const replayStatus = projection.pendingCount === 0 ? "consumed" : "pending";
+            const ready = projection.turns === 0 && projection.runtimeReady && projection.channelConnected && !projection.reconnecting;
+            return { recoveryCommitted: true, generationChanged: recovery.generationChanged, sessionChanged: recovery.sessionChanged,
+                ...projection, rearmedCount: recovery.rearmedCount, replayStatus, remainingPendingCount: projection.pendingCount,
+                readyForFreshScenario: ready, inboundObserved: false,
+                ...(!ready ? { code: "recovery_timeout", error: "recovery committed but Runtime/channel readiness did not converge before timeout" } : {}) };
+        },
         async start() {
             try {
                 fs.mkdirSync(larkinHome, { recursive: true });