@agent-native/core 0.101.6 → 0.101.10

package/dist/a2a/artifact-response.js

@@ -1,3 +1,88 @@
+import { createHmac, timingSafeEqual } from "node:crypto";
+const ARTIFACT_IDENTITY_WRITE_TOOLS = new Set([
+    "save-monitor",
+    "create-form",
+    "submit-content-database-form",
+    "add-database-item",
+    "create-document",
+    "update-document",
+    "create-deck",
+    "duplicate-deck",
+    "add-slide",
+    "update-dashboard",
+    "rename-dashboard",
+    "save-analysis",
+    "generate-image",
+    "edit-image",
+    "refine-image",
+    "restyle-image",
+    "save-generated-image",
+    "save-generated-asset",
+    "export-image",
+    "export-asset",
+    "generate-image-batch",
+    "create-design",
+    "generate-design",
+    "create-file",
+    "duplicate-design",
+]);
+const PERSISTED_ARTIFACT_MARKER = "agent-native:persisted-artifacts=";
+const PERSISTED_ARTIFACT_MARKER_PATTERN = /\s*<!--\s*agent-native:persisted-artifacts=[A-Za-z0-9_-]+\.[a-f0-9]{64}\s*-->/g;
+const ARTIFACT_RESOURCE_TYPES = new Set([
+    "document",
+    "deck",
+    "dashboard",
+    "analysis",
+    "image",
+    "design",
+    "monitor",
+    "form",
+]);
+function persistedArtifactIdentitiesFromMarker(result) {
+    const secret = process.env.A2A_SECRET;
+    if (!secret)
+        return [];
+    const match = result.match(/<!--\s*agent-native:persisted-artifacts=([A-Za-z0-9_-]+)\.([a-f0-9]{64})\s*-->/);
+    if (!match)
+        return [];
+    try {
+        const payload = match[1];
+        const expected = createHmac("sha256", secret).update(payload).digest();
+        const supplied = Buffer.from(match[2], "hex");
+        if (supplied.length !== expected.length ||
+            !timingSafeEqual(supplied, expected)) {
+            return [];
+        }
+        const parsed = JSON.parse(Buffer.from(payload, "base64url").toString());
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed
+            .slice(0, 12)
+            .filter((identity) => {
+            const item = asRecord(identity);
+            return (!!item &&
+                ARTIFACT_RESOURCE_TYPES.has(item.resourceType) &&
+                typeof item.id === "string" &&
+                typeof item.sourceAction === "string");
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function withPersistedArtifactMarker(text, toolResults) {
+    const identities = extractA2AArtifactIdentities(toolResults).slice(0, 12);
+    const secret = process.env.A2A_SECRET;
+    if (identities.length === 0 || !secret)
+        return text;
+    const payload = Buffer.from(JSON.stringify(identities)).toString("base64url");
+    const signature = createHmac("sha256", secret).update(payload).digest("hex");
+    const marker = `<!-- ${PERSISTED_ARTIFACT_MARKER}${payload}.${signature} -->`;
+    return text ? `${text}\n\n${marker}` : marker;
+}
+export function stripA2APersistedArtifactMarkers(text) {
+    return text.replace(PERSISTED_ARTIFACT_MARKER_PATTERN, "").trim();
+}
 function asRecord(value) {
     return value && typeof value === "object" && !Array.isArray(value)
         ? value
@@ -450,13 +535,22 @@ function collectArtifacts(results) {
             continue;
         }
         if (toolResult.tool === "generate-image" ||
+            toolResult.tool === "edit-image" ||
             toolResult.tool === "refine-image" ||
+            toolResult.tool === "restyle-image" ||
             toolResult.tool === "get-asset" ||
             toolResult.tool === "save-generated-image" ||
+            toolResult.tool === "save-generated-asset" ||
             toolResult.tool === "export-image") {
             addImageArtifact(images, parsed);
             continue;
         }
+        if (toolResult.tool === "export-asset") {
+            if (stringValue(parsed.artifactType) === "image") {
+                addImageArtifact(images, parsed);
+            }
+            continue;
+        }
         if (toolResult.tool === "generate-image-batch") {
             if (Array.isArray(parsed.images)) {
                 for (const item of parsed.images) {
@@ -553,6 +647,107 @@ function collectArtifacts(results) {
         forms: [...forms.values()],
     };
 }
+/**
+ * Extract a compact, verified identity ledger from successful artifact tools.
+ * The ledger deliberately excludes raw tool results so it is safe to retain in
+ * long-lived thread context and stable even when a resource is later renamed.
+ */
+export function extractA2AArtifactIdentities(results) {
+    const identities = new Map();
+    const remember = (identity) => {
+        identities.set(`${identity.resourceType}:${identity.id}`, identity);
+    };
+    for (const result of results) {
+        if (result.tool === "call-agent") {
+            for (const identity of persistedArtifactIdentitiesFromMarker(result.result)) {
+                remember({ ...identity, sourceAction: "call-agent" });
+            }
+            continue;
+        }
+        if (!ARTIFACT_IDENTITY_WRITE_TOOLS.has(result.tool))
+            continue;
+        const artifacts = collectArtifacts([result]);
+        for (const document of artifacts.documents) {
+            remember({
+                resourceType: "document",
+                id: document.id,
+                sourceAction: result.tool,
+                titleAtAction: document.title,
+                url: document.url,
+            });
+        }
+        for (const deck of artifacts.decks) {
+            remember({
+                resourceType: "deck",
+                id: deck.id,
+                sourceAction: result.tool,
+                url: deck.url,
+            });
+        }
+        for (const dashboard of artifacts.dashboards) {
+            remember({
+                resourceType: "dashboard",
+                id: dashboard.id,
+                sourceAction: result.tool,
+                titleAtAction: dashboard.title,
+                url: dashboard.url,
+            });
+        }
+        for (const analysis of artifacts.analyses) {
+            remember({
+                resourceType: "analysis",
+                id: analysis.id,
+                sourceAction: result.tool,
+                titleAtAction: analysis.title,
+                url: analysis.url,
+            });
+        }
+        for (const image of artifacts.images) {
+            remember({
+                resourceType: "image",
+                id: image.id,
+                sourceAction: result.tool,
+                titleAtAction: image.title,
+                url: image.url,
+            });
+        }
+        for (const design of artifacts.designShells) {
+            remember({
+                resourceType: "design",
+                id: design.id,
+                sourceAction: result.tool,
+                titleAtAction: design.title,
+            });
+        }
+        for (const design of artifacts.generatedDesigns) {
+            remember({
+                resourceType: "design",
+                id: design.id,
+                sourceAction: result.tool,
+                url: design.url,
+            });
+        }
+        for (const monitor of artifacts.monitors) {
+            remember({
+                resourceType: "monitor",
+                id: monitor.id,
+                sourceAction: result.tool,
+                titleAtAction: monitor.name,
+                url: monitor.url,
+            });
+        }
+        for (const form of artifacts.forms) {
+            remember({
+                resourceType: "form",
+                id: form.id,
+                sourceAction: result.tool,
+                titleAtAction: form.title,
+                url: form.url,
+            });
+        }
+    }
+    return [...identities.values()];
+}
 function parseDownstreamArtifactBlock(result) {
     const artifacts = [];
     for (const line of downstreamArtifactLines(result)) {
@@ -857,6 +1052,9 @@ function formatUnverifiedArtifactMessage(refs, documents, decks, dashboards, ana
 export function appendA2AArtifactLinks(responseText, toolResults, options = {}) {
     const baseUrl = normalizeBaseUrl(options.baseUrl);
     const includeReferencedArtifacts = options.includeReferencedArtifacts ?? false;
+    const finalize = (value) => options.includePersistedArtifactMarker
+        ? withPersistedArtifactMarker(value, toolResults)
+        : value;
     const { documents, decks, dashboards, analyses, images, designShells, generatedDesigns, monitors, forms, } = collectArtifacts(toolResults);
     const generatedDesignIds = new Set(generatedDesigns.map((design) => design.id));
     const incompleteShells = designShells.filter((shell) => !generatedDesignIds.has(shell.id));
@@ -866,11 +1064,11 @@ export function appendA2AArtifactLinks(responseText, toolResults, options = {})
         !responseAlreadyWarnsIncompleteDesign(text) &&
         (incompleteShells.some((shell) => responseMentionsDesignShell(text, shell)) ||
             /\b(?:done|created|ready|here(?:'s| is)|complete|finished)\b/i.test(text))) {
-        return formatIncompleteDesignMessage(incompleteShells);
+        return finalize(formatIncompleteDesignMessage(incompleteShells));
     }
     const unverifiedRefs = findUnverifiedArtifactReferences(text, baseUrl, documents, decks, dashboards, analyses, images, generatedDesigns);
     if (unverifiedRefs.length > 0) {
-        return formatUnverifiedArtifactMessage(unverifiedRefs, documents, decks, dashboards, analyses, images, generatedDesigns, baseUrl);
+        return finalize(formatUnverifiedArtifactMessage(unverifiedRefs, documents, decks, dashboards, analyses, images, generatedDesigns, baseUrl));
     }
     const missingLines = [];
     for (const document of documents) {
@@ -927,10 +1125,11 @@ export function appendA2AArtifactLinks(responseText, toolResults, options = {})
             missingLines.push(formatFormLine(form));
         }
     }
-    if (missingLines.length === 0)
-        return text;
+    if (missingLines.length === 0) {
+        return finalize(text);
+    }
     const artifactBlock = `Artifacts:\n${missingLines.join("\n")}`;
-    return text ? `${text}\n\n${artifactBlock}` : artifactBlock;
+    return finalize(text ? `${text}\n\n${artifactBlock}` : artifactBlock);
 }
 export function buildA2ARecoverableArtifactMessage(toolResults, options = {}) {
     const baseUrl = normalizeBaseUrl(options.baseUrl);