@agent-native/core 0.94.2 → 0.94.3

package/corpus/core/src/integrations/a2a-continuations-store.ts

@@ -10,7 +10,7 @@ import {
   ensureIndexExists,
 } from "../db/ddl-guard.js";
 import { isDuplicateColumnError } from "../db/migrations.js";
-import type { IncomingMessage } from "./types.js";
+import type { IncomingMessage, PlatformRunProgressRef } from "./types.js";
 
 let _initPromise: Promise<void> | undefined;
 const PROCESSING_STUCK_AFTER_MS = 5 * 60 * 1000;
@@ -28,6 +28,8 @@ function buildCreateSql(): string {
     external_thread_id TEXT NOT NULL,
     incoming_payload TEXT NOT NULL,
     placeholder_ref TEXT,
+    progress_ref TEXT,
+    progress_ref_claimed ${intType()} NOT NULL DEFAULT 0,
     owner_email TEXT NOT NULL,
     org_id TEXT,
     agent_name TEXT NOT NULL,
@@ -76,10 +78,25 @@ async function ensureTable(): Promise<void> {
           "dedupe_key",
           `ALTER TABLE integration_a2a_continuations ADD COLUMN IF NOT EXISTS dedupe_key TEXT`,
         );
+        await ensureColumnExists(
+          "integration_a2a_continuations",
+          "progress_ref",
+          `ALTER TABLE integration_a2a_continuations ADD COLUMN IF NOT EXISTS progress_ref TEXT`,
+        );
+        await ensureColumnExists(
+          "integration_a2a_continuations",
+          "progress_ref_claimed",
+          `ALTER TABLE integration_a2a_continuations ADD COLUMN IF NOT EXISTS progress_ref_claimed ${intType()} NOT NULL DEFAULT 0`,
+        );
+        await backfillProgressRefOwners(client);
         await ensureIndexExists(
           "idx_a2a_continuations_dedupe_key",
           `CREATE INDEX IF NOT EXISTS idx_a2a_continuations_dedupe_key ON integration_a2a_continuations(integration_task_id, agent_url, dedupe_key)`,
         );
+        await ensureIndexExists(
+          "idx_a2a_continuations_one_progress_owner",
+          `CREATE UNIQUE INDEX IF NOT EXISTS idx_a2a_continuations_one_progress_owner ON integration_a2a_continuations(integration_task_id) WHERE progress_ref_claimed = 1`,
+        );
         return;
       }
       // SQLite (local dev): keep existing behavior
@@ -101,11 +118,22 @@ async function ensureTable(): Promise<void> {
       );
       await addColumnIfMissing("a2a_auth_token", "TEXT");
       await addColumnIfMissing("dedupe_key", "TEXT");
+      await addColumnIfMissing("progress_ref", "TEXT");
+      await addColumnIfMissing(
+        "progress_ref_claimed",
+        `${intType()} NOT NULL DEFAULT 0`,
+      );
+      await backfillProgressRefOwners(client);
       await retryOnDdlRace(() =>
         client.execute(
           `CREATE INDEX IF NOT EXISTS idx_a2a_continuations_dedupe_key ON integration_a2a_continuations(integration_task_id, agent_url, dedupe_key)`,
         ),
       );
+      await retryOnDdlRace(() =>
+        client.execute(
+          `CREATE UNIQUE INDEX IF NOT EXISTS idx_a2a_continuations_one_progress_owner ON integration_a2a_continuations(integration_task_id) WHERE progress_ref_claimed = 1`,
+        ),
+      );
     })().catch((err) => {
       // Retry init on the next call after a failed startup.
       _initPromise = undefined;
@@ -128,6 +156,33 @@ async function addColumnIfMissing(name: string, definition: string) {
   }
 }
 
+async function backfillProgressRefOwners(
+  client: ReturnType<typeof getDbExec>,
+): Promise<void> {
+  await client.execute(`
+    UPDATE integration_a2a_continuations AS candidate
+    SET progress_ref_claimed = 1
+    WHERE candidate.progress_ref IS NOT NULL
+      AND candidate.status NOT IN ('completed', 'failed')
+      AND candidate.progress_ref_claimed = 0
+      AND NOT EXISTS (
+        SELECT 1
+        FROM integration_a2a_continuations AS owner
+        WHERE owner.integration_task_id = candidate.integration_task_id
+          AND owner.progress_ref_claimed = 1
+      )
+      AND candidate.id = (
+        SELECT selected.id
+        FROM integration_a2a_continuations AS selected
+        WHERE selected.integration_task_id = candidate.integration_task_id
+          AND selected.progress_ref IS NOT NULL
+          AND selected.status NOT IN ('completed', 'failed')
+        ORDER BY selected.created_at ASC, selected.id ASC
+        LIMIT 1
+      )
+  `);
+}
+
 export type A2AContinuationStatus =
   | "pending"
   | "processing"
@@ -142,6 +197,8 @@ export interface A2AContinuation {
   externalThreadId: string;
   incoming: IncomingMessage;
   placeholderRef: string | null;
+  progressRef: PlatformRunProgressRef | null;
+  progressRefClaimed: boolean;
   ownerEmail: string;
   orgId: string | null;
   agentName: string;
@@ -158,6 +215,44 @@ export interface A2AContinuation {
   completedAt: number | null;
 }
 
+const MAX_PROGRESS_REF_KIND_CHARS = 128;
+const MAX_PROGRESS_REF_STREAM_TS_CHARS = 256;
+
+/**
+ * Keep only the tiny, adapter-owned continuation reference. Invalid rows are
+ * treated as unavailable rather than throwing during a retry sweep.
+ */
+function parseProgressRef(value: unknown): PlatformRunProgressRef | null {
+  if (typeof value !== "string" || value.length === 0) return null;
+  try {
+    const parsed = JSON.parse(value) as unknown;
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return null;
+    }
+    const { kind, streamTs } = parsed as Record<string, unknown>;
+    if (
+      typeof kind !== "string" ||
+      typeof streamTs !== "string" ||
+      kind.length === 0 ||
+      streamTs.length === 0 ||
+      kind.length > MAX_PROGRESS_REF_KIND_CHARS ||
+      streamTs.length > MAX_PROGRESS_REF_STREAM_TS_CHARS
+    ) {
+      return null;
+    }
+    return { kind, streamTs };
+  } catch {
+    return null;
+  }
+}
+
+function serializeProgressRef(value: unknown): string | null {
+  const parsed = parseProgressRef(
+    typeof value === "string" ? value : JSON.stringify(value),
+  );
+  return parsed ? JSON.stringify(parsed) : null;
+}
+
 function rowToContinuation(row: Record<string, unknown>): A2AContinuation {
   return {
     id: row.id as string,
@@ -166,6 +261,8 @@ function rowToContinuation(row: Record<string, unknown>): A2AContinuation {
     externalThreadId: row.external_thread_id as string,
     incoming: JSON.parse(row.incoming_payload as string) as IncomingMessage,
     placeholderRef: (row.placeholder_ref as string | null) ?? null,
+    progressRef: parseProgressRef(row.progress_ref),
+    progressRefClaimed: Number(row.progress_ref_claimed ?? 0) === 1,
     ownerEmail: row.owner_email as string,
     orgId: (row.org_id as string | null) ?? null,
     agentName: row.agent_name as string,
@@ -190,6 +287,7 @@ export async function insertA2AContinuation(input: {
   externalThreadId: string;
   incoming: IncomingMessage;
   placeholderRef?: string | null;
+  progressRef?: PlatformRunProgressRef | null;
   ownerEmail: string;
   orgId?: string | null;
   agentName: string;
@@ -203,14 +301,15 @@ export async function insertA2AContinuation(input: {
   const now = Date.now();
   const id = `a2a-cont-${now}-${Math.random().toString(36).slice(2, 8)}`;
   const payload = JSON.stringify(input.incoming);
+  const progressRef = serializeProgressRef(input.progressRef);
 
   try {
     await client.execute({
       sql: `INSERT INTO integration_a2a_continuations
         (id, integration_task_id, platform, external_thread_id, incoming_payload,
-         placeholder_ref, owner_email, org_id, agent_name, agent_url, dedupe_key, a2a_task_id, a2a_auth_token,
+         placeholder_ref, progress_ref, progress_ref_claimed, owner_email, org_id, agent_name, agent_url, dedupe_key, a2a_task_id, a2a_auth_token,
          status, attempts, next_check_at, created_at, updated_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
       args: [
         id,
         input.integrationTaskId,
@@ -218,6 +317,8 @@ export async function insertA2AContinuation(input: {
         input.externalThreadId,
         payload,
         input.placeholderRef ?? null,
+        null,
+        0,
         input.ownerEmail,
         input.orgId ?? null,
         input.agentName,
@@ -232,7 +333,6 @@ export async function insertA2AContinuation(input: {
         now,
       ],
     });
-    return (await getA2AContinuation(id))!;
   } catch (err: any) {
     if (!isDuplicateContinuationError(err)) throw err;
     const existing = await findA2AContinuation(
@@ -240,7 +340,65 @@ export async function insertA2AContinuation(input: {
       input.agentUrl,
       input.a2aTaskId,
     );
-    if (existing) return existing;
+    if (existing) {
+      // A retry can reach this row after the original invocation created it
+      // without a resumable progress surface (or with one that has gone
+      // stale). Keep the most recent valid adapter reference for active work,
+      // but never resurrect short-lived delivery state after a terminal row
+      // has deliberately scrubbed it.
+      if (
+        progressRef &&
+        existing.status !== "completed" &&
+        existing.status !== "failed"
+      ) {
+        if (existing.progressRefClaimed) {
+          if (JSON.stringify(existing.progressRef) !== progressRef) {
+            await client.execute({
+              sql: `UPDATE integration_a2a_continuations
+                    SET progress_ref = ?, updated_at = ?
+                    WHERE id = ? AND status NOT IN ('completed', 'failed')
+                      AND progress_ref_claimed = 1
+                      AND (progress_ref IS NULL OR progress_ref <> ?)`,
+              args: [progressRef, now, existing.id, progressRef],
+            });
+          }
+        } else {
+          await claimA2AContinuationProgressRef(existing.id, progressRef);
+        }
+        return (await getA2AContinuation(existing.id)) ?? existing;
+      }
+      return existing;
+    }
+    throw err;
+  }
+
+  if (progressRef) {
+    await claimA2AContinuationProgressRef(id, progressRef);
+  }
+  return (await getA2AContinuation(id))!;
+}
+
+/**
+ * A native platform stream has one terminal completion. Claim it for a single
+ * downstream continuation, and retain the ownership marker after terminal
+ * cleanup scrubs the short-lived stream reference. The partial unique index
+ * makes concurrent downstream inserts safe across processes.
+ */
+async function claimA2AContinuationProgressRef(
+  id: string,
+  progressRef: string,
+): Promise<void> {
+  try {
+    await getDbExec().execute({
+      sql: `UPDATE integration_a2a_continuations
+            SET progress_ref = ?, progress_ref_claimed = 1
+            WHERE id = ? AND progress_ref_claimed = 0`,
+      args: [progressRef, id],
+    });
+  } catch (err) {
+    // A sibling continuation already owns this stream and will finalize it.
+    // This continuation still delivers through the normal response path.
+    if (isDuplicateContinuationError(err)) return;
     throw err;
   }
 }
@@ -462,7 +620,7 @@ export async function completeA2AContinuation(id: string): Promise<void> {
   await client.execute({
     sql: `UPDATE integration_a2a_continuations
           SET status = ?, updated_at = ?, completed_at = ?,
-              incoming_payload = ?, a2a_auth_token = NULL
+              incoming_payload = ?, a2a_auth_token = NULL, progress_ref = NULL
           WHERE id = ? AND status IN ('processing', 'delivering', 'completed')`,
     args: ["completed", now, now, "{}", id],
   });
@@ -478,7 +636,7 @@ export async function failA2AContinuation(
   await client.execute({
     sql: `UPDATE integration_a2a_continuations
           SET status = ?, updated_at = ?, error_message = ?,
-              incoming_payload = ?, a2a_auth_token = NULL
+              incoming_payload = ?, a2a_auth_token = NULL, progress_ref = NULL
           WHERE id = ? AND status <> 'completed'`,
     args: ["failed", now, errorMessage.slice(0, 2000), "{}", id],
   });

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

@@ -22,6 +22,7 @@ import type {
   IntegrationStatus,
   OutboundTarget,
   PlatformRunProgress,
+  PlatformRunProgressRef,
   IntegrationContextMessage,
   IntegrationFileReference,
 } from "../types.js";
@@ -359,6 +360,16 @@ export function slackAdapter(
       return startSlackRunProgress(token, incoming);
     },
 
+    async resumeRunProgress(
+      incoming: IncomingMessage,
+      ref: PlatformRunProgressRef,
+    ): Promise<PlatformRunProgress | null> {
+      if (!isSlackStreamProgressRef(ref)) return null;
+      const token = await resolveBotToken(incoming);
+      if (!token) return null;
+      return resumeSlackRunProgress(token, incoming, ref.streamTs);
+    },
+
     async sendResponse(
       message: OutgoingMessage,
       context: IncomingMessage,
@@ -1273,6 +1284,21 @@ async function postSlackJson(
   return data;
 }
 
+function streamFailureCode(error: unknown): string {
+  const message = error instanceof Error ? error.message.trim() : "";
+  return /^[a-z0-9_:-]{1,80}$/i.test(message) ? message : "unknown";
+}
+
+function streamChunkType(chunk: Record<string, unknown>): string {
+  const type = chunk.type;
+  return type === "task_update" ||
+    type === "plan_update" ||
+    type === "markdown_text" ||
+    type === "blocks"
+    ? type
+    : "unknown";
+}
+
 async function startSlackRunProgress(
   token: string,
   incoming: IncomingMessage,
@@ -1304,12 +1330,45 @@ async function startSlackRunProgress(
         },
       ],
     });
-  } catch {
+  } catch (error) {
+    console.warn("[slack] chat.startStream failed; using standard reply", {
+      errorCode: streamFailureCode(error),
+      isDirectMessage: incoming.conversationType === "dm",
+      hasRecipientTeam: Boolean(incoming.tenantId),
+      hasRecipientUser: Boolean(incoming.senderId),
+    });
     return null;
   }
 
   const streamTs = started.ts;
   if (typeof streamTs !== "string") return null;
+  return createSlackRunProgress(token, incoming, channel, threadTs, streamTs);
+}
+
+function isSlackStreamProgressRef(ref: PlatformRunProgressRef): boolean {
+  return (
+    ref.kind === "slack-stream" && /^\d{1,20}\.\d{1,9}$/.test(ref.streamTs)
+  );
+}
+
+async function resumeSlackRunProgress(
+  token: string,
+  incoming: IncomingMessage,
+  streamTs: string,
+): Promise<PlatformRunProgress | null> {
+  const channel = incoming.platformContext.channelId;
+  const threadTs = incoming.platformContext.threadTs;
+  if (typeof channel !== "string" || typeof threadTs !== "string") return null;
+  return createSlackRunProgress(token, incoming, channel, threadTs, streamTs);
+}
+
+function createSlackRunProgress(
+  token: string,
+  incoming: IncomingMessage,
+  channel: string,
+  threadTs: string,
+  streamTs: string,
+): PlatformRunProgress {
   const tasks = new Map<string, { title: string; status: string }>();
   const toolTaskIds = new Map<string, string>();
   const agentTaskIds = new Map<string, string>();
@@ -1328,12 +1387,22 @@ async function startSlackRunProgress(
     const now = Date.now();
     const write = async (value: Record<string, unknown>) => {
       lastWriteAt = Date.now();
-      await postSlackJson(token, "chat.appendStream", {
-        channel,
-        ts: streamTs,
-        markdown_text: "Progress updated.",
-        chunks: [value],
-      }).catch(() => {});
+      try {
+        await postSlackJson(token, "chat.appendStream", {
+          channel,
+          ts: streamTs,
+          markdown_text: "Progress updated.",
+          chunks: [value],
+        });
+      } catch (error) {
+        console.warn(
+          "[slack] chat.appendStream failed; progress may be stale",
+          {
+            chunkType: streamChunkType(value),
+            errorCode: streamFailureCode(error),
+          },
+        );
+      }
     };
     if (now - lastWriteAt >= 900) {
       await write(chunk);
@@ -1357,6 +1426,7 @@ async function startSlackRunProgress(
     `${prefix}:${explicit || ++sequence}`.slice(0, 240);
 
   return {
+    ref: { kind: "slack-stream", streamTs },
     async onEvent(event) {
       if (!cancelControl) {
         const context = getIntegrationRequestContext();

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

@@ -181,6 +181,12 @@ export interface PlatformAdapterCapabilities {
 }
 
 export interface PlatformRunProgress {
+  /**
+   * Opaque, provider-owned reference for resuming this progress surface from a
+   * durable continuation. It deliberately contains no user content,
+   * credentials, or provider payload.
+   */
+  ref?: PlatformRunProgressRef;
   /** Receive normalized agent events. Implementations should throttle writes. */
   onEvent(event: AgentChatEvent): Promise<void> | void;
   /** Finalize the provider-native progress surface with the answer. */
@@ -189,6 +195,19 @@ export interface PlatformRunProgress {
   fail?(message: string): Promise<void>;
 }
 
+/**
+ * Safe, minimal reference to a provider-native run-progress surface.
+ *
+ * The field values are opaque to the framework. Adapters may use `kind` to
+ * distinguish their own resume strategy and `streamTs` to identify the
+ * provider-side stream. No incoming message text, platform payload, or
+ * credential belongs here.
+ */
+export interface PlatformRunProgressRef {
+  kind: string;
+  streamTs: string;
+}
+
 export interface ImmediateWebhookResponse {
   status: number;
   body: unknown;
@@ -304,6 +323,17 @@ export interface PlatformAdapter {
     incoming: IncomingMessage,
   ): Promise<PlatformRunProgress | null>;
 
+  /**
+   * Reattach a durable continuation to a provider-native progress surface
+   * previously started by this adapter. Adapters that cannot resume a native
+   * surface should omit this and the continuation will use its normal reply
+   * path instead.
+   */
+  resumeRunProgress?(
+    incoming: IncomingMessage,
+    ref: PlatformRunProgressRef,
+  ): Promise<PlatformRunProgress | null>;
+
   /**
    * Send a proactive outbound message to a platform destination. Adapters that
    * only support direct replies can omit this.

package/corpus/core/src/integrations/webhook-handler.ts

@@ -796,6 +796,7 @@ async function processIncomingMessage(
                   attempts: opts.attempts,
                   incoming,
                   placeholderRef: opts.placeholderRef,
+                  progressRef: progress?.ref,
                   scopeId: incoming.integrationScopeId,
                   principalType: opts.principalType ?? "user",
                   lineage: {
@@ -872,8 +873,9 @@ async function processIncomingMessage(
       },
       async (completedRun: ActiveRun) => {
         let keepSlackInputWindow = false;
+        let queuedA2AContinuation = false;
         try {
-          const queuedA2AContinuation = hasQueuedA2AContinuation(completedRun);
+          queuedA2AContinuation = hasQueuedA2AContinuation(completedRun);
           const slackInputRequest =
             incoming.platform === "slack"
               ? extractSlackInputRequest(completedRun)
@@ -963,7 +965,15 @@ async function processIncomingMessage(
               threadDeepLinkUrl,
             });
             let delivered = false;
-            if (progress) {
+            if (queuedA2AContinuation && progress?.ref) {
+              // Post substantive parent results as a normal thread reply while
+              // the one continuation that claimed this resumable stream keeps
+              // it open for its eventual terminal result.
+              await adapter.sendResponse(outgoing, incoming, {
+                placeholderRef: opts.placeholderRef,
+              });
+              delivered = true;
+            } else if (progress) {
               try {
                 await progress.complete(outgoing);
                 delivered = true;
@@ -988,24 +998,35 @@ async function processIncomingMessage(
               keepSlackInputWindow = true;
             }
           } else if (progress) {
-            // The downstream agent owns the eventual reply, but this parent
-            // integration run owns the native progress stream it opened. End
-            // that stream now so Slack does not leave an eternal task card;
-            // the continuation processor will post the final result into the
-            // same thread when the downstream task completes.
-            const deferred = adapter.formatAgentResponse(
-              "The delegated agent is still working. I’ll post its final result in this thread automatically.",
-            );
-            try {
-              await progress.complete(deferred);
-            } catch {
-              // A failed complete must still terminate a provider-native
-              // stream when the adapter offers a failure lifecycle. Do not
-              // duplicate the deferred text as a regular reply: a later
-              // continuation delivery is authoritative.
-              await progress.fail?.(
+            // A continuation owns the eventual final response. If the adapter
+            // supplied a durable progress reference, leave the same native
+            // stream open for the continuation processor to update and close;
+            // ending it here discards the plan/task UI before the delegated
+            // work has actually finished.
+            if (progress.ref) {
+              await progress.onEvent({
+                type: "agent_call_progress",
+                agent:
+                  getQueuedA2AContinuationAgent(completedRun) ??
+                  "delegated agent",
+                state: "working",
+                elapsedSeconds: 0,
+                detail: "Continuing in the background",
+              });
+            } else {
+              // Older adapters have no resumable native surface. Close their
+              // stream cleanly; the continuation will deliver one standard
+              // final reply when the downstream task is terminal.
+              const deferred = adapter.formatAgentResponse(
                 "The delegated agent is still working. I’ll post its final result in this thread automatically.",
               );
+              try {
+                await progress.complete(deferred);
+              } catch {
+                await progress.fail?.(
+                  "The delegated agent is still working. I’ll post its final result in this thread automatically.",
+                );
+              }
             }
           }
 
@@ -1036,6 +1057,10 @@ async function processIncomingMessage(
             `[integrations] Error sending response to ${incoming.platform}:`,
             err,
           );
+          // A queued continuation owns the final platform response. Later
+          // bookkeeping failures (for example, persisting this parent run)
+          // must not close its resumable native stream with a false failure.
+          if (queuedA2AContinuation) return;
           // Last-ditch: try to post a brief apology so the thread isn't silent.
           try {
             await progress?.fail?.(
@@ -1322,6 +1347,17 @@ function hasQueuedA2AContinuation(completedRun: ActiveRun): boolean {
   });
 }
 
+function getQueuedA2AContinuationAgent(completedRun: ActiveRun): string | null {
+  for (let i = completedRun.events.length - 1; i >= 0; i--) {
+    const event = completedRun.events[i]!.event;
+    if (event.type !== "agent_call") continue;
+    if (typeof event.agent === "string" && event.agent.trim()) {
+      return event.agent;
+    }
+  }
+  return null;
+}
+
 function extractSlackInputRequest(
   completedRun: ActiveRun,
 ): { text: string } | null {

package/corpus/core/src/scripts/call-agent.ts

@@ -427,6 +427,7 @@ async function enqueueIntegrationContinuationIfPossible(
       externalThreadId: integration.incoming.externalThreadId,
       incoming: integration.incoming,
       placeholderRef: integration.placeholderRef,
+      progressRef: integration.progressRef,
       ownerEmail,
       orgId: getRequestOrgId() ?? null,
       agentName: agent.name,

package/corpus/core/src/server/request-context.ts

@@ -164,6 +164,8 @@ export interface RequestContext {
     attempts?: number;
     incoming: import("../integrations/types.js").IncomingMessage;
     placeholderRef?: string;
+    /** Opaque provider-native progress surface for a durable continuation. */
+    progressRef?: import("../integrations/types.js").PlatformRunProgressRef;
     installationId?: string;
     scopeId?: string;
     principalType?: "user" | "service";

package/dist/a2a/artifact-response.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"artifact-response.d.ts","sourceRoot":"","sources":["../../src/a2a/artifact-response.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,0BAA0B;IACzC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,0BAA0B,CAAC,EAAE,OAAO,CAAC;CACtC;AAo8BD,wBAAgB,sBAAsB,CACpC,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,oBAAoB,EAAE,EACnC,OAAO,GAAE,0BAA+B,GACvC,MAAM,CAsIR;AAED,wBAAgB,kCAAkC,CAChD,WAAW,EAAE,oBAAoB,EAAE,EACnC,OAAO,GAAE,0BAA+B,GACvC,MAAM,GAAG,IAAI,CA8Bf"}
+{"version":3,"file":"artifact-response.d.ts","sourceRoot":"","sources":["../../src/a2a/artifact-response.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,0BAA0B;IACzC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,0BAA0B,CAAC,EAAE,OAAO,CAAC;CACtC;AA6lCD,wBAAgB,sBAAsB,CACpC,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,oBAAoB,EAAE,EACnC,OAAO,GAAE,0BAA+B,GACvC,MAAM,CAsIR;AAED,wBAAgB,kCAAkC,CAChD,WAAW,EAAE,oBAAoB,EAAE,EACnC,OAAO,GAAE,0BAA+B,GACvC,MAAM,GAAG,IAAI,CA8Bf"}