@agent-native/core 0.94.2 → 0.95.0

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/corpus/core/src/usage/store.ts

@@ -197,6 +197,8 @@ export interface UsageRecord {
    * provider-reported dollar cost so two surfaces agree exactly.
    */
   costCentsX100?: number;
+  /** Whether cost is provider-reported, estimated, or unavailable. */
+  costSource?: UsageCostSource;
   orgId?: string;
   runId?: string;
   threadId?: string;
@@ -206,6 +208,8 @@ export interface UsageRecord {
   sourceId?: string;
 }
 
+export type UsageCostSource = "reported" | "estimated" | "unavailable";
+
 let _initPromise: Promise<void> | undefined;
 
 async function ensureUsageTable(): Promise<void> {
@@ -221,6 +225,7 @@ async function ensureUsageTable(): Promise<void> {
           cache_read_tokens ${intType()} NOT NULL DEFAULT 0,
           cache_write_tokens ${intType()} NOT NULL DEFAULT 0,
           cost_cents_x100 ${intType()} NOT NULL DEFAULT 0,
+          cost_source TEXT NOT NULL DEFAULT 'estimated',
           model TEXT NOT NULL DEFAULT '',
           label TEXT NOT NULL DEFAULT 'chat',
           app TEXT NOT NULL DEFAULT '',
@@ -240,6 +245,7 @@ async function ensureUsageTable(): Promise<void> {
       const additions: Array<[string, string]> = [
         ["cache_read_tokens", `${intType()} NOT NULL DEFAULT 0`],
         ["cache_write_tokens", `${intType()} NOT NULL DEFAULT 0`],
+        ["cost_source", `TEXT NOT NULL DEFAULT 'estimated'`],
         ["label", `TEXT NOT NULL DEFAULT 'chat'`],
         ["app", `TEXT NOT NULL DEFAULT ''`],
         ["ref_id", `TEXT NOT NULL DEFAULT ''`],
@@ -379,6 +385,7 @@ export async function recordUsage(
     app,
     refId,
     costCentsX100,
+    costSource,
     orgId,
     runId,
     threadId,
@@ -410,14 +417,24 @@ export async function recordUsage(
 
   // Prefer an explicit precomputed cost (e.g. a provider-reported dollar cost);
   // otherwise derive it from tokens via the pricing table.
+  const resolvedCostSource =
+    costSource ?? (costCentsX100 == null ? "estimated" : "reported");
   const costX100 =
-    costCentsX100 ??
-    calculateCost(inTok, outTok, modelName, cacheReadTokens, cacheWriteTokens);
+    resolvedCostSource === "unavailable"
+      ? 0
+      : (costCentsX100 ??
+        calculateCost(
+          inTok,
+          outTok,
+          modelName,
+          cacheReadTokens,
+          cacheWriteTokens,
+        ));
   const id = Date.now() * 1000 + Math.floor(Math.random() * 1000);
   await client.execute({
     sql: `INSERT INTO token_usage
-      (id, owner_email, input_tokens, output_tokens, cache_read_tokens, cache_write_tokens, cost_cents_x100, model, label, app, ref_id, org_id, run_id, thread_id, task_id, integration_scope_id, source_platform, source_id, created_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      (id, owner_email, input_tokens, output_tokens, cache_read_tokens, cache_write_tokens, cost_cents_x100, cost_source, model, label, app, ref_id, org_id, run_id, thread_id, task_id, integration_scope_id, source_platform, source_id, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
     args: [
       id,
       ownerEmail,
@@ -426,6 +443,7 @@ export async function recordUsage(
       cacheReadTokens,
       cacheWriteTokens,
       costX100,
+      resolvedCostSource,
       modelName,
       resolvedLabel,
       resolvedApp,
@@ -469,6 +487,7 @@ export interface UsageBucket {
   cacheReadTokens: number;
   cacheWriteTokens: number;
   cents: number;
+  cost: UsageCostAggregate;
   calls: number;
 }
 
@@ -476,9 +495,15 @@ export interface DailyBucket {
   /** YYYY-MM-DD (UTC) */
   date: string;
   cents: number;
+  cost: UsageCostAggregate;
   calls: number;
 }
 
+export type UsageCostAggregate =
+  | { status: "known"; knownCents: number; unavailableCalls: 0 }
+  | { status: "partial"; knownCents: number; unavailableCalls: number }
+  | { status: "unavailable"; knownCents: 0; unavailableCalls: number };
+
 export interface UsageRecentEntry {
   id: number;
   createdAt: number;
@@ -490,11 +515,14 @@ export interface UsageRecentEntry {
   cacheReadTokens: number;
   cacheWriteTokens: number;
   cents: number;
+  costSource: UsageCostSource;
 }
 
 export interface UsageSummary {
   billing?: UsageBillingMode;
+  /** Legacy known-cost subtotal. Use totalCost to preserve unavailable spend. */
   totalCents: number;
+  totalCost: UsageCostAggregate;
   totalCalls: number;
   totalInputTokens: number;
   totalOutputTokens: number;
@@ -523,7 +551,8 @@ export async function getUsageSummary(
 
   const totalRow = await client.execute({
     sql: `SELECT
-      COALESCE(SUM(cost_cents_x100), 0) AS cents,
+      COALESCE(SUM(CASE WHEN cost_source = 'unavailable' THEN 0 ELSE cost_cents_x100 END), 0) AS known_cents,
+      COALESCE(SUM(CASE WHEN cost_source = 'unavailable' THEN 1 ELSE 0 END), 0) AS unavailable_calls,
       COUNT(*) AS calls,
       COALESCE(SUM(input_tokens), 0) AS in_tok,
       COALESCE(SUM(output_tokens), 0) AS out_tok,
@@ -536,7 +565,8 @@ export async function getUsageSummary(
 
   const bucketSql = (col: string) => ({
     sql: `SELECT ${col} AS k,
-        COALESCE(SUM(cost_cents_x100), 0) AS cents,
+        COALESCE(SUM(CASE WHEN cost_source = 'unavailable' THEN 0 ELSE cost_cents_x100 END), 0) AS known_cents,
+        COALESCE(SUM(CASE WHEN cost_source = 'unavailable' THEN 1 ELSE 0 END), 0) AS unavailable_calls,
         COUNT(*) AS calls,
         COALESCE(SUM(input_tokens), 0) AS in_tok,
         COALESCE(SUM(output_tokens), 0) AS out_tok,
@@ -545,16 +575,19 @@ export async function getUsageSummary(
       FROM token_usage
       WHERE owner_email = ? AND created_at >= ?
       GROUP BY ${col}
-      ORDER BY cents DESC`,
+      ORDER BY known_cents DESC`,
     args: [options.ownerEmail, sinceMs],
   });
 
   const mapBuckets = (rows: unknown[]): UsageBucket[] =>
     rows.map((r) => {
       const row = r as Record<string, number | string | null>;
+      const knownCents = Number(row.known_cents ?? 0) / 100;
+      const unavailableCalls = Number(row.unavailable_calls ?? 0);
       return {
         key: String(row.k ?? ""),
-        cents: Number(row.cents ?? 0) / 100,
+        cents: knownCents,
+        cost: buildUsageCostAggregate(knownCents, unavailableCalls),
         calls: Number(row.calls ?? 0),
         inputTokens: Number(row.in_tok ?? 0),
         outputTokens: Number(row.out_tok ?? 0),
@@ -573,30 +606,42 @@ export async function getUsageSummary(
   // date functions (SQLite `strftime`, Postgres `to_char`). Cheap enough
   // for a 30-day window; if this grows, swap for a dialect-aware query.
   const dayRows = await client.execute({
-    sql: `SELECT created_at, cost_cents_x100 FROM token_usage
+    sql: `SELECT created_at, cost_cents_x100, cost_source FROM token_usage
       WHERE owner_email = ? AND created_at >= ?`,
     args: [options.ownerEmail, sinceMs],
   });
-  const dayMap = new Map<string, { cents: number; calls: number }>();
-  for (const row of dayRows.rows as Array<Record<string, number>>) {
+  const dayMap = new Map<
+    string,
+    { knownCentsX100: number; unavailableCalls: number; calls: number }
+  >();
+  for (const row of dayRows.rows as Array<Record<string, number | string>>) {
     const date = new Date(Number(row.created_at)).toISOString().slice(0, 10);
-    const prev = dayMap.get(date) ?? { cents: 0, calls: 0 };
-    prev.cents += Number(row.cost_cents_x100 ?? 0);
+    const prev = dayMap.get(date) ?? {
+      knownCentsX100: 0,
+      unavailableCalls: 0,
+      calls: 0,
+    };
+    if (row.cost_source === "unavailable") prev.unavailableCalls += 1;
+    else prev.knownCentsX100 += Number(row.cost_cents_x100 ?? 0);
     prev.calls += 1;
     dayMap.set(date, prev);
   }
   const byDay: DailyBucket[] = [...dayMap.entries()]
-    .map(([date, v]) => ({
-      date,
-      cents: v.cents / 100,
-      calls: v.calls,
-    }))
+    .map(([date, v]) => {
+      const knownCents = v.knownCentsX100 / 100;
+      return {
+        date,
+        cents: knownCents,
+        cost: buildUsageCostAggregate(knownCents, v.unavailableCalls),
+        calls: v.calls,
+      };
+    })
     .sort((a, b) => a.date.localeCompare(b.date));
 
   const recentRows = await client.execute({
     sql: `SELECT id, created_at, label, app, model,
         input_tokens, output_tokens, cache_read_tokens, cache_write_tokens,
-        cost_cents_x100
+        cost_cents_x100, cost_source
       FROM token_usage
       WHERE owner_email = ?
       ORDER BY created_at DESC
@@ -616,11 +661,15 @@ export async function getUsageSummary(
     cacheReadTokens: Number(row.cache_read_tokens ?? 0),
     cacheWriteTokens: Number(row.cache_write_tokens ?? 0),
     cents: Number(row.cost_cents_x100 ?? 0) / 100,
+    costSource: String(row.cost_source ?? "estimated") as UsageCostSource,
   }));
 
+  const knownCents = Number(t.known_cents ?? 0) / 100;
+  const unavailableCalls = Number(t.unavailable_calls ?? 0);
   return {
     billing: USD_USAGE_BILLING,
-    totalCents: Number(t.cents ?? 0) / 100,
+    totalCents: knownCents,
+    totalCost: buildUsageCostAggregate(knownCents, unavailableCalls),
     totalCalls: Number(t.calls ?? 0),
     totalInputTokens: Number(t.in_tok ?? 0),
     totalOutputTokens: Number(t.out_tok ?? 0),
@@ -634,3 +683,16 @@ export async function getUsageSummary(
     recent,
   };
 }
+
+function buildUsageCostAggregate(
+  knownCents: number,
+  unavailableCalls: number,
+): UsageCostAggregate {
+  if (unavailableCalls === 0) {
+    return { status: "known", knownCents, unavailableCalls: 0 };
+  }
+  if (knownCents === 0) {
+    return { status: "unavailable", knownCents: 0, unavailableCalls };
+  }
+  return { status: "partial", knownCents, unavailableCalls };
+}

package/corpus/templates/plan/actions/record-recap-usage-cost.ts

@@ -0,0 +1,49 @@
+export type RecapUsageCostSource = "reported" | "estimated" | "unavailable";
+
+export interface RecapUsageCostInput {
+  agent?: "claude" | "codex" | "openai-compatible";
+  model: string;
+  inputTokens: number;
+  outputTokens: number;
+  cacheReadTokens: number;
+  cacheWriteTokens: number;
+  reportedCostUsd?: number;
+}
+
+type CostEstimator = (
+  inputTokens: number,
+  outputTokens: number,
+  model: string,
+  cacheReadTokens: number,
+  cacheWriteTokens: number,
+) => number;
+
+export function resolveRecapUsageCost(
+  input: RecapUsageCostInput,
+  estimateCost?: CostEstimator,
+): { costCentsX100: number | null; costSource: RecapUsageCostSource } {
+  if (input.reportedCostUsd != null) {
+    return {
+      costCentsX100: Math.max(1, Math.round(input.reportedCostUsd * 10_000)),
+      costSource: "reported",
+    };
+  }
+  if (input.agent === "openai-compatible") {
+    return { costCentsX100: null, costSource: "unavailable" };
+  }
+  if (!estimateCost) {
+    throw new Error(
+      "A cost estimator is required for standard recap backends.",
+    );
+  }
+  return {
+    costCentsX100: estimateCost(
+      input.inputTokens,
+      input.outputTokens,
+      input.model,
+      input.cacheReadTokens,
+      input.cacheWriteTokens,
+    ),
+    costSource: "estimated",
+  };
+}

package/corpus/templates/plan/actions/record-recap-usage.ts

@@ -5,11 +5,12 @@ import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
 import { assertPlanEditor, nowIso } from "../server/plans.js";
+import { resolveRecapUsageCost } from "./record-recap-usage-cost.js";
 
 /**
- * Attach token usage + a derived cost estimate to an existing recap, keyed by
+ * Attach token usage and an honest cost state to an existing recap, keyed by
  * plan id. The PR Visual Recap workflow calls this AFTER the coding agent
- * (Claude Code / Codex) exits — the recap is created mid-run, before the run's
+ * (Claude Code / Codex / OpenAI-compatible Agent-Native Code) exits — the recap is created mid-run, before the run's
  * own token total exists, so usage can't ride along with create-visual-recap.
  *
  * Internal by design: no `publicAgent`, so it is NOT advertised as an MCP tool
@@ -24,11 +25,11 @@ import { assertPlanEditor, nowIso } from "../server/plans.js";
  */
 export default defineAction({
   description:
-    "Record the LLM token usage and derived cost for a recap, keyed by plan id. Internal mechanic used by the PR Visual Recap workflow after the agent run finishes; not an agent-facing tool.",
+    "Record LLM token usage and reported or estimated cost when available for a recap, keyed by plan id. Internal mechanic used by the PR Visual Recap workflow after the agent run finishes; not an agent-facing tool.",
   agentTool: false,
   schema: z.object({
     planId: z.string().min(1),
-    agent: z.enum(["claude", "codex"]).optional(),
+    agent: z.enum(["claude", "codex", "openai-compatible"]).optional(),
     model: z.string().min(1),
     // Token counts must already be normalized to the cache-exclusive shape
     // calculateCost expects (the recap CLI strips Codex's cached_input_tokens
@@ -37,7 +38,8 @@ export default defineAction({
     outputTokens: z.number().int().nonnegative(),
     cacheReadTokens: z.number().int().nonnegative().default(0),
     cacheWriteTokens: z.number().int().nonnegative().default(0),
-    // Claude Code reports a real dollar cost (total_cost_usd); Codex does not.
+    // Claude Code reports a real dollar cost; Codex and compatible providers
+    // generally provide tokens only.
     reportedCostUsd: z.number().nonnegative().optional(),
   }),
   run: async (args) => {
@@ -54,18 +56,10 @@ export default defineAction({
       .limit(1);
     if (!row) throw new Error(`Plan ${args.planId} not found`);
 
-    // Prefer the agent's reported dollar cost; otherwise estimate from tokens.
-    const reported = args.reportedCostUsd != null;
-    const costCentsX100 = reported
-      ? Math.max(1, Math.round(args.reportedCostUsd! * 10_000)) // USD → centicents
-      : calculateCost(
-          args.inputTokens,
-          args.outputTokens,
-          args.model,
-          args.cacheReadTokens,
-          args.cacheWriteTokens,
-        );
-    const costSource = reported ? "reported" : "estimated";
+    const { costCentsX100, costSource } = resolveRecapUsageCost(
+      args,
+      calculateCost,
+    );
     const recordedAt = nowIso();
 
     await db
@@ -84,10 +78,8 @@ export default defineAction({
       })
       .where(eq(schema.plans.id, args.planId));
 
-    // Mirror into the shared token_usage table so recap spend shows up in the
-    // existing Usage admin panel + cross-app aggregation. refId = plan id makes
-    // it idempotent on re-push; costCentsX100 carries the exact figure stored on
-    // the plan row (reported when available) so the two surfaces agree.
+    // Mirror tokens into the shared usage table. Unknown compatible-provider
+    // prices remain explicitly unavailable instead of inheriting a generic rate.
     await recordUsage({
       ownerEmail: row.ownerEmail,
       inputTokens: args.inputTokens,
@@ -98,7 +90,8 @@ export default defineAction({
       label: "visual-recap",
       app: "plan",
       refId: args.planId,
-      costCentsX100,
+      costCentsX100: costCentsX100 ?? undefined,
+      costSource,
     });
 
     return { planId: args.planId, costCentsX100, costSource };

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"}