@agent-native/core 0.101.5 → 0.101.7

package/corpus/core/src/agent/thread-data-builder.ts

@@ -637,23 +637,96 @@ export function threadDataToEngineMessages(
   for (const entry of data.messages) {
     const m = entry?.message ?? entry;
     if (!m || (m.role !== "user" && m.role !== "assistant")) continue;
-    const text =
-      typeof m.content === "string"
-        ? m.content
-        : Array.isArray(m.content)
-          ? m.content
-              .filter(
-                (c: any) => c?.type === "text" && typeof c.text === "string",
-              )
-              .map((c: any) => c.text)
-              .join("\n")
-          : "";
+    const text = threadMessageTextForEngine(m);
     if (!text.trim()) continue;
     messages.push({ role: m.role, content: [{ type: "text", text }] });
   }
   return messages;
 }
 
+const MAX_INTEGRATION_ARTIFACTS_IN_CONTEXT = 12;
+const MAX_INTEGRATION_ARTIFACT_FIELD_CHARS = 500;
+
+function boundedString(value: unknown): string | undefined {
+  if (typeof value !== "string") return undefined;
+  const trimmed = value.trim();
+  return trimmed
+    ? trimmed.slice(0, MAX_INTEGRATION_ARTIFACT_FIELD_CHARS)
+    : undefined;
+}
+
+function promptSafeJson(value: unknown): string {
+  return JSON.stringify(value)
+    .replaceAll("&", "\\u0026")
+    .replaceAll("<", "\\u003c")
+    .replaceAll(">", "\\u003e");
+}
+
+function messageTextContent(message: any): string {
+  if (typeof message?.content === "string") return message.content;
+  if (!Array.isArray(message?.content)) return "";
+  return message.content
+    .filter(
+      (part: any) => part?.type === "text" && typeof part.text === "string",
+    )
+    .map((part: any) => part.text)
+    .join("\n");
+}
+
+/**
+ * Select the participant-visible delivery for integration turns while keeping
+ * a compact, trusted resource ledger available to the agent. Raw tool results
+ * remain in thread_data for UI/audit use but are not replayed into the prompt.
+ */
+export function threadMessageTextForEngine(message: any): string {
+  const delivery = message?.metadata?.integrationDelivery;
+  const deliveryAttempted =
+    message?.metadata?.integrationDeliveryAttempted === true;
+  const deliveredText =
+    message?.role === "assistant" &&
+    delivery?.status === "delivered" &&
+    typeof delivery.text === "string" &&
+    delivery.text.trim()
+      ? delivery.text
+      : undefined;
+  let text =
+    deliveredText ??
+    (message?.role === "assistant" && deliveryAttempted
+      ? ""
+      : messageTextContent(message));
+
+  if (message?.role !== "assistant") return text;
+  const storedArtifacts = message?.metadata?.integrationArtifacts;
+  if (!Array.isArray(storedArtifacts)) return text;
+
+  const artifacts = storedArtifacts
+    .slice(0, MAX_INTEGRATION_ARTIFACTS_IN_CONTEXT)
+    .map((artifact: any) => ({
+      resourceType: boundedString(artifact?.resourceType),
+      id: boundedString(artifact?.id),
+      sourceAction: boundedString(artifact?.sourceAction),
+      titleAtAction: boundedString(artifact?.titleAtAction),
+      url: boundedString(artifact?.url),
+    }))
+    .filter(
+      (artifact: {
+        resourceType?: string;
+        id?: string;
+        sourceAction?: string;
+      }) => artifact.resourceType && artifact.id && artifact.sourceAction,
+    );
+  if (artifacts.length === 0) return text;
+
+  const context = [
+    "<integration_artifact_context>",
+    "Trusted action history for this conversation. Resource IDs remain stable if participants rename the resource. Use these IDs when a follow-up refers to an earlier artifact, while still deciding from the request whether to update, add, supersede, or create.",
+    promptSafeJson(artifacts),
+    "</integration_artifact_context>",
+  ].join("\n");
+  text = text.trim() ? `${text.trim()}\n\n${context}` : context;
+  return text;
+}
+
 export interface CodeAgentThreadTranscriptEvent {
   id: string;
   runId: string;

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

@@ -1,4 +1,8 @@
-import { appendA2AArtifactLinks } from "../a2a/artifact-response.js";
+import {
+  appendA2AArtifactLinks,
+  extractA2AArtifactIdentities,
+  stripA2APersistedArtifactMarkers,
+} from "../a2a/artifact-response.js";
 import { A2AClient, signA2AToken } from "../a2a/client.js";
 import type { Task } from "../a2a/types.js";
 import {
@@ -6,6 +10,8 @@ import {
   isLlmCredentialError,
   LLM_MISSING_CREDENTIALS_ERROR_CODE,
 } from "../agent/engine/credential-errors.js";
+import { extractThreadMeta } from "../agent/thread-data-builder.js";
+import { getThread, updateThreadData } from "../chat-threads/store.js";
 import { withConfiguredAppBasePath } from "../server/app-base-path.js";
 import { FRAMEWORK_ROUTE_PREFIX } from "../server/core-routes-plugin.js";
 import {
@@ -19,9 +25,11 @@ import {
   type A2AContinuation,
 } from "./a2a-continuations-store.js";
 import { signInternalToken } from "./internal-token.js";
+import { getThreadMapping } from "./thread-mapping-store.js";
 import type {
   OutgoingMessage,
   PlatformAdapter,
+  PlatformDeliveryReceipt,
   PlatformRunProgress,
 } from "./types.js";
 
@@ -359,8 +367,10 @@ async function deliverAndCompleteA2AContinuation(
   if (!deliveryContinuation) return;
 
   try {
-    const outgoing = adapter.formatAgentResponse(text);
-    await withTimeout(
+    const outgoing = adapter.formatAgentResponse(
+      stripA2APersistedArtifactMarkers(text),
+    );
+    const deliveryReceipt = await withTimeout(
       deliverA2AContinuationResponse(
         adapter,
         deliveryContinuation,
@@ -371,6 +381,27 @@ async function deliverAndCompleteA2AContinuation(
       PLATFORM_SEND_TIMEOUT_MS,
       `${deliveryContinuation.platform} response delivery timed out`,
     );
+    let persistenceError: unknown;
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+      try {
+        await persistA2AContinuationDelivery(
+          deliveryContinuation,
+          outgoing,
+          deliveryReceipt,
+          text,
+        );
+        persistenceError = undefined;
+        break;
+      } catch (err) {
+        persistenceError = err;
+      }
+    }
+    if (persistenceError) {
+      console.error(
+        `[integrations] Delivered A2A continuation ${deliveryContinuation.id} but could not persist its thread history:`,
+        persistenceError,
+      );
+    }
   } catch (err) {
     if (deliveryContinuation.attempts >= MAX_ATTEMPTS) {
       await failA2AContinuation(
@@ -392,7 +423,7 @@ async function deliverA2AContinuationResponse(
   message: OutgoingMessage,
   progress: PlatformRunProgress | null,
   status: "done" | "error",
-): Promise<void> {
+): Promise<PlatformDeliveryReceipt> {
   if (progress) {
     try {
       await progress.onEvent({
@@ -400,8 +431,9 @@ async function deliverA2AContinuationResponse(
         agent: continuation.agentName,
         status,
       });
-      await progress.complete(message);
-      return;
+      const receipt = await progress.complete(message);
+      if (receipt?.status === "delivered") return receipt;
+      throw new Error("Continuation progress completed without delivery proof");
     } catch {
       // A resumed Slack stream can no longer be finalized (for example when
       // chat.stopStream rejects). Preserve the final answer with the same
@@ -417,9 +449,69 @@ async function deliverA2AContinuationResponse(
       }
     }
   }
-  await adapter.sendResponse(message, continuation.incoming, {
+  const receipt = await adapter.sendResponse(message, continuation.incoming, {
     placeholderRef: continuation.placeholderRef ?? undefined,
   });
+  if (receipt?.status !== "delivered") {
+    throw new Error("Continuation response completed without delivery proof");
+  }
+  return receipt;
+}
+
+async function persistA2AContinuationDelivery(
+  continuation: A2AContinuation,
+  outgoing: OutgoingMessage,
+  receipt: PlatformDeliveryReceipt,
+  artifactText: string,
+): Promise<void> {
+  const mapping = await getThreadMapping(
+    continuation.platform,
+    continuation.externalThreadId,
+  );
+  if (!mapping) return;
+  const thread = await getThread(mapping.internalThreadId);
+  if (!thread) return;
+
+  let repo: any;
+  try {
+    repo = JSON.parse(thread.threadData || "{}");
+  } catch {
+    repo = {};
+  }
+  if (!Array.isArray(repo.messages)) repo.messages = [];
+
+  const artifacts = extractA2AArtifactIdentities([
+    { tool: "call-agent", result: artifactText },
+  ]);
+  const metadata: Record<string, unknown> = {
+    integrationDeliveryAttempted: true,
+    integrationDelivery: {
+      platform: continuation.platform,
+      status: "delivered",
+      text: outgoing.text,
+      deliveredAt: new Date().toISOString(),
+      ...(receipt.messageRefs?.length
+        ? { messageRefs: receipt.messageRefs }
+        : {}),
+    },
+  };
+  if (artifacts.length > 0) metadata.integrationArtifacts = artifacts;
+
+  repo.messages.push({
+    id: `msg-${Date.now()}-assistant-continuation`,
+    role: "assistant",
+    content: [{ type: "text", text: outgoing.text }],
+    createdAt: new Date().toISOString(),
+    metadata,
+  });
+  const meta = extractThreadMeta(repo);
+  await updateThreadData(
+    mapping.internalThreadId,
+    JSON.stringify(repo),
+    meta.title || thread.title || "Integration Chat",
+    meta.preview || thread.preview || "",
+    repo.messages.length,
+  );
 }
 
 async function rescheduleAndRedispatchA2AContinuation(

package/corpus/core/src/integrations/adapters/discord.ts

@@ -9,6 +9,7 @@ import type {
   IntegrationStatus,
   OutgoingMessage,
   PlatformAdapter,
+  PlatformDeliveryReceipt,
 } from "../types.js";
 
 const DISCORD_MAX_CONTENT_LENGTH = 2_000;
@@ -209,7 +210,7 @@ export function discordAdapter(): PlatformAdapter {
     async sendResponse(
       message: OutgoingMessage,
       context: IncomingMessage,
-    ): Promise<void> {
+    ): Promise<void | PlatformDeliveryReceipt> {
       const applicationId = readString(context.platformContext.applicationId);
       const interactionToken = readString(
         context.responseContext?.interactionToken,
@@ -236,6 +237,7 @@ export function discordAdapter(): PlatformAdapter {
           chunk,
         );
       }
+      return { status: "delivered" };
     },
 
     formatAgentResponse(text: string): OutgoingMessage {

package/corpus/core/src/integrations/adapters/email.ts

@@ -18,6 +18,7 @@ import type {
   OutgoingMessage,
   IntegrationStatus,
   OutboundTarget,
+  PlatformDeliveryReceipt,
 } from "../types.js";
 
 /** Max body length before truncation */
@@ -249,7 +250,7 @@ export function emailAdapter(): PlatformAdapter {
     async sendResponse(
       message: OutgoingMessage,
       context: IncomingMessage,
-    ): Promise<void> {
+    ): Promise<void | PlatformDeliveryReceipt> {
       const agentAddress = await resolveSecret("EMAIL_AGENT_ADDRESS");
       if (!agentAddress) {
         console.error("[email] EMAIL_AGENT_ADDRESS not configured");
@@ -284,7 +285,9 @@ export function emailAdapter(): PlatformAdapter {
         });
       } catch (err) {
         console.error("[email] Failed to send response:", err);
+        throw err;
       }
+      return { status: "delivered" };
     },
 
     async sendMessageToTarget(

package/corpus/core/src/integrations/adapters/google-docs.ts

@@ -6,6 +6,7 @@ import type {
   IncomingMessage,
   OutgoingMessage,
   IntegrationStatus,
+  PlatformDeliveryReceipt,
 } from "../types.js";
 
 /** Google Docs comment replies have no formal length limit but keep it reasonable */
@@ -303,7 +304,7 @@ export function googleDocsAdapter(): PlatformAdapter {
     async sendResponse(
       message: OutgoingMessage,
       context: IncomingMessage,
-    ): Promise<void> {
+    ): Promise<void | PlatformDeliveryReceipt> {
       const fileId = context.platformContext.fileId as string;
       const commentId = context.platformContext.commentId as string;
 
@@ -319,8 +320,10 @@ export function googleDocsAdapter(): PlatformAdapter {
           await replyToComment(fileId, commentId, chunk, accessToken);
         } catch (err) {
           console.error("[google-docs] Failed to send reply:", err);
+          throw err;
         }
       }
+      return { status: "delivered" };
     },
 
     formatAgentResponse(text: string): OutgoingMessage {

package/corpus/core/src/integrations/adapters/microsoft-teams.ts

@@ -8,6 +8,7 @@ import type {
   IntegrationStatus,
   OutgoingMessage,
   PlatformAdapter,
+  PlatformDeliveryReceipt,
 } from "../types.js";
 
 const BOT_FRAMEWORK_SCOPE = "https://api.botframework.com/.default";
@@ -201,7 +202,7 @@ export function microsoftTeamsAdapter(): PlatformAdapter {
     async sendResponse(
       message: OutgoingMessage,
       context: IncomingMessage,
-    ): Promise<void> {
+    ): Promise<void | PlatformDeliveryReceipt> {
       const serviceUrl = normalizeServiceUrl(
         context.platformContext.serviceUrl,
       );
@@ -242,6 +243,7 @@ export function microsoftTeamsAdapter(): PlatformAdapter {
           `Microsoft Teams reply failed (HTTP ${response.status})`,
         );
       }
+      return { status: "delivered" };
     },
 
     formatAgentResponse(text: string): OutgoingMessage {

package/corpus/core/src/integrations/adapters/slack.ts

@@ -23,6 +23,7 @@ import type {
   OutboundTarget,
   PlatformRunProgress,
   PlatformRunProgressRef,
+  PlatformDeliveryReceipt,
   IntegrationContextMessage,
   IntegrationFileReference,
 } from "../types.js";
@@ -431,11 +432,12 @@ export function slackAdapter(
       message: OutgoingMessage,
       context: IncomingMessage,
       opts?: { placeholderRef?: string },
-    ): Promise<void> {
+    ): Promise<void | PlatformDeliveryReceipt> {
       const token = await resolveBotToken(context);
       if (!token) {
-        console.error("[slack] SLACK_BOT_TOKEN not configured");
-        return;
+        throw new Error(
+          "[slack] Cannot deliver response: no Slack bot token is configured",
+        );
       }
 
       const channelId = context.platformContext.channelId as string;
@@ -458,6 +460,7 @@ export function slackAdapter(
         return;
       }
       const restChunks = chunks.slice(1);
+      const messageRefs: string[] = [];
 
       const finalBlocks =
         blocks ??
@@ -489,14 +492,29 @@ export function slackAdapter(
           const data = (await res.json()) as {
             ok: boolean;
             error?: string;
+            ts?: string;
           };
           if (!data.ok) {
             console.error("[slack] chat.update error:", data.error);
             // Fall back to a fresh post so the user still sees a reply
-            await postFresh(token, channelId, threadTs, baseBody);
+            const postedTs = await postFresh(
+              token,
+              channelId,
+              threadTs,
+              baseBody,
+            );
+            if (postedTs) messageRefs.push(postedTs);
+          } else {
+            messageRefs.push(data.ts || placeholderRef);
           }
         } else {
-          await postFresh(token, channelId, threadTs, baseBody);
+          const postedTs = await postFresh(
+            token,
+            channelId,
+            threadTs,
+            baseBody,
+          );
+          if (postedTs) messageRefs.push(postedTs);
         }
 
         // Clear the AI-assistant "is thinking…" status now that we've
@@ -507,14 +525,19 @@ export function slackAdapter(
 
         // Overflow chunks (rare) — post as plain follow-ups in the same thread
         for (const chunk of restChunks) {
-          await postFresh(token, channelId, threadTs, {
+          const postedTs = await postFresh(token, channelId, threadTs, {
             channel: channelId,
             text: chunk,
             unfurl_links: false,
             unfurl_media: false,
             mrkdwn: true,
           });
+          if (postedTs) messageRefs.push(postedTs);
         }
+        return {
+          status: "delivered",
+          ...(messageRefs.length > 0 ? { messageRefs } : {}),
+        };
       } catch (err) {
         console.error("[slack] Failed to send message:", err);
         throw err;
@@ -992,7 +1015,7 @@ async function postFresh(
   channelId: string,
   threadTs: string | undefined,
   body: Record<string, unknown>,
-): Promise<void> {
+): Promise<string | undefined> {
   const hasBlocks =
     Array.isArray(body.blocks) && (body.blocks as unknown[]).length > 0;
   if (
@@ -1000,7 +1023,7 @@ async function postFresh(
     body.text.trim().length === 0 &&
     !hasBlocks
   ) {
-    return;
+    return undefined;
   }
 
   const payload: Record<string, unknown> = {
@@ -1016,11 +1039,16 @@ async function postFresh(
     },
     body: JSON.stringify(payload),
   });
-  const data = (await res.json()) as { ok: boolean; error?: string };
+  const data = (await res.json()) as {
+    ok: boolean;
+    error?: string;
+    ts?: string;
+  };
   if (!data.ok) {
     console.error("[slack] chat.postMessage error:", data.error);
     throw new Error(data.error || "chat.postMessage failed");
   }
+  return data.ts;
 }
 
 async function slackApiFetch(
@@ -1871,6 +1899,7 @@ function createSlackRunProgress(
           : {}),
       });
       setSlackAssistantStatus(token, channel, threadTs, "");
+      return { status: "delivered", messageRefs: [streamTs] };
     },
     async fail(message) {
       if (pendingTimer) clearTimeout(pendingTimer);

package/corpus/core/src/integrations/adapters/telegram.ts

@@ -10,6 +10,7 @@ import type {
   OutgoingMessage,
   IntegrationStatus,
   OutboundTarget,
+  PlatformDeliveryReceipt,
 } from "../types.js";
 
 /** Telegram's max message length */
@@ -194,7 +195,7 @@ export function telegramAdapter(): PlatformAdapter {
     async sendResponse(
       message: OutgoingMessage,
       context: IncomingMessage,
-    ): Promise<void> {
+    ): Promise<void | PlatformDeliveryReceipt> {
       const token = await resolveSecret("TELEGRAM_BOT_TOKEN");
       if (!token) {
         console.error("[telegram] TELEGRAM_BOT_TOKEN not configured");
@@ -235,22 +236,43 @@ export function telegramAdapter(): PlatformAdapter {
           if (!data.ok) {
             // Retry without Markdown if parsing fails
             if (data.description?.includes("parse")) {
-              await fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({
-                  ...body,
-                  parse_mode: undefined,
-                }),
-              });
+              const retry = await fetch(
+                `https://api.telegram.org/bot${token}/sendMessage`,
+                {
+                  method: "POST",
+                  headers: { "Content-Type": "application/json" },
+                  body: JSON.stringify({
+                    ...body,
+                    parse_mode: undefined,
+                  }),
+                },
+              );
+              if (!retry.ok) {
+                throw new Error(
+                  `Telegram sendMessage retry failed (HTTP ${retry.status})`,
+                );
+              }
+              const retryData = (await retry.json()) as {
+                ok: boolean;
+                description?: string;
+              };
+              if (!retryData.ok) {
+                throw new Error(
+                  `Telegram sendMessage retry failed: ${retryData.description ?? "unknown error"}`,
+                );
+              }
             } else {
-              console.error("[telegram] sendMessage error:", data.description);
+              throw new Error(
+                `Telegram sendMessage failed: ${data.description ?? "unknown error"}`,
+              );
             }
           }
         } catch (err) {
           console.error("[telegram] Failed to send message:", err);
+          throw err;
         }
       }
+      return { status: "delivered" };
     },
 
     async sendMessageToTarget(

package/corpus/core/src/integrations/adapters/whatsapp.ts

@@ -8,6 +8,7 @@ import type {
   IncomingMessage,
   OutgoingMessage,
   IntegrationStatus,
+  PlatformDeliveryReceipt,
 } from "../types.js";
 
 /** WhatsApp's max message length */
@@ -240,7 +241,7 @@ export function whatsappAdapter(): PlatformAdapter {
     async sendResponse(
       message: OutgoingMessage,
       context: IncomingMessage,
-    ): Promise<void> {
+    ): Promise<void | PlatformDeliveryReceipt> {
       const accessToken = await resolveSecret("WHATSAPP_ACCESS_TOKEN");
       const phoneNumberId = await resolveSecret("WHATSAPP_PHONE_NUMBER_ID");
       if (!accessToken || !phoneNumberId) {
@@ -279,11 +280,14 @@ export function whatsappAdapter(): PlatformAdapter {
           if (!res.ok) {
             const data = await res.json().catch(() => ({}));
             console.error("[whatsapp] sendMessage error:", data);
+            throw new Error(`WhatsApp sendMessage failed (HTTP ${res.status})`);
           }
         } catch (err) {
           console.error("[whatsapp] Failed to send message:", err);
+          throw err;
         }
       }
+      return { status: "delivered" };
     },
 
     formatAgentResponse(text: string): OutgoingMessage {

package/corpus/core/src/integrations/index.ts

@@ -15,6 +15,7 @@ export type {
   IntegrationConversationType,
   IntegrationTriggerKind,
   PlatformRunProgress,
+  PlatformDeliveryReceipt,
 } from "./types.js";
 export { assertPlatformCapability } from "./types.js";
 

package/corpus/core/src/integrations/types.ts

@@ -127,6 +127,13 @@ export interface OutgoingMessage {
   platformContext: Record<string, unknown>;
 }
 
+/** Provider-confirmed references for a successfully delivered response. */
+export interface PlatformDeliveryReceipt {
+  status: "delivered";
+  /** Opaque provider message ids/timestamps; never message content. */
+  messageRefs?: string[];
+}
+
 /**
  * Proactive outbound message target for a platform.
  * Used when the agent needs to send to a saved destination instead of replying
@@ -197,7 +204,7 @@ export interface PlatformRunProgress {
   /** Receive normalized agent events. Implementations should throttle writes. */
   onEvent(event: AgentChatEvent): Promise<void> | void;
   /** Finalize the provider-native progress surface with the answer. */
-  complete(message: OutgoingMessage): Promise<void>;
+  complete(message: OutgoingMessage): Promise<void | PlatformDeliveryReceipt>;
   /** Mark the provider-native surface failed and leave a retryable explanation. */
   fail?(message: string): Promise<void>;
 }
@@ -316,7 +323,7 @@ export interface PlatformAdapter {
     message: OutgoingMessage,
     context: IncomingMessage,
     opts?: { placeholderRef?: string },
-  ): Promise<void>;
+  ): Promise<void | PlatformDeliveryReceipt>;
 
   /**
    * Send a short best-effort system notice to the conversation the incoming