@agent-native/core 0.107.1 → 0.107.2

package/dist/server/agent-chat-plugin.js

@@ -1,7 +1,7 @@
 import crypto from "node:crypto";
 import nodePath from "node:path";
 import { createError, defineEventHandler, setResponseStatus, setResponseHeader, getMethod, getQuery, getHeader, getRequestIP, } from "h3";
-import { buildA2ARecoverableArtifactMessage, } from "../a2a/artifact-response.js";
+import { appendA2AArtifactLinks, buildA2ARecoverableArtifactMessage, } from "../a2a/artifact-response.js";
 import { hasConfiguredA2ASecret, isLoopbackAddress, isTrustedLocalRuntime, } from "../a2a/auth-policy.js";
 import { applyAgentTextEventToBuffer } from "../a2a/response-text.js";
 import { createA2AApproval, updateTaskStatusMessage, } from "../a2a/task-store.js";
@@ -77,6 +77,60 @@ export { shouldBlockInProductCodeEditingSurface };
 export { loadRunCodeToolEntries };
 export { shouldDisableRecurringJobsRuntime };
 export { finalizeClaimedAgentChatProcessRunFailure };
+export function createSerializedA2ATaskStatusWriter(taskId, writeStatus = updateTaskStatusMessage, onError = (error) => {
+    console.error(`[A2A] Failed to persist recoverable artifact message for task ${taskId}:`, error);
+}) {
+    const maxAttempts = 3;
+    let latestWrite = Promise.resolve();
+    const persistWithRetry = async (message) => {
+        let lastError;
+        for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+            try {
+                await writeStatus(taskId, message);
+                return;
+            }
+            catch (error) {
+                lastError = error;
+            }
+        }
+        try {
+            onError(lastError);
+        }
+        catch {
+            // The durable-write error below remains the authoritative failure.
+        }
+        throw lastError;
+    };
+    return {
+        enqueue(message) {
+            // A newer checkpoint supersedes an earlier failed checkpoint, so keep
+            // the queue moving. flush() still rejects when the latest write itself
+            // cannot be made durable after bounded retries.
+            latestWrite = latestWrite
+                .catch(() => undefined)
+                .then(() => {
+                return persistWithRetry(message);
+            });
+        },
+        flush() {
+            return latestWrite;
+        },
+    };
+}
+export async function resolveA2ARecoverableArtifactSecret(orgId = getRequestOrgId()) {
+    const globalSecret = process.env.A2A_SECRET?.trim();
+    if (globalSecret)
+        return globalSecret;
+    if (!orgId)
+        return undefined;
+    try {
+        const { getOrgA2ASecret } = await import("../org/context.js");
+        return (await getOrgA2ASecret(orgId))?.trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 export function buildLeanRunPolicyPrompt(codeEditingSurfaceRestriction, prodCodeExecPromptNote) {
     return codeEditingSurfaceRestriction + prodCodeExecPromptNote;
 }
@@ -1116,6 +1170,8 @@ export function createAgentChatPlugin(options) {
                     const a2aEvents = [];
                     const a2aToolResults = [];
                     let lastRecoverableArtifactText = "";
+                    const recoverableArtifactSecret = await resolveA2ARecoverableArtifactSecret();
+                    const recoverableArtifactStatusWriter = createSerializedA2ATaskStatusWriter(context.taskId);
                     const controller = new AbortController();
                     console.log(`[A2A] Starting agent loop: ${a2aToolSurface.tools.length}/${a2aToolSurface.availableTools.length} initial tools, prompt ${systemPrompt.length} chars`);
                     await runA2AAgentLoop({
@@ -1146,13 +1202,21 @@ export function createAgentChatPlugin(options) {
                                     isError: event.isError,
                                     completedSideEffect: event.completedSideEffect,
                                 });
-                                const recoverableArtifactText = buildA2ARecoverableArtifactMessage(a2aToolResults, {
-                                    baseUrl: resolveArtifactBaseUrl(context.event),
+                                const artifactBaseUrl = resolveArtifactBaseUrl(context.event);
+                                const recoverableArtifactMessage = buildA2ARecoverableArtifactMessage(a2aToolResults, {
+                                    baseUrl: artifactBaseUrl,
                                 });
+                                const recoverableArtifactText = recoverableArtifactMessage
+                                    ? appendA2AArtifactLinks(recoverableArtifactMessage, a2aToolResults, {
+                                        baseUrl: artifactBaseUrl,
+                                        includePersistedArtifactMarker: true,
+                                        persistedArtifactSecret: recoverableArtifactSecret,
+                                    })
+                                    : null;
                                 if (recoverableArtifactText &&
                                     recoverableArtifactText !== lastRecoverableArtifactText) {
                                     lastRecoverableArtifactText = recoverableArtifactText;
-                                    updateTaskStatusMessage(context.taskId, {
+                                    recoverableArtifactStatusWriter.enqueue({
                                         role: "agent",
                                         metadata: { agentNativeRecoverableArtifacts: true },
                                         parts: [
@@ -1161,8 +1225,6 @@ export function createAgentChatPlugin(options) {
                                                 text: recoverableArtifactText,
                                             },
                                         ],
-                                    }).catch((err) => {
-                                        console.error(`[A2A] Failed to persist recoverable artifact message for task ${context.taskId}:`, err);
                                     });
                                 }
                             }
@@ -1181,6 +1243,9 @@ export function createAgentChatPlugin(options) {
                         backgroundFunction: options?.durableBackgroundRuns === true &&
                             isInBackgroundFunctionRuntime(),
                     });
+                    // The continuation can observe terminal output immediately, so make
+                    // its latest mutation checkpoint durable first.
+                    await recoverableArtifactStatusWriter.flush();
                     const approval = [...a2aEvents]
                         .reverse()
                         .find((event) => event.type === "approval_required");