@agent-native/core 0.94.2 → 0.94.3

package/corpus/core/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @agent-native/core
 
+## 0.94.3
+
+### Patch Changes
+
+- 48d8471: Keep Slack agent task cards active through deferred cross-agent work, show durable progress, and deliver the true final result instead of treating interim artifacts as complete.
+- 48d8471: Keep completed realtime voice turns in their originating chat, restore that chat safely when voice ends, and expose live audio activity to the voice dock.
+- 48d8471: Accept canonical Content document links returned by successful read-only actions as A2A artifact proof while continuing to reject mismatched or unproven URLs.
+
 ## 0.94.2
 
 ### Patch Changes

package/corpus/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.94.2",
+  "version": "0.94.3",
   "description": "Framework for agent-native application development — where AI agents and UI share SQL state, actions, and context",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {

package/corpus/core/src/a2a/artifact-response.ts

@@ -228,6 +228,132 @@ function contentDatabaseSubmissionArtifact(
   };
 }
 
+function documentUrlForId(
+  parsed: Record<string, unknown>,
+  id: string,
+  additionalCandidates: Array<string | undefined> = [],
+  options: { requireContentOrigin?: boolean } = {},
+): string | undefined {
+  const candidates = [
+    stringValue(parsed.url),
+    stringValue(parsed.urlPath),
+    stringValue(parsed.deepLink),
+    stringValue(parsed.pageUrl),
+    stringValue(parsed.documentUrl),
+    ...additionalCandidates,
+  ].filter((value): value is string => !!value);
+
+  return candidates.find((candidate) => {
+    if (!artifactUrlReferencesId(candidate, "document", id)) return false;
+    return !options.requireContentOrigin || isContentDocumentUrl(candidate);
+  });
+}
+
+function isContentDocumentUrl(rawUrl: string): boolean {
+  try {
+    return new URL(rawUrl).origin === "https://content.agent-native.com";
+  } catch {
+    return false;
+  }
+}
+
+function addDocumentReadArtifact(
+  documents: Map<string, CreatedDocumentArtifact>,
+  parsed: Record<string, unknown>,
+  options: {
+    allowWithoutUrl: boolean;
+    additionalUrlCandidates?: Array<string | undefined>;
+    requireContentOrigin?: boolean;
+  },
+): void {
+  const id = stringValue(parsed.documentId) ?? stringValue(parsed.id);
+  if (!id) return;
+
+  const url = documentUrlForId(parsed, id, options.additionalUrlCandidates, {
+    requireContentOrigin: options.requireContentOrigin,
+  });
+  if (!url && !options.allowWithoutUrl) return;
+
+  documents.set(id, {
+    id,
+    title: stringValue(parsed.title) ?? stringValue(parsed.name),
+    url,
+  });
+}
+
+function addContentDatabaseReadArtifacts(
+  documents: Map<string, CreatedDocumentArtifact>,
+  parsed: Record<string, unknown>,
+): void {
+  const resultUrls = [
+    stringValue(parsed.url),
+    stringValue(parsed.urlPath),
+    stringValue(parsed.deepLink),
+  ];
+  const database = asRecord(parsed.database);
+  if (database) {
+    addDocumentReadArtifact(documents, database, {
+      allowWithoutUrl: true,
+      requireContentOrigin: true,
+      additionalUrlCandidates: resultUrls,
+    });
+  } else {
+    // Unavailable database reads still return a documentId, but they do not
+    // prove that the page exists and must not authorize an artifact URL.
+    if (parsed.available !== false) {
+      addDocumentReadArtifact(documents, parsed, {
+        allowWithoutUrl: true,
+        requireContentOrigin: true,
+      });
+    }
+  }
+
+  if (!Array.isArray(parsed.items)) return;
+  for (const item of parsed.items) {
+    const itemRecord = asRecord(item);
+    const document = asRecord(itemRecord?.document);
+    if (!document) continue;
+    addDocumentReadArtifact(documents, document, {
+      allowWithoutUrl: true,
+      requireContentOrigin: true,
+      additionalUrlCandidates: [
+        stringValue(itemRecord?.url),
+        stringValue(itemRecord?.urlPath),
+        stringValue(itemRecord?.deepLink),
+      ],
+    });
+  }
+}
+
+function isGenericReadTool(tool: string): boolean {
+  return /^(?:find|get|list|query|read|search)-/i.test(tool);
+}
+
+function addGenericDocumentReadArtifact(
+  documents: Map<string, CreatedDocumentArtifact>,
+  parsed: Record<string, unknown>,
+): void {
+  // Unknown read actions are accepted only when their result pairs a document
+  // ID with a canonical page URL containing that exact ID. An ID by itself is
+  // insufficient, preserving the fabrication guard for unrelated actions.
+  addDocumentReadArtifact(documents, parsed, {
+    allowWithoutUrl: false,
+    requireContentOrigin: true,
+  });
+
+  const document = asRecord(parsed.document);
+  if (!document) return;
+  addDocumentReadArtifact(documents, document, {
+    allowWithoutUrl: false,
+    requireContentOrigin: true,
+    additionalUrlCandidates: [
+      stringValue(parsed.url),
+      stringValue(parsed.urlPath),
+      stringValue(parsed.deepLink),
+    ],
+  });
+}
+
 function addImageArtifact(
   images: Map<string, CreatedImageArtifact>,
   parsed: Record<string, unknown>,
@@ -387,7 +513,6 @@ function collectArtifacts(results: A2AToolResultSummary[]): {
 
     if (
       toolResult.tool === "create-document" ||
-      toolResult.tool === "get-document" ||
       toolResult.tool === "update-document"
     ) {
       const id = stringValue(parsed.id);
@@ -401,6 +526,34 @@ function collectArtifacts(results: A2AToolResultSummary[]): {
       continue;
     }
 
+    if (
+      toolResult.tool === "get-document" ||
+      toolResult.tool === "get-content-document"
+    ) {
+      const document = asRecord(parsed.document);
+      addDocumentReadArtifact(documents, document ?? parsed, {
+        allowWithoutUrl: true,
+        requireContentOrigin: true,
+        additionalUrlCandidates: document
+          ? [
+              stringValue(parsed.url),
+              stringValue(parsed.urlPath),
+              stringValue(parsed.deepLink),
+            ]
+          : [],
+      });
+      continue;
+    }
+
+    if (toolResult.tool === "get-content-database") {
+      addContentDatabaseReadArtifacts(documents, parsed);
+      continue;
+    }
+
+    if (isGenericReadTool(toolResult.tool)) {
+      addGenericDocumentReadArtifact(documents, parsed);
+    }
+
     if (
       toolResult.tool === "create-deck" ||
       toolResult.tool === "duplicate-deck"

package/corpus/core/src/integrations/a2a-continuation-processor.ts

@@ -18,7 +18,11 @@ import {
   type A2AContinuation,
 } from "./a2a-continuations-store.js";
 import { signInternalToken } from "./internal-token.js";
-import type { PlatformAdapter } from "./types.js";
+import type {
+  OutgoingMessage,
+  PlatformAdapter,
+  PlatformRunProgress,
+} from "./types.js";
 
 const PROCESSOR_PATH = `${FRAMEWORK_ROUTE_PREFIX}/integrations/process-a2a-continuation`;
 const TERMINAL_STATES = new Set(["completed", "failed", "canceled"]);
@@ -150,6 +154,8 @@ async function processClaimedContinuation(
     return;
   }
 
+  const progress = await resumeA2AContinuationProgress(continuation, adapter);
+
   const auth = await signContinuationToken(continuation);
   const client = new A2AClient(continuation.agentUrl, auth.apiKey, {
     requestTimeoutMs: POLL_REQUEST_TIMEOUT_MS,
@@ -162,6 +168,7 @@ async function processClaimedContinuation(
     while (Date.now() < deadline) {
       task = await client.getTask(continuation.a2aTaskId);
       if (TERMINAL_STATES.has(task.status.state)) break;
+      await reportA2AContinuationProgress(continuation, progress, task);
       await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
     }
   } catch (err) {
@@ -171,6 +178,7 @@ async function processClaimedContinuation(
           continuation,
           adapter,
           remotePollFailureReason(continuation),
+          progress,
         );
         return;
       }
@@ -182,6 +190,7 @@ async function processClaimedContinuation(
         continuation,
         adapter,
         err instanceof Error ? err.message : String(err),
+        progress,
       );
       return;
     }
@@ -190,24 +199,12 @@ async function processClaimedContinuation(
   }
 
   if (!task || !TERMINAL_STATES.has(task.status.state)) {
-    const recoverableArtifactText = extractRecoverableArtifactText(task);
-    if (recoverableArtifactText) {
-      await deliverAndCompleteA2AContinuation(
-        continuation,
-        adapter,
-        formatContinuationArtifactText(
-          recoverableArtifactText,
-          continuation.agentUrl,
-        ),
-      );
-      return;
-    }
-
     if (shouldStopPollingRemoteTask(continuation)) {
       await notifyAndFailA2AContinuation(
         continuation,
         adapter,
         remotePollFailureReason(continuation),
+        progress,
       );
       return;
     }
@@ -219,7 +216,7 @@ async function processClaimedContinuation(
     const reason =
       extractTaskText(task) ||
       `Remote A2A task ${continuation.a2aTaskId} ended with state ${task.status.state}`;
-    await notifyAndFailA2AContinuation(continuation, adapter, reason);
+    await notifyAndFailA2AContinuation(continuation, adapter, reason, progress);
     return;
   }
 
@@ -232,11 +229,64 @@ async function processClaimedContinuation(
       continuation,
       adapter,
       `Remote A2A task ${continuation.a2aTaskId} completed without text`,
+      progress,
     );
     return;
   }
 
-  await deliverAndCompleteA2AContinuation(continuation, adapter, text);
+  await deliverAndCompleteA2AContinuation(
+    continuation,
+    adapter,
+    text,
+    progress,
+  );
+}
+
+async function resumeA2AContinuationProgress(
+  continuation: A2AContinuation,
+  adapter: PlatformAdapter,
+): Promise<PlatformRunProgress | null> {
+  if (!continuation.progressRef || !adapter.resumeRunProgress) return null;
+  try {
+    const progress = await adapter.resumeRunProgress(
+      continuation.incoming,
+      continuation.progressRef,
+    );
+    if (!progress) return null;
+    await progress.onEvent({
+      type: "agent_call_progress",
+      agent: continuation.agentName,
+      state: "working",
+      elapsedSeconds: Math.max(
+        0,
+        Math.round((Date.now() - continuation.createdAt) / 1_000),
+      ),
+      detail: "Continuing in the background",
+    });
+    return progress;
+  } catch {
+    // A continuation still has a normal reply fallback. Do not log the
+    // opaque provider reference or the inbound message payload.
+    return null;
+  }
+}
+
+async function reportA2AContinuationProgress(
+  continuation: A2AContinuation,
+  progress: PlatformRunProgress | null,
+  task: Task,
+): Promise<void> {
+  if (!progress) return;
+  await progress.onEvent({
+    type: "agent_call_progress",
+    agent: continuation.agentName,
+    state: task.status.state,
+    elapsedSeconds: Math.max(
+      0,
+      Math.round((Date.now() - continuation.createdAt) / 1_000),
+    ),
+    detail: "Still working on the delegated request",
+  });
 }
 
 async function waitForContinuationDue(
@@ -262,6 +312,7 @@ async function notifyAndFailA2AContinuation(
   continuation: A2AContinuation,
   adapter: PlatformAdapter,
   reason: string,
+  progress: PlatformRunProgress | null = null,
 ): Promise<void> {
   const deliveryContinuation = await claimA2AContinuationDelivery(
     continuation.id,
@@ -273,11 +324,14 @@ async function notifyAndFailA2AContinuation(
     reason,
   );
   try {
+    const outgoing = adapter.formatAgentResponse(message);
     await withTimeout(
-      adapter.sendResponse(
-        adapter.formatAgentResponse(message),
-        deliveryContinuation.incoming,
-        { placeholderRef: deliveryContinuation.placeholderRef ?? undefined },
+      deliverA2AContinuationResponse(
+        adapter,
+        deliveryContinuation,
+        outgoing,
+        progress,
+        "error",
       ),
       PLATFORM_SEND_TIMEOUT_MS,
       `${deliveryContinuation.platform} failure notification timed out`,
@@ -296,6 +350,7 @@ async function deliverAndCompleteA2AContinuation(
   continuation: A2AContinuation,
   adapter: PlatformAdapter,
   text: string,
+  progress: PlatformRunProgress | null = null,
 ): Promise<void> {
   const deliveryContinuation = await claimA2AContinuationDelivery(
     continuation.id,
@@ -303,11 +358,14 @@ async function deliverAndCompleteA2AContinuation(
   if (!deliveryContinuation) return;
 
   try {
+    const outgoing = adapter.formatAgentResponse(text);
     await withTimeout(
-      adapter.sendResponse(
-        adapter.formatAgentResponse(text),
-        deliveryContinuation.incoming,
-        { placeholderRef: deliveryContinuation.placeholderRef ?? undefined },
+      deliverA2AContinuationResponse(
+        adapter,
+        deliveryContinuation,
+        outgoing,
+        progress,
+        "done",
       ),
       PLATFORM_SEND_TIMEOUT_MS,
       `${deliveryContinuation.platform} response delivery timed out`,
@@ -327,6 +385,42 @@ async function deliverAndCompleteA2AContinuation(
   await completeAfterSuccessfulDelivery(deliveryContinuation);
 }
 
+async function deliverA2AContinuationResponse(
+  adapter: PlatformAdapter,
+  continuation: A2AContinuation,
+  message: OutgoingMessage,
+  progress: PlatformRunProgress | null,
+  status: "done" | "error",
+): Promise<void> {
+  if (progress) {
+    try {
+      await progress.onEvent({
+        type: "agent_call",
+        agent: continuation.agentName,
+        status,
+      });
+      await progress.complete(message);
+      return;
+    } catch {
+      // A resumed Slack stream can no longer be finalized (for example when
+      // chat.stopStream rejects). Preserve the final answer with the same
+      // thread reply fallback used by the initial webhook run. Also ask the
+      // adapter to terminate the native stream: otherwise Slack can keep the
+      // task card in its working state after the thread fallback succeeds.
+      try {
+        await progress.fail?.(
+          "I couldn't update the live response, but I posted the final result in this thread.",
+        );
+      } catch {
+        // The thread reply below is still the authoritative final answer.
+      }
+    }
+  }
+  await adapter.sendResponse(message, continuation.incoming, {
+    placeholderRef: continuation.placeholderRef ?? undefined,
+  });
+}
+
 async function rescheduleAndRedispatchA2AContinuation(
   continuationId: string,
 ): Promise<void> {
@@ -524,13 +618,6 @@ function extractTaskText(task: Task): string {
     .join("\n");
 }
 
-function extractRecoverableArtifactText(task: Task | null): string {
-  if (!task?.status.message?.metadata?.agentNativeRecoverableArtifacts) {
-    return "";
-  }
-  return extractTaskText(task);
-}
-
 function formatContinuationArtifactText(
   text: string,
   agentUrl: string,