@tangle-network/agent-gateway 0.5.0 → 0.7.0

package/dist/chunk-373QHRKV.js

@@ -1,635 +0,0 @@
-import {
-  MemoryNonceStore
-} from "./chunk-M7ZJAK4K.js";
-import {
-  MemoryRateLimitStore,
-  checkRateLimit
-} from "./chunk-XCTXHZ76.js";
-
-// src/middleware.ts
-import { Hono } from "hono";
-
-// 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/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/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 maxLen = config.maxMessageLength ?? 8e3;
-  const rateLimitStore = config.rateLimitStore ?? new MemoryRateLimitStore();
-  const globalRateLimit = config.rateLimit ?? { limit: 60, windowSeconds: 60 };
-  const nonceStore = config.nonceStore ?? new MemoryNonceStore();
-  const requiredScope = config.requiredScope ?? "chat";
-  const obs = config.observer;
-  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 startMs = Date.now();
-    const requestId = generateRequestId();
-    const ctx = { requestId, agentSlug: slug, startMs };
-    await obs?.onRequestStart?.(ctx);
-    const agent = await config.resolveAgent(slug);
-    if (!agent) {
-      return c.json({ error: { message: "Agent not found", type: "not_found" } }, 404);
-    }
-    const contentLength = parseInt(c.req.header("Content-Length") ?? "0", 10);
-    if (contentLength > 65536) {
-      await obs?.onBodyTooLarge?.(ctx, 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 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, nonceStore);
-      if (!signer) {
-        await 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 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 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(requiredScope)) {
-        await obs?.onAuthFailure?.(ctx, { method: "apikey", code: "insufficient_scope", httpStatus: 403 });
-        return c.json(
-          { error: { message: `API key missing required scope: ${requiredScope}`, type: "forbidden", code: "insufficient_scope" } },
-          { status: 403, headers: { "X-Request-Id": requestId } }
-        );
-      }
-      consumerId = key.consumerId;
-      paymentMethod = "apikey";
-      keyInfo = key;
-    } else {
-      await 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 obs?.onPaymentVerified?.(ctx, { method: paymentMethod, consumerId, keyId: keyInfo?.keyId });
-    const effectiveRateLimit = keyInfo?.rateLimitPerMinute ? { limit: keyInfo.rateLimitPerMinute, windowSeconds: 60 } : globalRateLimit;
-    const rl = await checkRateLimit(consumerId, effectiveRateLimit, rateLimitStore);
-    if (!rl.allowed) {
-      await 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(body.messages, maxLen);
-    if (injectionWarnings.length > 0) {
-      await 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 } }
-        );
-      }
-    }
-    const inputTokens = Math.ceil(userMessage.length / 4);
-    let outputTokens = 0;
-    const stream = new ReadableStream({
-      async start(controller) {
-        const encoder = new TextEncoder();
-        const sendChunk = (rawDelta) => {
-          const delta = redactSystemPromptFromOutput(rawDelta, agent.systemPrompt);
-          outputTokens += Math.ceil(delta.length / 4);
-          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 {
-          const box = await config.getSandbox(agent);
-          const promptStream = box.streamPrompt(userMessage, {
-            sessionId: `consumer:${consumerId}`,
-            systemPrompt: agent.systemPrompt
-          });
-          for await (const event of promptStream) {
-            if (event.type === "message.part.updated" && event.data?.part?.type === "text" && event.data.delta) {
-              sendChunk(event.data.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"));
-          const totalCost = (inputTokens + outputTokens) * agent.pricePerTokenUsd;
-          const ownerEarned = totalCost * (1 - agent.platformFeePercent);
-          const platformFee = totalCost * agent.platformFeePercent;
-          const usageEvent = {
-            requestId: ctx.requestId,
-            agentId: agent.id,
-            agentSlug: agent.slug,
-            consumerId,
-            paymentMethod,
-            inputTokens,
-            outputTokens,
-            totalCostUsd: totalCost,
-            ownerEarnedUsd: ownerEarned,
-            platformFeeUsd: platformFee,
-            durationMs: Date.now() - startMs
-          };
-          await config.recordUsage(usageEvent);
-          await obs?.onRequestComplete?.(ctx, usageEvent);
-          if (config.settlePayment) {
-            await config.settlePayment(
-              { method: paymentMethod, consumerId, requestId: ctx.requestId },
-              totalCost
-            ).catch(async (err) => {
-              const msg = err instanceof Error ? err.message : String(err);
-              console.error(`[agent-gateway] settlement failed for ${consumerId}: ${msg}`);
-              await obs?.onSettlementError?.(ctx, { consumerId, method: paymentMethod, errorMessage: msg });
-            });
-          }
-        } 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",
-        ...rl.remaining !== void 0 ? { "X-RateLimit-Remaining": String(rl.remaining) } : {}
-      }
-    });
-  });
-  return gw;
-}
-
-export {
-  verifyX402,
-  verifyMpp,
-  defaultVerifyApiKey,
-  detectInjection,
-  filterConsumerMessages,
-  filterConsumerMessagesStrict,
-  redactSystemPromptFromOutput,
-  ConsoleObserver,
-  CompositeObserver,
-  generateRequestId,
-  createAgentGateway
-};
-//# sourceMappingURL=chunk-373QHRKV.js.map