@tangle-network/agent-gateway 0.5.0 → 0.7.0

package/dist/chunk-3IKQWFKX.js

@@ -0,0 +1,1703 @@
+import {
+  MemoryNonceStore
+} from "./chunk-M7ZJAK4K.js";
+import {
+  MemoryRateLimitStore,
+  checkRateLimit
+} from "./chunk-XCTXHZ76.js";
+
+// src/middleware.ts
+import { Hono } from "hono";
+
+// src/filter.ts
+var INJECTION_PATTERNS = [
+  // Direct instruction override
+  /ignore\s+(all\s+)?(previous|prior|above|earlier)\s+(instructions?|prompts?|rules?|directives?)/i,
+  /disregard\s+(all\s+)?(previous|prior|system)/i,
+  /forget\s+(everything|all|your)\s+(previous|instructions?|training)/i,
+  // Role assumption
+  /you\s+are\s+now\s+(a|an|the)\s+/i,
+  /pretend\s+(you\s+are|to\s+be)\s+/i,
+  /act\s+as\s+(if\s+you\s+are|a|an|the)\s+/i,
+  /new\s+instructions?:/i,
+  /\[system\]/i,
+  /\[INST\]/i,
+  // Prompt extraction
+  /what\s+(is|are)\s+your\s+(system\s+)?(prompt|instructions?|rules?|directives?)/i,
+  /repeat\s+(your|the)\s+(system\s+)?(prompt|instructions?)/i,
+  /output\s+(your|the)\s+((system|initial|original|first|full|real|hidden|secret|raw|exact)\s+)?(prompt|instructions?)/i,
+  /show\s+(me\s+)?(your|the)\s+((system|hidden|secret|initial|original)\s+)?(prompt|instructions?|message|directives?)/i,
+  /tell\s+me\s+(your|the)\s+(system\s+)?(prompt|instructions?|rules?)/i,
+  // Developer/debug/admin/jailbreak mode override
+  /(developer|debug|admin|god|sudo|jailbreak|unrestricted|maintenance)\s+mode/i,
+  // Safety/safeguard disablement
+  /(disable|bypass|override|remove|turn\s+off)\s+(your\s+|the\s+)?(safety|safeguards?|guardrails?|filters?|restrictions?|rules?|limitations?|content\s+policy)/i,
+  // Role reversal
+  /(from\s+now\s+on|starting\s+now|now)\s+you('re|\s+are)\s+(the\s+)?(user|human|customer|assistant)/i,
+  /i('m|\s+am)\s+(the\s+)?(assistant|ai|model|llm|bot)/i,
+  // Tool-call / JSON-shaped spoofs
+  /"(?:tool|function|action|call)"\s*:\s*"[^"]*(exfiltrate|leak|reveal|dump|extract|steal)[^"]*"/i,
+  /exfiltrate[_\s]*(system|prompt|secret|vault|config|data)/i,
+  // Data exfiltration
+  /read\s+(the\s+)?(vault|workspace|config|secret|\.env)/i,
+  /cat\s+\/home\/agent\/(vault|config|\.env|secrets?)/i,
+  /list\s+(all\s+)?(vault|workspace|secret)\s+(files?|contents?|data)/i,
+  // i18n — Spanish
+  /ignor[ae]\s+(todas?\s+)?(las\s+)?(instrucciones?|indicaciones?|órdenes?)\s+(previas?|anteriores?)/i,
+  /olvid[ae]\s+(todas?\s+|tus\s+)?(instrucciones?|indicaciones?)/i,
+  /(ahora\s+)?(tú\s+)?eres\s+(ahora\s+)?(un|una|el|la)\s+/i,
+  /finge\s+(que\s+eres|ser)\s+/i,
+  // i18n — French
+  /ignor(ez|e|es)\s+(toutes?\s+)?(les\s+)?(instructions?|consignes?|directives?)\s+(précédentes?|antérieures?)/i,
+  /oublie(z|s)?\s+(toutes?\s+|vos\s+|tes\s+)?(instructions?|consignes?)/i,
+  /(vous\s+êtes|tu\s+es)\s+(maintenant|désormais)\s+(un|une)\s+/i,
+  /prétend(ez|s)?\s+(être|que\s+vous\s+êtes|que\s+tu\s+es)\s+/i,
+  // i18n — German
+  /ignorier(e|en|t)\s+(alle\s+)?(vorherigen?|vorigen?|bisherigen?)\s+(anweisungen|anordnungen|vorgaben)/i,
+  /vergiss\s+(alle\s+|deine\s+)?(anweisungen|vorgaben|regeln)/i,
+  /du\s+bist\s+(jetzt|nun)\s+(ein|eine)\s+/i,
+  /tu\s+so\s+als\s+(wärst\s+du|ob\s+du)\s+/i
+];
+var HOMOGLYPHS = {
+  "\u0430": "a",
+  "\u0435": "e",
+  "\u043E": "o",
+  "\u0440": "p",
+  "\u0441": "c",
+  "\u0443": "y",
+  "\u0445": "x",
+  "\u0456": "i",
+  "\u0458": "j",
+  "\u0455": "s",
+  "\u04BB": "h",
+  "\u0410": "A",
+  "\u0412": "B",
+  "\u0415": "E",
+  "\u041A": "K",
+  "\u041C": "M",
+  "\u041D": "H",
+  "\u041E": "O",
+  "\u0420": "P",
+  "\u0421": "C",
+  "\u0422": "T",
+  "\u0425": "X",
+  "\u0406": "I",
+  "\u0408": "J",
+  "\u0405": "S",
+  "\u03B1": "a",
+  "\u03B5": "e",
+  "\u03BF": "o",
+  "\u03C1": "p",
+  "\u03C5": "y",
+  "\u03BD": "v",
+  "\u03B9": "i",
+  "\u03C4": "t",
+  "\u03BA": "k",
+  "\u03C7": "x",
+  "\u03B7": "n",
+  "\u03BC": "u",
+  "\u0391": "A",
+  "\u0392": "B",
+  "\u0395": "E",
+  "\u0396": "Z",
+  "\u0397": "H",
+  "\u0399": "I",
+  "\u039A": "K",
+  "\u039C": "M",
+  "\u039D": "N",
+  "\u039F": "O",
+  "\u03A1": "P",
+  "\u03A4": "T",
+  "\u03A7": "X",
+  "\u03A5": "Y"
+};
+function collapseHomoglyphs(text) {
+  let out = "";
+  for (const ch of text) out += HOMOGLYPHS[ch] ?? ch;
+  return out;
+}
+function normalizeUnicode(text) {
+  return collapseHomoglyphs(
+    text.replace(/[\u200B-\u200F\u2028-\u202F\u2060\uFEFF]/g, "").normalize("NFKC")
+  );
+}
+function normalizeForDetection(text) {
+  const spaced = text.replace(/[\u200B\u200C\uFEFF]/g, " ").replace(/[\u200D\u200E\u200F\u2028-\u202F\u2060]/g, "").normalize("NFKC");
+  return collapseHomoglyphs(spaced).replace(/[(){}<>,.!?:;"`~]+/g, " ").replace(/\s+/g, " ");
+}
+function normalizeForDetectionNoBrackets(text) {
+  return normalizeForDetection(text).replace(/[\[\]]+/g, " ").replace(/\s+/g, " ");
+}
+function detectInjection(content) {
+  const stripNorm = normalizeUnicode(content);
+  const detectNorm = normalizeForDetection(content);
+  const noBracketNorm = normalizeForDetectionNoBrackets(content);
+  const matches = [];
+  for (const pattern of INJECTION_PATTERNS) {
+    if (pattern.test(stripNorm) || pattern.test(detectNorm) || pattern.test(noBracketNorm)) {
+      matches.push(pattern.source.slice(0, 60));
+    }
+  }
+  for (const norm of [stripNorm, detectNorm]) {
+    const b64Matches = norm.match(/[A-Za-z0-9+/]{40,}={0,2}/g);
+    if (!b64Matches) continue;
+    for (const b64 of b64Matches) {
+      try {
+        const decoded = atob(b64);
+        if (INJECTION_PATTERNS.some((p) => p.test(decoded))) {
+          if (!matches.includes("base64-encoded injection")) {
+            matches.push("base64-encoded injection");
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  return matches;
+}
+function filterConsumerMessages(messages, maxLength = 8e3) {
+  return messages.filter((m) => m.role !== "system").map((m) => {
+    const normalized = normalizeUnicode(m.content);
+    const redacted = normalized.replace(/\b(vault|workspace|owner|admin|secret|\.env|config\.json)[\s/:][^\s]*/gi, "[REDACTED]").slice(0, maxLength);
+    return { role: m.role, content: redacted };
+  });
+}
+function filterConsumerMessagesStrict(messages, maxLength = 8e3) {
+  const filtered = filterConsumerMessages(messages, maxLength);
+  const allContent = filtered.map((m) => m.content).join(" ");
+  const injectionWarnings = detectInjection(allContent);
+  return { messages: filtered, injectionWarnings };
+}
+function redactSystemPromptFromOutput(output, systemPrompt) {
+  if (!systemPrompt || systemPrompt.length < 40) return output;
+  const chunks = systemPrompt.split(/[.\n]/).map((s) => s.trim()).filter((s) => s.length >= 40);
+  let redacted = output;
+  for (const chunk of chunks) {
+    const idx = redacted.toLowerCase().indexOf(chunk.toLowerCase());
+    if (idx >= 0) {
+      redacted = redacted.slice(0, idx) + "[REDACTED \u2014 system instructions]" + redacted.slice(idx + chunk.length);
+    }
+  }
+  return redacted;
+}
+
+// src/observer.ts
+var ConsoleObserver = class {
+  constructor(log = (e) => console.log(JSON.stringify(e))) {
+    this.log = log;
+  }
+  log;
+  emit(level, event, ctx, rest = {}) {
+    this.log({
+      level,
+      event,
+      time: (/* @__PURE__ */ new Date()).toISOString(),
+      requestId: ctx.requestId,
+      agentSlug: ctx.agentSlug,
+      durationMs: Date.now() - ctx.startMs,
+      ...rest
+    });
+  }
+  onRequestStart(ctx) {
+    this.emit("info", "gateway.request.start", ctx);
+  }
+  onPaymentVerified(ctx, info) {
+    this.emit("info", "gateway.payment.verified", ctx, info);
+  }
+  onAuthFailure(ctx, reason) {
+    this.emit("warn", "gateway.auth.failure", ctx, reason);
+  }
+  onRateLimited(ctx, info) {
+    this.emit("warn", "gateway.rate_limit", ctx, info);
+  }
+  onBodyTooLarge(ctx, contentLength) {
+    this.emit("warn", "gateway.body_too_large", ctx, { contentLength });
+  }
+  onInjectionDetected(ctx, info) {
+    this.emit("warn", "gateway.injection", ctx, info);
+  }
+  onRequestComplete(ctx, usage) {
+    this.emit("info", "gateway.request.complete", ctx, usage);
+  }
+  onStreamError(ctx, info) {
+    this.emit("error", "gateway.stream.error", ctx, info);
+  }
+  onSettlementError(ctx, info) {
+    this.emit("error", "gateway.settlement.error", ctx, info);
+  }
+};
+var CompositeObserver = class {
+  constructor(observers) {
+    this.observers = observers;
+  }
+  observers;
+  async fanOut(event, ...args) {
+    for (const obs of this.observers) {
+      const fn = obs[event];
+      if (!fn) continue;
+      try {
+        await fn.apply(obs, args);
+      } catch (err) {
+        console.warn(`[agent-gateway] observer ${event} threw:`, err instanceof Error ? err.message : err);
+      }
+    }
+  }
+  onRequestStart = (ctx) => this.fanOut("onRequestStart", ctx);
+  onPaymentVerified = (ctx, info) => this.fanOut("onPaymentVerified", ctx, info);
+  onAuthFailure = (ctx, reason) => this.fanOut("onAuthFailure", ctx, reason);
+  onRateLimited = (ctx, info) => this.fanOut("onRateLimited", ctx, info);
+  onBodyTooLarge = (ctx, contentLength) => this.fanOut("onBodyTooLarge", ctx, contentLength);
+  onInjectionDetected = (ctx, info) => this.fanOut("onInjectionDetected", ctx, info);
+  onRequestComplete = (ctx, usage) => this.fanOut("onRequestComplete", ctx, usage);
+  onStreamError = (ctx, info) => this.fanOut("onStreamError", ctx, info);
+  onSettlementError = (ctx, info) => this.fanOut("onSettlementError", ctx, info);
+};
+function generateRequestId() {
+  const bytes = new Uint8Array(16);
+  globalThis.crypto.getRandomValues(bytes);
+  const hex = Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  return `req_${hex}`;
+}
+
+// src/verify.ts
+async function verifyX402(spendAuthHeader, config, nonceStore) {
+  try {
+    const raw = JSON.parse(spendAuthHeader);
+    if (!raw.commitment || !raw.signature || !raw.amount) return null;
+    if (raw.operator?.toLowerCase() !== config.operatorAddress.toLowerCase()) return null;
+    const amount = BigInt(raw.amount);
+    const nonce = BigInt(raw.nonce);
+    const expiry = BigInt(raw.expiry);
+    if (expiry < BigInt(Math.floor(Date.now() / 1e3))) return null;
+    if (amount <= 0n) return null;
+    const nonceKey = `${raw.commitment}:${nonce.toString()}`;
+    if (nonceStore) {
+      if (await nonceStore.hasSeen(nonceKey)) return null;
+      const ttl = Math.min(Number(expiry) - Math.floor(Date.now() / 1e3), 3600);
+      await nonceStore.markSeen(nonceKey, Math.max(ttl, 60));
+    }
+    if (config.verifySigner) {
+      const verified = await config.verifySigner(raw);
+      if (!verified) return null;
+    } else if (!config.demoMode) {
+      return null;
+    }
+    return raw.commitment;
+  } catch {
+    return null;
+  }
+}
+async function verifyMpp(authHeader, _config, x402Config) {
+  const match = authHeader.match(/^Payment\s+(\S+)\s+(\S+)$/i);
+  if (!match) return null;
+  const [, , credentialB64] = match;
+  try {
+    const decoded = Buffer.from(credentialB64, "base64url").toString("utf-8");
+    const credential = JSON.parse(decoded);
+    const payload = credential.payload ?? credential;
+    if (!payload.commitment && !payload.from) return null;
+    const operator = payload.operator ?? payload.to;
+    if (operator && operator.toLowerCase() !== x402Config.operatorAddress.toLowerCase()) return null;
+    if (payload.amount) BigInt(payload.amount);
+    if (payload.nonce) BigInt(payload.nonce);
+    return payload.commitment ?? payload.from ?? null;
+  } catch {
+    return null;
+  }
+}
+async function defaultVerifyApiKey(authHeader) {
+  if (!authHeader.startsWith("Bearer sk_agent_")) return null;
+  const key = authHeader.slice(7);
+  return {
+    keyId: key.slice(0, 16),
+    consumerId: `apikey:${key.slice(0, 16)}`
+  };
+}
+
+// src/dispatch.ts
+async function authenticateAndGuard(c, slug, messages, config, state) {
+  const startMs = Date.now();
+  const requestId = generateRequestId();
+  const ctx = { requestId, agentSlug: slug, startMs };
+  await state.obs?.onRequestStart?.(ctx);
+  const agent = await config.resolveAgent(slug);
+  if (!agent) {
+    return c.json({ error: { message: "Agent not found", type: "not_found" } }, 404);
+  }
+  if (!messages?.length) {
+    return c.json(
+      { error: { message: "messages array required", type: "invalid_request" } },
+      400
+    );
+  }
+  const spendAuthHeader = c.req.header("X-Payment-Signature");
+  const authHeader = c.req.header("Authorization") ?? "";
+  let consumerId = null;
+  let paymentMethod = "none";
+  let keyInfo = null;
+  if (spendAuthHeader) {
+    const signer = await verifyX402(spendAuthHeader, config.x402, state.nonceStore);
+    if (!signer) {
+      await state.obs?.onAuthFailure?.(ctx, {
+        method: "x402",
+        code: "invalid_spend_auth",
+        httpStatus: 402
+      });
+      return c.json(
+        {
+          error: {
+            message: "Invalid X-Payment-Signature",
+            type: "authentication_error",
+            code: "invalid_spend_auth"
+          }
+        },
+        {
+          status: 402,
+          headers: { "X-Payment-Required": "spendauth", "X-Request-Id": requestId }
+        }
+      );
+    }
+    consumerId = signer;
+    paymentMethod = "x402";
+  } else if (config.mpp && authHeader.toLowerCase().startsWith("payment ")) {
+    const signer = await verifyMpp(authHeader, config.mpp, config.x402);
+    if (!signer) {
+      const realm = config.mpp.realm;
+      const method = config.mpp.method ?? "blueprintevm";
+      await state.obs?.onAuthFailure?.(ctx, {
+        method: "mpp",
+        code: "invalid_mpp_credential",
+        httpStatus: 401
+      });
+      return c.json(
+        {
+          error: {
+            message: "Invalid Payment credential",
+            type: "authentication_error",
+            code: "invalid_mpp_credential"
+          }
+        },
+        {
+          status: 401,
+          headers: {
+            "WWW-Authenticate": `Payment realm="${realm}", method="${method}"`,
+            "X-Request-Id": requestId
+          }
+        }
+      );
+    }
+    consumerId = signer;
+    paymentMethod = "mpp";
+  } else if (authHeader.startsWith("Bearer ")) {
+    const verify = config.verifyApiKey ?? defaultVerifyApiKey;
+    const key = await verify(authHeader);
+    if (!key) {
+      await state.obs?.onAuthFailure?.(ctx, {
+        method: "apikey",
+        code: "invalid_api_key",
+        httpStatus: 401
+      });
+      return c.json(
+        { error: { message: "Invalid API key", type: "authentication_error" } },
+        { status: 401, headers: { "X-Request-Id": requestId } }
+      );
+    }
+    if (key.scopes && key.scopes.length > 0 && !key.scopes.includes(state.requiredScope)) {
+      await state.obs?.onAuthFailure?.(ctx, {
+        method: "apikey",
+        code: "insufficient_scope",
+        httpStatus: 403
+      });
+      return c.json(
+        {
+          error: {
+            message: `API key missing required scope: ${state.requiredScope}`,
+            type: "forbidden",
+            code: "insufficient_scope"
+          }
+        },
+        { status: 403, headers: { "X-Request-Id": requestId } }
+      );
+    }
+    consumerId = key.consumerId;
+    paymentMethod = "apikey";
+    keyInfo = key;
+  } else {
+    await state.obs?.onAuthFailure?.(ctx, {
+      method: "none",
+      code: "payment_required",
+      httpStatus: 402
+    });
+    const methods = ["x402"];
+    if (config.mpp) methods.push("mpp");
+    methods.push("api_key");
+    const headers = {
+      "X-Payment-Required": methods.join(", "),
+      "X-Request-Id": requestId
+    };
+    if (config.mpp) {
+      headers["WWW-Authenticate"] = `Payment realm="${config.mpp.realm}", method="${config.mpp.method ?? "blueprintevm"}"`;
+    }
+    return c.json(
+      {
+        error: {
+          message: "Payment required",
+          type: "payment_required",
+          payment_methods: methods,
+          x402: {
+            operator: config.x402.operatorAddress,
+            chain_id: config.x402.chainId,
+            credits_address: config.x402.creditsAddress,
+            estimated_amount_per_request: "20000"
+          },
+          ...config.mpp ? { mpp: { realm: config.mpp.realm, method: config.mpp.method ?? "blueprintevm" } } : {},
+          api_key: {
+            purchase_url: config.baseUrl ? `${config.baseUrl}/agents/${slug}/api-keys` : void 0
+          }
+        }
+      },
+      { status: 402, headers }
+    );
+  }
+  await state.obs?.onPaymentVerified?.(ctx, {
+    method: paymentMethod,
+    consumerId,
+    keyId: keyInfo?.keyId
+  });
+  const effectiveRateLimit = keyInfo?.rateLimitPerMinute ? { limit: keyInfo.rateLimitPerMinute, windowSeconds: 60 } : state.globalRateLimit;
+  const rl = await checkRateLimit(consumerId, effectiveRateLimit, state.rateLimitStore);
+  if (!rl.allowed) {
+    await state.obs?.onRateLimited?.(ctx, {
+      consumerId,
+      retryAfterSeconds: rl.retryAfterSeconds ?? 60
+    });
+    return c.json(
+      {
+        error: {
+          message: "Rate limit exceeded",
+          type: "rate_limit_error",
+          retry_after: rl.retryAfterSeconds
+        }
+      },
+      {
+        status: 429,
+        headers: {
+          "Retry-After": String(rl.retryAfterSeconds ?? 60),
+          "X-Request-Id": requestId
+        }
+      }
+    );
+  }
+  const { messages: filtered, injectionWarnings } = filterConsumerMessagesStrict(
+    messages,
+    state.maxLen
+  );
+  if (injectionWarnings.length > 0) {
+    await state.obs?.onInjectionDetected?.(ctx, {
+      consumerId,
+      patterns: injectionWarnings,
+      blocked: !!config.blockInjection
+    });
+    if (config.blockInjection) {
+      return c.json(
+        {
+          error: {
+            message: "Request rejected: potential prompt injection detected",
+            type: "content_policy_violation"
+          }
+        },
+        { status: 400, headers: { "X-Request-Id": requestId } }
+      );
+    }
+  }
+  const userMessage = filtered.filter((m) => m.role === "user").map((m) => m.content).join("\n\n");
+  if (!userMessage) {
+    return c.json(
+      { error: { message: "No user message provided", type: "invalid_request" } },
+      400
+    );
+  }
+  if (config.authorizeConsumer) {
+    const authz = await config.authorizeConsumer(agent, {
+      method: paymentMethod,
+      consumerId,
+      keyId: keyInfo?.keyId,
+      requestId
+    });
+    if (!authz.allow) {
+      return c.json(
+        {
+          error: {
+            message: authz.reason,
+            type: "authorization_denied",
+            code: authz.code
+          }
+        },
+        { status: 403, headers: { "X-Request-Id": requestId } }
+      );
+    }
+  }
+  return {
+    agent,
+    consumerId,
+    paymentMethod,
+    keyInfo,
+    userMessage,
+    rateLimitRemaining: rl.remaining,
+    requestId,
+    startMs
+  };
+}
+async function* dispatchSandboxStream(agent, userMessage, consumerId, config, signal, sessionId) {
+  for await (const event of dispatchSandboxStreamRich(
+    agent,
+    userMessage,
+    consumerId,
+    config,
+    signal,
+    sessionId
+  )) {
+    if (event.kind === "text") yield event.delta;
+  }
+}
+async function* dispatchSandboxStreamRich(agent, userMessage, consumerId, config, signal, sessionId) {
+  const box = await config.getSandbox(agent);
+  const promptStream = box.streamPrompt(userMessage, {
+    sessionId: sessionId ?? `consumer:${consumerId}`,
+    systemPrompt: agent.systemPrompt
+  });
+  for await (const event of promptStream) {
+    if (signal?.aborted) return;
+    if (event.type === "message.part.updated" && event.data?.part?.type === "text" && event.data.delta) {
+      yield {
+        kind: "text",
+        delta: redactSystemPromptFromOutput(event.data.delta, agent.systemPrompt)
+      };
+      continue;
+    }
+    if (event.type === "input-required" || event.data?.inputRequired) {
+      yield { kind: "input-required", prompt: event.data?.inputRequired?.prompt };
+      return;
+    }
+  }
+}
+async function settleAndRecord(agent, authz, inputTokens, outputTokens, config, obs) {
+  const totalCost = (inputTokens + outputTokens) * agent.pricePerTokenUsd;
+  const ownerEarned = totalCost * (1 - agent.platformFeePercent);
+  const platformFee = totalCost * agent.platformFeePercent;
+  const usageEvent = {
+    requestId: authz.requestId,
+    agentId: agent.id,
+    agentSlug: agent.slug,
+    consumerId: authz.consumerId,
+    paymentMethod: authz.paymentMethod,
+    inputTokens,
+    outputTokens,
+    totalCostUsd: totalCost,
+    ownerEarnedUsd: ownerEarned,
+    platformFeeUsd: platformFee,
+    durationMs: Date.now() - authz.startMs
+  };
+  await config.recordUsage(usageEvent);
+  const ctx = {
+    requestId: authz.requestId,
+    agentSlug: agent.slug,
+    startMs: authz.startMs
+  };
+  await obs?.onRequestComplete?.(ctx, usageEvent);
+  if (config.settlePayment) {
+    await config.settlePayment(
+      {
+        method: authz.paymentMethod,
+        consumerId: authz.consumerId,
+        requestId: authz.requestId
+      },
+      totalCost
+    ).catch(async (err) => {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`[agent-gateway] settlement failed for ${authz.consumerId}: ${msg}`);
+      await obs?.onSettlementError?.(ctx, {
+        consumerId: authz.consumerId,
+        method: authz.paymentMethod,
+        errorMessage: msg
+      });
+    });
+  }
+}
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+
+// src/a2a/agent-card.ts
+function buildAgentCard(agent, config, agentUrl) {
+  const schemes = ["x402"];
+  if (config.mpp) schemes.push("mpp");
+  schemes.push("Bearer");
+  const skills = agent.skills && agent.skills.length > 0 ? agent.skills : [
+    {
+      id: "chat",
+      name: agent.slug,
+      description: agent.description ?? `${agent.slug} agent`,
+      tags: ["chat"],
+      inputModes: ["text"],
+      outputModes: ["text"]
+    }
+  ];
+  return {
+    name: agent.slug,
+    description: agent.description ?? `${agent.slug} agent`,
+    url: agentUrl,
+    version: "1.0.0",
+    provider: { organization: "Tangle", url: "https://tangle.tools" },
+    capabilities: {
+      streaming: true,
+      pushNotifications: !!config.a2a?.pushStore,
+      stateTransitionHistory: false
+    },
+    authentication: { schemes },
+    defaultInputModes: ["text"],
+    defaultOutputModes: ["text"],
+    skills
+  };
+}
+
+// src/a2a/types.ts
+var A2A_ERROR_CODES = {
+  PARSE_ERROR: -32700,
+  INVALID_REQUEST: -32600,
+  METHOD_NOT_FOUND: -32601,
+  INVALID_PARAMS: -32602,
+  INTERNAL_ERROR: -32603,
+  TASK_NOT_FOUND: -32001,
+  TASK_NOT_CANCELABLE: -32002,
+  PUSH_NOT_SUPPORTED: -32003,
+  UNSUPPORTED_OPERATION: -32004,
+  CONTENT_TYPE_NOT_SUPPORTED: -32005,
+  INVALID_AGENT_RESPONSE: -32006,
+  AUTHENTICATED_EXTENDED_CARD_NOT_CONFIGURED: -32007
+};
+
+// src/a2a/jsonrpc.ts
+function parseEnvelope(raw) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    return {
+      id: null,
+      code: A2A_ERROR_CODES.INVALID_REQUEST,
+      message: "request must be a JSON object"
+    };
+  }
+  const req = raw;
+  const id = req.id === void 0 ? null : req.id;
+  if (req.jsonrpc !== "2.0") {
+    return { id, code: A2A_ERROR_CODES.INVALID_REQUEST, message: 'jsonrpc field must be "2.0"' };
+  }
+  if (typeof req.method !== "string" || req.method.length === 0) {
+    return { id, code: A2A_ERROR_CODES.INVALID_REQUEST, message: "method field required" };
+  }
+  return {
+    jsonrpc: "2.0",
+    id,
+    method: req.method,
+    params: req.params
+  };
+}
+function ok(id, result) {
+  return { jsonrpc: "2.0", id, result };
+}
+function fail(id, code, message, data) {
+  return {
+    jsonrpc: "2.0",
+    id,
+    error: { code, message, ...data !== void 0 ? { data } : {} }
+  };
+}
+
+// src/a2a/push-notifications.ts
+var InMemoryPushNotificationStore = class {
+  byTask = /* @__PURE__ */ new Map();
+  async set(taskId, config) {
+    let configs = this.byTask.get(taskId);
+    if (!configs) {
+      configs = /* @__PURE__ */ new Map();
+      this.byTask.set(taskId, configs);
+    }
+    configs.set(config.id, { ...config });
+  }
+  async get(taskId, configId) {
+    const cfg = this.byTask.get(taskId)?.get(configId);
+    return cfg ? { ...cfg } : void 0;
+  }
+  async list(taskId) {
+    const configs = this.byTask.get(taskId);
+    if (!configs) return [];
+    return [...configs.values()].map((c) => ({ ...c }));
+  }
+  async delete(taskId, configId) {
+    const configs = this.byTask.get(taskId);
+    if (!configs) return;
+    configs.delete(configId);
+    if (configs.size === 0) this.byTask.delete(taskId);
+  }
+};
+var PUSH_TABLE_DDL = (table) => `
+  CREATE TABLE IF NOT EXISTS ${table} (
+    task_id TEXT NOT NULL,
+    config_id TEXT NOT NULL,
+    url TEXT NOT NULL,
+    token TEXT,
+    authentication TEXT,
+    PRIMARY KEY (task_id, config_id)
+  )
+`;
+var SqlPushNotificationStore = class {
+  constructor(db, table = "a2a_push_configs") {
+    this.db = db;
+    this.table = table;
+  }
+  db;
+  table;
+  async migrate() {
+    await this.db.exec(PUSH_TABLE_DDL(this.table));
+  }
+  async set(taskId, config) {
+    const auth = config.authentication ? JSON.stringify(config.authentication) : null;
+    const updated = await this.db.exec(
+      `UPDATE ${this.table} SET url = ?, token = ?, authentication = ? WHERE task_id = ? AND config_id = ?`,
+      [config.url, config.token ?? null, auth, taskId, config.id]
+    );
+    if (updated.rowsAffected === 0) {
+      await this.db.exec(
+        `INSERT INTO ${this.table} (task_id, config_id, url, token, authentication) VALUES (?, ?, ?, ?, ?)`,
+        [taskId, config.id, config.url, config.token ?? null, auth]
+      );
+    }
+  }
+  async get(taskId, configId) {
+    const rows = await this.db.query(
+      `SELECT config_id, url, token, authentication FROM ${this.table} WHERE task_id = ? AND config_id = ?`,
+      [taskId, configId]
+    );
+    const row = rows[0];
+    if (!row) return void 0;
+    return {
+      id: row.config_id,
+      url: row.url,
+      token: row.token ?? void 0,
+      authentication: row.authentication ? JSON.parse(row.authentication) : void 0
+    };
+  }
+  async list(taskId) {
+    const rows = await this.db.query(
+      `SELECT config_id, url, token, authentication FROM ${this.table} WHERE task_id = ?`,
+      [taskId]
+    );
+    return rows.map((row) => ({
+      id: row.config_id,
+      url: row.url,
+      token: row.token ?? void 0,
+      authentication: row.authentication ? JSON.parse(row.authentication) : void 0
+    }));
+  }
+  async delete(taskId, configId) {
+    await this.db.exec(
+      `DELETE FROM ${this.table} WHERE task_id = ? AND config_id = ?`,
+      [taskId, configId]
+    );
+  }
+};
+async function deliverPushNotifications(args) {
+  const fetcher = args.fetcher ?? fetch;
+  const configs = await args.store.list(args.task.id);
+  const body = JSON.stringify({
+    taskId: args.task.id,
+    state: args.task.status.state,
+    task: args.task
+  });
+  const signature = args.webhookSecret ? `sha256=${await hmacSha256Hex(args.webhookSecret, body)}` : void 0;
+  const results = [];
+  for (const config of configs) {
+    const headers = { "Content-Type": "application/json" };
+    if (config.token) headers["X-A2A-Notification-Token"] = config.token;
+    if (signature) headers["X-A2A-Signature"] = signature;
+    if (config.authentication?.credentials) {
+      const scheme = config.authentication.schemes[0] ?? "Bearer";
+      headers.Authorization = `${scheme} ${config.authentication.credentials}`;
+    }
+    let result;
+    try {
+      const res = await fetcher(config.url, { method: "POST", headers, body });
+      result = {
+        taskId: args.task.id,
+        configId: config.id,
+        url: config.url,
+        ok: res.ok,
+        status: res.status
+      };
+    } catch (err) {
+      result = {
+        taskId: args.task.id,
+        configId: config.id,
+        url: config.url,
+        ok: false,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+    args.onDelivery?.(result);
+    results.push(result);
+  }
+  return results;
+}
+async function hmacSha256Hex(secret, body) {
+  const enc = new TextEncoder();
+  const key = await crypto.subtle.importKey(
+    "raw",
+    enc.encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const sig = await crypto.subtle.sign("HMAC", key, enc.encode(body));
+  return [...new Uint8Array(sig)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+// src/a2a/translate.ts
+function extractTextFromMessage(message) {
+  if (!message || message.kind !== "message") {
+    return {
+      error: {
+        code: A2A_ERROR_CODES.INVALID_PARAMS,
+        message: 'params.message must be an A2A Message ({ kind: "message", role, parts, messageId })'
+      }
+    };
+  }
+  if (!Array.isArray(message.parts) || message.parts.length === 0) {
+    return {
+      error: {
+        code: A2A_ERROR_CODES.INVALID_PARAMS,
+        message: "message.parts must be a non-empty array"
+      }
+    };
+  }
+  const texts = [];
+  for (const part of message.parts) {
+    if (part.kind === "text") {
+      if (typeof part.text !== "string") {
+        return {
+          error: {
+            code: A2A_ERROR_CODES.INVALID_PARAMS,
+            message: "text part .text must be a string"
+          }
+        };
+      }
+      texts.push(part.text);
+    } else {
+      return {
+        error: {
+          code: A2A_ERROR_CODES.CONTENT_TYPE_NOT_SUPPORTED,
+          message: `part.kind '${part.kind}' not supported; this agent accepts text parts only`
+        }
+      };
+    }
+  }
+  return { text: texts.join("\n\n") };
+}
+function responseTextToArtifact(text, artifactId) {
+  return {
+    artifactId,
+    name: "response",
+    parts: [{ kind: "text", text }]
+  };
+}
+
+// src/a2a/handler.ts
+var TERMINAL_STATES = /* @__PURE__ */ new Set([
+  "completed",
+  "canceled",
+  "failed",
+  "rejected"
+]);
+var CancelRegistry = class {
+  controllers = /* @__PURE__ */ new Map();
+  register(taskId) {
+    const c = new AbortController();
+    this.controllers.set(taskId, c);
+    return c;
+  }
+  clear(taskId) {
+    this.controllers.delete(taskId);
+  }
+  cancel(taskId) {
+    const c = this.controllers.get(taskId);
+    if (!c) return false;
+    c.abort();
+    this.controllers.delete(taskId);
+    return true;
+  }
+};
+function createA2AHandlers(deps) {
+  const cancels = new CancelRegistry();
+  const handleAgentCard = async (c) => {
+    const slug = c.req.param("slug");
+    if (!slug) return c.json({ error: "slug required" }, 400);
+    const agent = await deps.config.resolveAgent(slug);
+    if (!agent) {
+      return c.json({ error: "Agent not found or not published" }, 404);
+    }
+    const url = new URL(c.req.url);
+    const agentUrl = `${url.origin}${url.pathname.replace(/\/\.well-known\/agent\.json$/, "")}`;
+    return c.json(buildAgentCard(agent, deps.config, agentUrl));
+  };
+  const handleJsonRpc = async (c) => {
+    const slug = c.req.param("slug");
+    if (!slug) {
+      return c.json(fail(null, A2A_ERROR_CODES.INVALID_REQUEST, "slug required"), 400);
+    }
+    const contentLength = Number.parseInt(c.req.header("Content-Length") ?? "0", 10);
+    if (contentLength > 65536) {
+      return c.json(fail(null, A2A_ERROR_CODES.INVALID_REQUEST, "request body too large (max 64KB)"), 413);
+    }
+    let raw;
+    try {
+      raw = await c.req.json();
+    } catch {
+      return c.json(fail(null, A2A_ERROR_CODES.PARSE_ERROR, "invalid JSON"), 400);
+    }
+    const parsed = parseEnvelope(raw);
+    if ("code" in parsed) {
+      return c.json(fail(parsed.id, parsed.code, parsed.message), 400);
+    }
+    switch (parsed.method) {
+      case "message/send":
+        return handleMessageSend(c, slug, parsed, deps);
+      case "message/stream":
+        return handleMessageStream(c, slug, parsed, deps, cancels);
+      case "tasks/get":
+        return handleTasksGet(c, parsed, deps);
+      case "tasks/cancel":
+        return handleTasksCancel(c, parsed, deps, cancels);
+      case "tasks/resubscribe":
+        return handleTasksResubscribe(c, parsed, deps);
+      case "tasks/pushNotificationConfig/set":
+        return handlePushSet(c, parsed, deps);
+      case "tasks/pushNotificationConfig/get":
+        return handlePushGet(c, parsed, deps);
+      case "tasks/pushNotificationConfig/list":
+        return handlePushList(c, parsed, deps);
+      case "tasks/pushNotificationConfig/delete":
+        return handlePushDelete(c, parsed, deps);
+      default:
+        return c.json(
+          fail(parsed.id, A2A_ERROR_CODES.METHOD_NOT_FOUND, `unknown method '${parsed.method}'`)
+        );
+    }
+  };
+  return { handleAgentCard, handleJsonRpc };
+}
+async function handleMessageSend(c, slug, req, deps) {
+  const guard = await guardMessageRequest(c, slug, req, deps);
+  if (guard instanceof Response) return guard;
+  const { authz, task } = guard;
+  let responseText = "";
+  let outputTokens = 0;
+  let inputRequiredPrompt;
+  let inputRequiredSeen = false;
+  try {
+    for await (const event of dispatchSandboxStreamRich(
+      authz.agent,
+      authz.userMessage,
+      authz.consumerId,
+      deps.config,
+      void 0,
+      task.id
+    )) {
+      if (event.kind === "text") {
+        responseText += event.delta;
+        outputTokens += estimateTokens(event.delta);
+      } else {
+        inputRequiredSeen = true;
+        inputRequiredPrompt = event.prompt;
+      }
+    }
+  } catch (err) {
+    const failed = withStatus(task, "failed");
+    await deps.taskStore.put(failed);
+    await maybeDeliverPush(failed, deps);
+    return c.json(
+      fail(
+        req.id,
+        A2A_ERROR_CODES.INTERNAL_ERROR,
+        err instanceof Error ? err.message : String(err)
+      )
+    );
+  }
+  await settleAndRecord(
+    authz.agent,
+    authz,
+    estimateTokens(authz.userMessage),
+    outputTokens,
+    deps.config,
+    deps.state.obs
+  );
+  if (inputRequiredSeen) {
+    const paused = withStatus(
+      task,
+      "input-required",
+      inputRequiredPrompt ? agentMessage(task, inputRequiredPrompt) : void 0,
+      responseText ? [responseTextToArtifact(responseText, `${task.id}-artifact-0`)] : task.artifacts
+    );
+    await deps.taskStore.put(paused);
+    return c.json(ok(req.id, paused));
+  }
+  const completed = withStatus(task, "completed", void 0, [
+    responseTextToArtifact(responseText, `${task.id}-artifact-0`)
+  ]);
+  await deps.taskStore.put(completed);
+  await maybeDeliverPush(completed, deps);
+  return c.json(ok(req.id, completed));
+}
+async function handleMessageStream(c, slug, req, deps, cancels) {
+  const guard = await guardMessageRequest(c, slug, req, deps);
+  if (guard instanceof Response) return guard;
+  const { authz, task } = guard;
+  const controller = cancels.register(task.id);
+  const inputTokens = estimateTokens(authz.userMessage);
+  let outputTokens = 0;
+  let responseText = "";
+  const stream = new ReadableStream({
+    async start(ctrl) {
+      const encoder = new TextEncoder();
+      const send = (event) => {
+        ctrl.enqueue(encoder.encode(`data: ${JSON.stringify(ok(req.id, event))}
+
+`));
+      };
+      const workingStatus = {
+        kind: "status-update",
+        taskId: task.id,
+        contextId: task.contextId,
+        status: { state: "working", timestamp: nowIso() },
+        final: false
+      };
+      await deps.taskStore.put({ ...task, status: workingStatus.status });
+      send(workingStatus);
+      let inputRequiredPrompt;
+      let inputRequiredSeen = false;
+      try {
+        for await (const event of dispatchSandboxStreamRich(
+          authz.agent,
+          authz.userMessage,
+          authz.consumerId,
+          deps.config,
+          controller.signal,
+          task.id
+        )) {
+          if (event.kind === "text") {
+            responseText += event.delta;
+            outputTokens += estimateTokens(event.delta);
+            const artifactEvent = {
+              kind: "artifact-update",
+              taskId: task.id,
+              contextId: task.contextId,
+              artifact: {
+                artifactId: `${task.id}-artifact-0`,
+                name: "response",
+                parts: [{ kind: "text", text: event.delta }]
+              },
+              append: true
+            };
+            send(artifactEvent);
+          } else {
+            inputRequiredSeen = true;
+            inputRequiredPrompt = event.prompt;
+          }
+        }
+        if (controller.signal.aborted) {
+          const canceled = withStatus(task, "canceled", void 0, [
+            responseTextToArtifact(responseText, `${task.id}-artifact-0`)
+          ]);
+          await deps.taskStore.put(canceled);
+          send({
+            kind: "status-update",
+            taskId: task.id,
+            contextId: task.contextId,
+            status: canceled.status,
+            final: true
+          });
+          await maybeDeliverPush(canceled, deps);
+          return;
+        }
+        await settleAndRecord(
+          authz.agent,
+          authz,
+          inputTokens,
+          outputTokens,
+          deps.config,
+          deps.state.obs
+        );
+        if (inputRequiredSeen) {
+          const paused = withStatus(
+            task,
+            "input-required",
+            inputRequiredPrompt ? agentMessage(task, inputRequiredPrompt) : void 0,
+            responseText ? [responseTextToArtifact(responseText, `${task.id}-artifact-0`)] : task.artifacts
+          );
+          await deps.taskStore.put(paused);
+          send({
+            kind: "status-update",
+            taskId: task.id,
+            contextId: task.contextId,
+            status: paused.status,
+            final: true
+          });
+          return;
+        }
+        send({
+          kind: "artifact-update",
+          taskId: task.id,
+          contextId: task.contextId,
+          artifact: {
+            artifactId: `${task.id}-artifact-0`,
+            name: "response",
+            parts: [{ kind: "text", text: "" }]
+          },
+          append: true,
+          lastChunk: true
+        });
+        const completed = withStatus(task, "completed", void 0, [
+          responseTextToArtifact(responseText, `${task.id}-artifact-0`)
+        ]);
+        await deps.taskStore.put(completed);
+        send({
+          kind: "status-update",
+          taskId: task.id,
+          contextId: task.contextId,
+          status: completed.status,
+          final: true
+        });
+        await maybeDeliverPush(completed, deps);
+      } catch (err) {
+        const failed = withStatus(task, "failed");
+        await deps.taskStore.put(failed);
+        send({
+          kind: "status-update",
+          taskId: task.id,
+          contextId: task.contextId,
+          status: failed.status,
+          final: true
+        });
+        await maybeDeliverPush(failed, deps);
+        await deps.state.obs?.onStreamError?.(
+          {
+            requestId: authz.requestId,
+            agentSlug: authz.agent.slug,
+            startMs: authz.startMs
+          },
+          {
+            consumerId: authz.consumerId,
+            errorMessage: err instanceof Error ? err.message : String(err)
+          }
+        );
+      } finally {
+        cancels.clear(task.id);
+        ctrl.close();
+      }
+    }
+  });
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      "X-Request-Id": authz.requestId,
+      "X-Agent-Slug": authz.agent.slug,
+      "X-Task-Id": task.id
+    }
+  });
+}
+async function handleTasksGet(c, req, deps) {
+  const params = req.params;
+  if (!params || typeof params.id !== "string") {
+    return c.json(fail(req.id, A2A_ERROR_CODES.INVALID_PARAMS, "params.id required"));
+  }
+  const task = await deps.taskStore.get(params.id);
+  if (!task) {
+    return c.json(
+      fail(req.id, A2A_ERROR_CODES.TASK_NOT_FOUND, `task '${params.id}' not found`)
+    );
+  }
+  return c.json(ok(req.id, task));
+}
+async function handleTasksCancel(c, req, deps, cancels) {
+  const params = req.params;
+  if (!params || typeof params.id !== "string") {
+    return c.json(fail(req.id, A2A_ERROR_CODES.INVALID_PARAMS, "params.id required"));
+  }
+  const task = await deps.taskStore.get(params.id);
+  if (!task) {
+    return c.json(
+      fail(req.id, A2A_ERROR_CODES.TASK_NOT_FOUND, `task '${params.id}' not found`)
+    );
+  }
+  if (isTerminal(task.status.state)) {
+    return c.json(
+      fail(
+        req.id,
+        A2A_ERROR_CODES.TASK_NOT_CANCELABLE,
+        `task '${params.id}' is in terminal state '${task.status.state}'`
+      )
+    );
+  }
+  const stillActive = cancels.cancel(task.id);
+  const canceled = {
+    ...task,
+    status: { state: "canceled", timestamp: nowIso() }
+  };
+  await deps.taskStore.put(canceled);
+  if (!stillActive) {
+    await maybeDeliverPush(canceled, deps);
+  }
+  return c.json(ok(req.id, canceled));
+}
+async function handleTasksResubscribe(c, req, deps) {
+  const params = req.params;
+  if (!params || typeof params.id !== "string") {
+    return c.json(fail(req.id, A2A_ERROR_CODES.INVALID_PARAMS, "params.id required"));
+  }
+  const task = await deps.taskStore.get(params.id);
+  if (!task) {
+    return c.json(
+      fail(req.id, A2A_ERROR_CODES.TASK_NOT_FOUND, `task '${params.id}' not found`)
+    );
+  }
+  const final = isTerminal(task.status.state) || task.status.state === "input-required";
+  const event = {
+    kind: "status-update",
+    taskId: task.id,
+    contextId: task.contextId,
+    status: task.status,
+    final
+  };
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream({
+    start(ctrl) {
+      ctrl.enqueue(encoder.encode(`data: ${JSON.stringify(ok(req.id, event))}
+
+`));
+      ctrl.close();
+    }
+  });
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      "X-Task-Id": task.id
+    }
+  });
+}
+async function handlePushSet(c, req, deps) {
+  if (!deps.pushStore) {
+    return c.json(fail(req.id, A2A_ERROR_CODES.PUSH_NOT_SUPPORTED, "push notifications not configured"));
+  }
+  const params = req.params;
+  if (!params || typeof params.taskId !== "string" || !params.pushNotificationConfig?.id) {
+    return c.json(
+      fail(
+        req.id,
+        A2A_ERROR_CODES.INVALID_PARAMS,
+        "params.taskId and params.pushNotificationConfig.id required"
+      )
+    );
+  }
+  if (typeof params.pushNotificationConfig.url !== "string") {
+    return c.json(fail(req.id, A2A_ERROR_CODES.INVALID_PARAMS, "pushNotificationConfig.url required"));
+  }
+  const task = await deps.taskStore.get(params.taskId);
+  if (!task) {
+    return c.json(fail(req.id, A2A_ERROR_CODES.TASK_NOT_FOUND, `task '${params.taskId}' not found`));
+  }
+  await deps.pushStore.set(params.taskId, params.pushNotificationConfig);
+  const stored = await deps.pushStore.get(params.taskId, params.pushNotificationConfig.id);
+  return c.json(ok(req.id, { taskId: params.taskId, pushNotificationConfig: stored }));
+}
+async function handlePushGet(c, req, deps) {
+  if (!deps.pushStore) {
+    return c.json(fail(req.id, A2A_ERROR_CODES.PUSH_NOT_SUPPORTED, "push notifications not configured"));
+  }
+  const params = req.params;
+  if (!params || typeof params.id !== "string" || typeof params.pushNotificationConfigId !== "string") {
+    return c.json(
+      fail(req.id, A2A_ERROR_CODES.INVALID_PARAMS, "params.id and params.pushNotificationConfigId required")
+    );
+  }
+  const cfg = await deps.pushStore.get(params.id, params.pushNotificationConfigId);
+  if (!cfg) {
+    return c.json(
+      fail(
+        req.id,
+        A2A_ERROR_CODES.TASK_NOT_FOUND,
+        `push config '${params.pushNotificationConfigId}' not found for task '${params.id}'`
+      )
+    );
+  }
+  return c.json(ok(req.id, { taskId: params.id, pushNotificationConfig: cfg }));
+}
+async function handlePushList(c, req, deps) {
+  if (!deps.pushStore) {
+    return c.json(fail(req.id, A2A_ERROR_CODES.PUSH_NOT_SUPPORTED, "push notifications not configured"));
+  }
+  const params = req.params;
+  if (!params || typeof params.id !== "string") {
+    return c.json(fail(req.id, A2A_ERROR_CODES.INVALID_PARAMS, "params.id required"));
+  }
+  const configs = await deps.pushStore.list(params.id);
+  return c.json(ok(req.id, configs.map((cfg) => ({ taskId: params.id, pushNotificationConfig: cfg }))));
+}
+async function handlePushDelete(c, req, deps) {
+  if (!deps.pushStore) {
+    return c.json(fail(req.id, A2A_ERROR_CODES.PUSH_NOT_SUPPORTED, "push notifications not configured"));
+  }
+  const params = req.params;
+  if (!params || typeof params.id !== "string" || typeof params.pushNotificationConfigId !== "string") {
+    return c.json(
+      fail(req.id, A2A_ERROR_CODES.INVALID_PARAMS, "params.id and params.pushNotificationConfigId required")
+    );
+  }
+  await deps.pushStore.delete(params.id, params.pushNotificationConfigId);
+  return c.json(ok(req.id, null));
+}
+async function guardMessageRequest(c, slug, req, deps) {
+  const params = req.params;
+  if (!params || !params.message) {
+    return c.json(fail(req.id, A2A_ERROR_CODES.INVALID_PARAMS, "params.message required"));
+  }
+  const extracted = extractTextFromMessage(params.message);
+  if ("error" in extracted) {
+    return c.json(fail(req.id, extracted.error.code, extracted.error.message));
+  }
+  const guard = await authenticateAndGuard(
+    c,
+    slug,
+    [{ role: "user", content: extracted.text }],
+    deps.config,
+    deps.state
+  );
+  if (guard instanceof Response) return guard;
+  const authz = guard;
+  if (typeof params.message.taskId === "string") {
+    const existing = await deps.taskStore.get(params.message.taskId);
+    if (existing) {
+      if (existing.status.state !== "input-required") {
+        return c.json(
+          fail(
+            req.id,
+            A2A_ERROR_CODES.INVALID_PARAMS,
+            `task '${existing.id}' is in state '${existing.status.state}'; only 'input-required' tasks accept follow-up messages`
+          )
+        );
+      }
+      const appendedMessage = {
+        ...params.message,
+        taskId: existing.id,
+        contextId: existing.contextId
+      };
+      const continued = {
+        ...existing,
+        status: { state: "working", timestamp: nowIso() },
+        history: [...existing.history ?? [], appendedMessage]
+      };
+      await deps.taskStore.put(continued);
+      return { authz, task: continued };
+    }
+  }
+  const taskId = params.message.taskId ?? `task_${cryptoRandomId()}`;
+  const contextId = params.message.contextId ?? `ctx_${cryptoRandomId()}`;
+  const initialMessage = {
+    ...params.message,
+    taskId,
+    contextId
+  };
+  const task = {
+    kind: "task",
+    id: taskId,
+    contextId,
+    status: { state: "submitted", timestamp: nowIso() },
+    history: [initialMessage]
+  };
+  await deps.taskStore.put(task);
+  return { authz, task };
+}
+function isTerminal(state) {
+  return state === "completed" || state === "canceled" || state === "failed" || state === "rejected";
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function cryptoRandomId() {
+  return crypto.randomUUID().replace(/-/g, "");
+}
+function withStatus(task, state, message, artifacts) {
+  return {
+    ...task,
+    status: { state, timestamp: nowIso(), ...message ? { message } : {} },
+    ...artifacts !== void 0 ? { artifacts } : {}
+  };
+}
+function agentMessage(task, text) {
+  return {
+    kind: "message",
+    role: "agent",
+    parts: [{ kind: "text", text }],
+    messageId: `${task.id}-status-${task.status.state}-${nowIso()}`,
+    taskId: task.id,
+    contextId: task.contextId
+  };
+}
+async function maybeDeliverPush(task, deps) {
+  if (!deps.pushStore || !TERMINAL_STATES.has(task.status.state)) return;
+  try {
+    await deliverPushNotifications({
+      task,
+      store: deps.pushStore,
+      webhookSecret: deps.config.a2a?.webhookSecret,
+      fetcher: deps.config.a2a?.pushFetcher,
+      onDelivery: (result) => {
+        if (!result.ok) {
+          deps.state.obs?.onStreamError?.(
+            { requestId: result.taskId, agentSlug: task.id, startMs: Date.now() },
+            {
+              consumerId: result.configId,
+              errorMessage: `push delivery failed (${result.status ?? "no-status"}): ${result.error ?? "non-2xx"}`
+            }
+          );
+        }
+      }
+    });
+  } catch (err) {
+    console.error(
+      `[agent-gateway] push delivery threw for task ${task.id}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+
+// src/a2a/task-store.ts
+var DEFAULT_TTL_MS = 60 * 60 * 1e3;
+var InMemoryTaskStore = class {
+  constructor(ttlMs = DEFAULT_TTL_MS) {
+    this.ttlMs = ttlMs;
+  }
+  ttlMs;
+  entries = /* @__PURE__ */ new Map();
+  async get(id) {
+    this.gc();
+    const entry = this.entries.get(id);
+    if (!entry) return void 0;
+    return clone(entry.task);
+  }
+  async put(task) {
+    this.gc();
+    this.entries.set(task.id, { task: clone(task), expiresAt: Date.now() + this.ttlMs });
+  }
+  async delete(id) {
+    this.entries.delete(id);
+  }
+  /**
+   * Sweep expired tasks. Called inline on every read/write — cheap for the
+   * Map sizes this is designed for (10s–1000s of concurrent tasks).
+   */
+  gc() {
+    const now = Date.now();
+    for (const [id, entry] of this.entries) {
+      if (entry.expiresAt <= now) this.entries.delete(id);
+    }
+  }
+};
+function clone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+// src/middleware.ts
+function createAgentGateway(config) {
+  if (!config.x402.verifySigner && !config.x402.demoMode) {
+    throw new Error(
+      "createAgentGateway: x402.verifySigner is required in production. For tests, set x402.demoMode: true explicitly."
+    );
+  }
+  const gw = new Hono();
+  const rateLimitStore = config.rateLimitStore ?? new MemoryRateLimitStore();
+  const state = {
+    rateLimitStore,
+    nonceStore: config.nonceStore ?? new MemoryNonceStore(),
+    globalRateLimit: config.rateLimit ?? { limit: 60, windowSeconds: 60 },
+    requiredScope: config.requiredScope ?? "chat",
+    maxLen: config.maxMessageLength ?? 8e3,
+    obs: config.observer
+  };
+  const obs = state.obs;
+  gw.get("/:slug/chat/completions", async (c) => {
+    const slug = c.req.param("slug");
+    const agent = await config.resolveAgent(slug);
+    if (!agent) return c.json({ error: "Agent not found or not published" }, 404);
+    const paymentMethods = [
+      {
+        type: "x402",
+        operator: config.x402.operatorAddress,
+        chain_id: config.x402.chainId,
+        credits_contract: config.x402.creditsAddress
+      }
+    ];
+    if (config.mpp) {
+      paymentMethods.push({
+        type: "mpp",
+        realm: config.mpp.realm,
+        method: config.mpp.method ?? "blueprintevm"
+      });
+    }
+    paymentMethods.push({ type: "api_key", prefix: "sk_agent_" });
+    return c.json({
+      slug: agent.slug,
+      pricing: {
+        per_token_usd: agent.pricePerTokenUsd,
+        currency: "USD",
+        platform_fee_percent: agent.platformFeePercent
+      },
+      hosting: {
+        mode: agent.sandboxEndpoint ? "sovereign" : "centralized",
+        endpoint: agent.sandboxEndpoint ?? config.baseUrl ?? "tangle.tools"
+      },
+      payment_methods: paymentMethods,
+      capabilities: ["chat.completions", "streaming"],
+      openai_compatible: true
+    });
+  });
+  gw.post("/:slug/chat/completions", async (c) => {
+    const slug = c.req.param("slug");
+    const contentLength = Number.parseInt(c.req.header("Content-Length") ?? "0", 10);
+    if (contentLength > 65536) {
+      const requestId = generateRequestId();
+      await obs?.onBodyTooLarge?.(
+        { requestId, agentSlug: slug, startMs: Date.now() },
+        contentLength
+      );
+      return c.json(
+        {
+          error: {
+            message: "Request body too large (max 64KB)",
+            type: "invalid_request"
+          }
+        },
+        413
+      );
+    }
+    let body;
+    try {
+      body = await c.req.json();
+    } catch {
+      return c.json({ error: { message: "Invalid JSON", type: "invalid_request" } }, 400);
+    }
+    if (!body.messages?.length) {
+      return c.json(
+        { error: { message: "messages array required", type: "invalid_request" } },
+        400
+      );
+    }
+    const guard = await authenticateAndGuard(c, slug, body.messages, config, state);
+    if (guard instanceof Response) return guard;
+    const authz = guard;
+    return streamChatCompletions(c, authz, config, obs);
+  });
+  const taskStore = config.a2a?.taskStore ?? new InMemoryTaskStore();
+  const pushStore = config.a2a?.pushStore;
+  const a2a = createA2AHandlers({ config, state, taskStore, pushStore });
+  gw.get("/:slug/.well-known/agent.json", a2a.handleAgentCard);
+  gw.post("/:slug", a2a.handleJsonRpc);
+  return gw;
+}
+function streamChatCompletions(c, authz, config, obs) {
+  const { agent, consumerId, paymentMethod, requestId, userMessage, rateLimitRemaining } = authz;
+  const inputTokens = estimateTokens(userMessage);
+  let outputTokens = 0;
+  const ctx = {
+    requestId,
+    agentSlug: agent.slug,
+    startMs: authz.startMs
+  };
+  const stream = new ReadableStream({
+    async start(controller) {
+      const encoder = new TextEncoder();
+      const sendChunk = (delta) => {
+        outputTokens += estimateTokens(delta);
+        const chunk = {
+          id: `chatcmpl-${Date.now()}`,
+          object: "chat.completion.chunk",
+          created: Math.floor(Date.now() / 1e3),
+          model: agent.slug,
+          choices: [{ index: 0, delta: { content: delta }, finish_reason: null }]
+        };
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify(chunk)}
+
+`));
+      };
+      try {
+        for await (const delta of dispatchSandboxStream(agent, userMessage, consumerId, config)) {
+          sendChunk(delta);
+        }
+        const done = {
+          id: `chatcmpl-${Date.now()}`,
+          object: "chat.completion.chunk",
+          created: Math.floor(Date.now() / 1e3),
+          model: agent.slug,
+          choices: [{ index: 0, delta: {}, finish_reason: "stop" }]
+        };
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify(done)}
+
+`));
+        controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+        await settleAndRecord(agent, authz, inputTokens, outputTokens, config, obs);
+      } catch (err) {
+        const rawMessage = err instanceof Error ? err.message : String(err);
+        const safeMessage = rawMessage.includes("/") || rawMessage.includes("\\") ? "Internal agent error" : rawMessage;
+        await obs?.onStreamError?.(ctx, { consumerId, errorMessage: rawMessage });
+        controller.enqueue(
+          encoder.encode(
+            `data: ${JSON.stringify({ error: { message: safeMessage, type: "server_error" } })}
+
+`
+          )
+        );
+      } finally {
+        controller.close();
+      }
+    }
+  });
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      "X-Request-Id": requestId,
+      "X-Agent-Slug": agent.slug,
+      "X-Agent-Hosting": agent.sandboxEndpoint ? "sovereign" : "centralized",
+      "X-Payment-Method": paymentMethod,
+      "X-Payment-Settled": paymentMethod === "x402" ? "pending" : "true",
+      ...rateLimitRemaining !== void 0 ? { "X-RateLimit-Remaining": String(rateLimitRemaining) } : {}
+    }
+  });
+}
+
+export {
+  detectInjection,
+  filterConsumerMessages,
+  filterConsumerMessagesStrict,
+  redactSystemPromptFromOutput,
+  ConsoleObserver,
+  CompositeObserver,
+  generateRequestId,
+  verifyX402,
+  verifyMpp,
+  defaultVerifyApiKey,
+  A2A_ERROR_CODES,
+  InMemoryPushNotificationStore,
+  SqlPushNotificationStore,
+  deliverPushNotifications,
+  InMemoryTaskStore,
+  createAgentGateway
+};
+//# sourceMappingURL=chunk-3IKQWFKX.js.map