@agent-native/core 0.107.0 → 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";
@@ -11,7 +11,7 @@ import { AGENT_CHAT_BACKGROUND_RUN_FIELD, AGENT_CHAT_PROCESS_RUN_PATH, backgroun
 import { resolveEngine, createAnthropicEngine, getStoredModelForEngine, normalizeModelForEngine, getAgentEngineEntry, isAgentEnginePackageInstalled, isStoredEngineUsableForRequest, listAgentEngines, registerBuiltinEngines, } from "../agent/engine/index.js";
 import { createProductionAgentHandler, actionsToEngineTools, executeAgentToolCall, toolCallCacheKey, getActiveRunForThreadAsync, abortRunDurably, subscribeToRun, } from "../agent/production-agent.js";
 import { callerHasRunAccess, callerHasThreadAccess, } from "../agent/run-ownership.js";
-import { readBackgroundRunClaim } from "../agent/run-store.js";
+import { markTurnAborted, readBackgroundRunClaim } from "../agent/run-store.js";
 import { buildCurrentTimeUserContext, buildRuntimeContextPrompt, } from "../agent/runtime-context.js";
 import { buildAssistantMessage, buildUserMessage, extractThreadMeta, foldAssistantTurn, mergeThreadDataForClientSave, upsertUserMessage, } from "../agent/thread-data-builder.js";
 import { attachToolSearch } from "../agent/tool-search.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");
@@ -3293,6 +3358,25 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                 const canViewThread = (threadId) => callerHasThreadAccess(owner, threadId, "viewer", { orgId });
                 const canViewRun = (runId) => callerHasRunAccess(owner, runId, "viewer", { orgId });
                 const canEditRun = (runId) => callerHasRunAccess(owner, runId, "editor", { orgId });
+                const canEditThread = (threadId) => callerHasThreadAccess(owner, threadId, "editor", { orgId });
+                // Route: POST /runs/turn/:turnId/abort
+                // Covers the short window where the client has sent a turn but the
+                // server has not yet created its background run id.
+                const turnAbortMatch = url.match(/\/runs\/turn\/([^/?]+)\/abort/) ||
+                    url.match(/^\/turn\/([^/?]+)\/abort/);
+                if (turnAbortMatch && method === "POST") {
+                    const turnId = decodeURIComponent(turnAbortMatch[1]);
+                    const body = await readBody(event).catch(() => null);
+                    const threadId = typeof body?.threadId === "string" ? body.threadId : "";
+                    if (!/^[a-zA-Z0-9_-]{1,160}$/.test(turnId) ||
+                        !threadId ||
+                        !(await canEditThread(threadId))) {
+                        setResponseStatus(event, 404);
+                        return { error: "Run not found" };
+                    }
+                    await markTurnAborted(threadId, turnId);
+                    return { ok: true };
+                }
                 // Route: GET /runs/list?goalId=agent-team|agent-harness
                 // Returns background agents in the Code hub-compatible run shape.
                 const listMatch = url.match(/\/runs\/list(?:[/?]|$)/) ||
@@ -4143,6 +4227,9 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                         }
                         workerBody = {
                             ...parsedPayload,
+                            ...(prepared.body.internalContinuation === true
+                                ? { internalContinuation: true }
+                                : {}),
                             [AGENT_CHAT_BACKGROUND_RUN_FIELD]: preparedMarker,
                         };
                     }