@mastra/deployer 0.3.3 → 0.3.4-alpha.1

package/dist/server/index.cjs

@@ -18,8 +18,12 @@ var cors = require('hono/cors');
 var logger = require('hono/logger');
 var timeout = require('hono/timeout');
 var httpException = require('hono/http-exception');
+var a2a = require('@mastra/server/handlers/a2a');
+var streaming = require('hono/streaming');
 var agents = require('@mastra/server/handlers/agents');
 var logs = require('@mastra/server/handlers/logs');
+var util = require('util');
+var buffer = require('buffer');
 var memory = require('@mastra/server/handlers/memory');
 var network = require('@mastra/server/handlers/network');
 var agent = require('@mastra/core/agent');
@@ -28,13 +32,13 @@ var telemetry = require('@mastra/server/handlers/telemetry');
 var tools = require('@mastra/server/handlers/tools');
 var vector = require('@mastra/server/handlers/vector');
 var vNextWorkflows = require('@mastra/server/handlers/vNextWorkflows');
-var streaming = require('hono/streaming');
 var voice = require('@mastra/server/handlers/voice');
 var workflows = require('@mastra/server/handlers/workflows');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var crypto__default = /*#__PURE__*/_interopDefault(crypto);
+var util__default = /*#__PURE__*/_interopDefault(util);
 
 // src/server/index.ts
 var RequestError = class extends Error {
@@ -159,27 +163,48 @@ Object.setPrototypeOf(requestPrototype, Request.prototype);
 var newRequest = (incoming, defaultHostname) => {
   const req = Object.create(requestPrototype);
   req[incomingKey] = incoming;
+  const incomingUrl = incoming.url || "";
+  if (incomingUrl[0] !== "/" && // short-circuit for performance. most requests are relative URL.
+  (incomingUrl.startsWith("http://") || incomingUrl.startsWith("https://"))) {
+    if (incoming instanceof http2.Http2ServerRequest) {
+      throw new RequestError("Absolute URL for :path is not allowed in HTTP/2");
+    }
+    try {
+      const url2 = new URL(incomingUrl);
+      req[urlKey] = url2.href;
+    } catch (e2) {
+      throw new RequestError("Invalid absolute URL", { cause: e2 });
+    }
+    return req;
+  }
   const host = (incoming instanceof http2.Http2ServerRequest ? incoming.authority : incoming.headers.host) || defaultHostname;
   if (!host) {
     throw new RequestError("Missing host header");
   }
-  const url = new URL(
-    `${incoming instanceof http2.Http2ServerRequest || incoming.socket && incoming.socket.encrypted ? "https" : "http"}://${host}${incoming.url}`
-  );
+  let scheme;
+  if (incoming instanceof http2.Http2ServerRequest) {
+    scheme = incoming.scheme;
+    if (!(scheme === "http" || scheme === "https")) {
+      throw new RequestError("Unsupported scheme");
+    }
+  } else {
+    scheme = incoming.socket && incoming.socket.encrypted ? "https" : "http";
+  }
+  const url = new URL(`${scheme}://${host}${incomingUrl}`);
   if (url.hostname.length !== host.length && url.hostname !== host.replace(/:\d+$/, "")) {
     throw new RequestError("Invalid host header");
   }
   req[urlKey] = url.href;
   return req;
 };
-function writeFromReadableStream(stream3, writable) {
-  if (stream3.locked) {
+function writeFromReadableStream(stream4, writable) {
+  if (stream4.locked) {
     throw new TypeError("ReadableStream is locked.");
   } else if (writable.destroyed) {
-    stream3.cancel();
+    stream4.cancel();
     return;
   }
-  const reader = stream3.getReader();
+  const reader = stream4.getReader();
   writable.on("close", cancel);
   writable.on("error", cancel);
   reader.read().then(flow, cancel);
@@ -377,7 +402,7 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
   const resHeaderRecord = buildOutgoingHttpHeaders(res.headers);
   const internalBody = getInternalBody(res);
   if (internalBody) {
-    const { length, source, stream: stream3 } = internalBody;
+    const { length, source, stream: stream4 } = internalBody;
     if (source instanceof Uint8Array && source.byteLength !== length) ; else {
       if (length) {
         resHeaderRecord["content-length"] = length;
@@ -388,7 +413,7 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
       } else if (source instanceof Blob) {
         outgoing.end(new Uint8Array(await source.arrayBuffer()));
       } else {
-        await writeFromReadableStream(stream3, outgoing);
+        await writeFromReadableStream(stream4, outgoing);
       }
       return;
     }
@@ -461,7 +486,7 @@ var getRequestListener = (fetchCallback, options = {}) => {
       }
     }
     try {
-      return responseViaResponseObject(res, outgoing, options);
+      return await responseViaResponseObject(res, outgoing, options);
     } catch (e2) {
       return handleResponseError(e2, outgoing);
     }
@@ -492,18 +517,18 @@ var ENCODINGS = {
   gzip: ".gz"
 };
 var ENCODINGS_ORDERED_KEYS = Object.keys(ENCODINGS);
-var createStreamBody = (stream3) => {
+var createStreamBody = (stream4) => {
   const body = new ReadableStream({
     start(controller) {
-      stream3.on("data", (chunk) => {
+      stream4.on("data", (chunk) => {
         controller.enqueue(chunk);
       });
-      stream3.on("end", () => {
+      stream4.on("end", () => {
         controller.close();
       });
     },
     cancel() {
-      stream3.destroy();
+      stream4.destroy();
     }
   });
   return body;
@@ -599,10 +624,10 @@ var serveStatic = (options = { root: "" }) => {
       end = size - 1;
     }
     const chunksize = end - start + 1;
-    const stream3 = fs.createReadStream(path, { start, end });
+    const stream4 = fs.createReadStream(path, { start, end });
     c2.header("Content-Length", chunksize.toString());
     c2.header("Content-Range", `bytes ${start}-${end}/${stats.size}`);
-    return c2.body(createStreamBody(stream3), 206);
+    return c2.body(createStreamBody(stream4), 206);
   };
 };
 var RENDER_TYPE = {
@@ -723,7 +748,7 @@ var middleware = (options) => async (c2) => {
   );
 };
 
-// ../../node_modules/.pnpm/hono-openapi@0.4.6_hono@4.7.4_openapi-types@12.1.3_zod@3.24.3/node_modules/hono-openapi/utils.js
+// ../../node_modules/.pnpm/hono-openapi@0.4.6_hono@4.7.7_openapi-types@12.1.3_zod@3.24.4/node_modules/hono-openapi/utils.js
 var e = Symbol("openapi");
 var s2 = ["GET", "PUT", "POST", "DELETE", "OPTIONS", "HEAD", "PATCH", "TRACE"];
 var n = (e2) => e2.charAt(0).toUpperCase() + e2.slice(1);
@@ -849,6 +874,59 @@ async function x(e2, t2, s3 = {}) {
   }
   return { docs: o2, components: n2 };
 }
+async function getAgentCardByIdHandler(c2) {
+  const mastra = c2.get("mastra");
+  const agentId = c2.req.param("agentId");
+  const runtimeContext = c2.get("runtimeContext");
+  const result = await a2a.getAgentCardByIdHandler({
+    mastra,
+    agentId,
+    runtimeContext
+  });
+  return c2.json(result);
+}
+async function getAgentExecutionHandler(c2) {
+  const mastra = c2.get("mastra");
+  const agentId = c2.req.param("agentId");
+  const runtimeContext = c2.get("runtimeContext");
+  const logger2 = mastra.getLogger();
+  const body = await c2.req.json();
+  if (!["tasks/send", "tasks/sendSubscribe", "tasks/get", "tasks/cancel"].includes(body.method)) {
+    return c2.json({ error: { message: `Unsupported method: ${body.method}`, code: "invalid_method" } }, 400);
+  }
+  const result = await a2a.getAgentExecutionHandler({
+    mastra,
+    agentId,
+    runtimeContext,
+    requestId: crypto.randomUUID(),
+    method: body.method,
+    params: body.params,
+    logger: logger2
+  });
+  if (body.method === "tasks/sendSubscribe") {
+    return streaming.stream(
+      c2,
+      async (stream4) => {
+        try {
+          stream4.onAbort(() => {
+            if (!result.locked) {
+              return result.cancel();
+            }
+          });
+          for await (const chunk of result) {
+            await stream4.write(JSON.stringify(chunk) + "");
+          }
+        } catch (err) {
+          logger2.error("Error in tasks/sendSubscribe stream: " + err?.message);
+        }
+      },
+      async (err) => {
+        logger2.error("Error in tasks/sendSubscribe stream: " + err?.message);
+      }
+    );
+  }
+  return c2.json(result);
+}
 function handleError(error, defaultMessage) {
   const apiError = error;
   throw new httpException.HTTPException(apiError.status || 500, {
@@ -949,93 +1027,2010 @@ async function setAgentInstructionsHandler(c2) {
     if (!agentId || !instructions) {
       return c2.json({ error: "Missing required fields" }, 400);
     }
-    const mastra = c2.get("mastra");
-    const agent = mastra.getAgent(agentId);
-    if (!agent) {
-      return c2.json({ error: "Agent not found" }, 404);
+    const mastra = c2.get("mastra");
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      return c2.json({ error: "Agent not found" }, 404);
+    }
+    agent.__updateInstructions(instructions);
+    return c2.json(
+      {
+        instructions
+      },
+      200
+    );
+  } catch (error) {
+    return handleError(error, "Error setting agent instructions");
+  }
+}
+
+// src/server/handlers/client.ts
+var clients = /* @__PURE__ */ new Set();
+function handleClientsRefresh(c2) {
+  const stream4 = new ReadableStream({
+    start(controller) {
+      clients.add(controller);
+      controller.enqueue("data: connected\n\n");
+      c2.req.raw.signal.addEventListener("abort", () => {
+        clients.delete(controller);
+      });
+    }
+  });
+  return new Response(stream4, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
+      "Access-Control-Allow-Origin": "*"
+    }
+  });
+}
+function handleTriggerClientsRefresh(c2) {
+  clients.forEach((controller) => {
+    try {
+      controller.enqueue("data: refresh\n\n");
+    } catch {
+      clients.delete(controller);
+    }
+  });
+  return c2.json({ success: true, clients: clients.size });
+}
+async function getLogsHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const transportId = c2.req.query("transportId");
+    const logs$1 = await logs.getLogsHandler({
+      mastra,
+      transportId
+    });
+    return c2.json(logs$1);
+  } catch (error) {
+    return handleError(error, "Error getting logs");
+  }
+}
+async function getLogsByRunIdHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const runId = c2.req.param("runId");
+    const transportId = c2.req.query("transportId");
+    const logs$1 = await logs.getLogsByRunIdHandler({
+      mastra,
+      runId,
+      transportId
+    });
+    return c2.json(logs$1);
+  } catch (error) {
+    return handleError(error, "Error getting logs by run ID");
+  }
+}
+async function getLogTransports(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const result = await logs.getLogTransports({
+      mastra
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error getting log Transports");
+  }
+}
+var classRegExp = /^([A-Z][a-z0-9]*)+$/;
+var kTypes = [
+  "string",
+  "function",
+  "number",
+  "object",
+  // Accept 'Function' and 'Object' as alternative to the lower cased version.
+  "Function",
+  "Object",
+  "boolean",
+  "bigint",
+  "symbol"
+];
+function determineSpecificType(value) {
+  if (value == null) {
+    return "" + value;
+  }
+  if (typeof value === "function" && value.name) {
+    return `function ${value.name}`;
+  }
+  if (typeof value === "object") {
+    if (value.constructor?.name) {
+      return `an instance of ${value.constructor.name}`;
+    }
+    return `${util__default.default.inspect(value, { depth: -1 })}`;
+  }
+  let inspected = util__default.default.inspect(value, { colors: false });
+  if (inspected.length > 28) {
+    inspected = `${inspected.slice(0, 25)}...`;
+  }
+  return `type ${typeof value} (${inspected})`;
+}
+var ERR_HTTP_BODY_NOT_ALLOWED = class extends Error {
+  constructor() {
+    super("Adding content for this request method or response status is not allowed.");
+  }
+};
+var ERR_HTTP_CONTENT_LENGTH_MISMATCH = class extends Error {
+  constructor(actual, expected) {
+    super(`Response body's content-length of ${actual} byte(s) does not match the content-length of ${expected} byte(s) set in header`);
+  }
+};
+var ERR_HTTP_HEADERS_SENT = class extends Error {
+  constructor(arg) {
+    super(`Cannot ${arg} headers after they are sent to the client`);
+  }
+};
+var ERR_INVALID_ARG_VALUE = class extends TypeError {
+  constructor(name, value, reason = "is invalid") {
+    let inspected = util__default.default.inspect(value);
+    if (inspected.length > 128) {
+      inspected = `${inspected.slice(0, 128)}...`;
+    }
+    const type = name.includes(".") ? "property" : "argument";
+    super(`The ${type} '${name}' ${reason}. Received ${inspected}`);
+  }
+};
+var ERR_INVALID_CHAR = class extends TypeError {
+  constructor(name, field) {
+    let msg = `Invalid character in ${name}`;
+    if (field !== void 0) {
+      msg += ` ["${field}"]`;
+    }
+    super(msg);
+  }
+};
+var ERR_HTTP_INVALID_HEADER_VALUE = class extends TypeError {
+  constructor(value, name) {
+    super(`Invalid value "${value}" for header "${name}"`);
+  }
+};
+var ERR_HTTP_INVALID_STATUS_CODE = class extends RangeError {
+  originalStatusCode;
+  constructor(originalStatusCode) {
+    super(`Invalid status code: ${originalStatusCode}`);
+    this.originalStatusCode = originalStatusCode;
+  }
+};
+var ERR_HTTP_TRAILER_INVALID = class extends Error {
+  constructor() {
+    super(`Trailers are invalid with this transfer encoding`);
+  }
+};
+var ERR_INVALID_ARG_TYPE = class extends TypeError {
+  constructor(name, expected, actual) {
+    if (!Array.isArray(expected)) {
+      expected = [expected];
+    }
+    let msg = "The ";
+    if (name.endsWith(" argument")) {
+      msg += `${name} `;
+    } else {
+      const type = name.includes(".") ? "property" : "argument";
+      msg += `"${name}" ${type} `;
+    }
+    msg += "must be ";
+    const types = [];
+    const instances = [];
+    const other = [];
+    for (const value of expected) {
+      if (kTypes.includes(value)) {
+        types.push(value.toLowerCase());
+      } else if (classRegExp.exec(value) !== null) {
+        instances.push(value);
+      } else {
+        other.push(value);
+      }
+    }
+    if (instances.length > 0) {
+      const pos = types.indexOf("object");
+      if (pos !== -1) {
+        types.splice(pos, 1);
+        instances.push("Object");
+      }
+    }
+    if (types.length > 0) {
+      if (types.length > 2) {
+        const last = types.pop();
+        msg += `one of type ${types.join(", ")}, or ${last}`;
+      } else if (types.length === 2) {
+        msg += `one of type ${types[0]} or ${types[1]}`;
+      } else {
+        msg += `of type ${types[0]}`;
+      }
+      if (instances.length > 0 || other.length > 0)
+        msg += " or ";
+    }
+    if (instances.length > 0) {
+      if (instances.length > 2) {
+        const last = instances.pop();
+        msg += `an instance of ${instances.join(", ")}, or ${last}`;
+      } else {
+        msg += `an instance of ${instances[0]}`;
+        if (instances.length === 2) {
+          msg += ` or ${instances[1]}`;
+        }
+      }
+      if (other.length > 0)
+        msg += " or ";
+    }
+    if (other.length > 0) {
+      if (other.length > 2) {
+        const last = other.pop();
+        msg += `one of ${other.join(", ")}, or ${last}`;
+      } else if (other.length === 2) {
+        msg += `one of ${other[0]} or ${other[1]}`;
+      } else {
+        if (other[0].toLowerCase() !== other[0])
+          msg += "an ";
+        msg += `${other[0]}`;
+      }
+    }
+    msg += `. Received ${determineSpecificType(actual)}`;
+    super(msg);
+  }
+};
+var ERR_INVALID_HTTP_TOKEN = class extends TypeError {
+  constructor(name, field) {
+    super(`${name} must be a valid HTTP token ["${field}"]`);
+  }
+};
+var ERR_METHOD_NOT_IMPLEMENTED = class extends Error {
+  constructor(methodName) {
+    super(`The ${methodName} method is not implemented`);
+  }
+};
+var ERR_STREAM_ALREADY_FINISHED = class extends Error {
+  constructor(methodName) {
+    super(`Cannot call ${methodName} after a stream was finished`);
+  }
+};
+var ERR_STREAM_CANNOT_PIPE = class extends Error {
+  constructor() {
+    super(`Cannot pipe, not readable`);
+  }
+};
+var ERR_STREAM_DESTROYED = class extends Error {
+  constructor(methodName) {
+    super(`Cannot call ${methodName} after a stream was destroyed`);
+  }
+};
+var ERR_STREAM_NULL_VALUES = class extends TypeError {
+  constructor() {
+    super(`May not write null values to stream`);
+  }
+};
+var ERR_STREAM_WRITE_AFTER_END = class extends Error {
+  constructor() {
+    super(`write after end`);
+  }
+};
+
+// ../../node_modules/.pnpm/fetch-to-node@2.1.0/node_modules/fetch-to-node/dist/fetch-to-node/http-incoming.js
+var kHeaders = Symbol("kHeaders");
+var kHeadersDistinct = Symbol("kHeadersDistinct");
+var kHeadersCount = Symbol("kHeadersCount");
+var kTrailers = Symbol("kTrailers");
+var kTrailersDistinct = Symbol("kTrailersDistinct");
+var kTrailersCount = Symbol("kTrailersCount");
+var FetchIncomingMessage = class extends stream.Readable {
+  get socket() {
+    return null;
+  }
+  set socket(_val) {
+    throw new ERR_METHOD_NOT_IMPLEMENTED("socket");
+  }
+  httpVersionMajor;
+  httpVersionMinor;
+  httpVersion;
+  complete = false;
+  [kHeaders] = null;
+  [kHeadersDistinct] = null;
+  [kHeadersCount] = 0;
+  rawHeaders = [];
+  [kTrailers] = null;
+  [kTrailersDistinct] = null;
+  [kTrailersCount] = 0;
+  rawTrailers = [];
+  joinDuplicateHeaders = false;
+  aborted = false;
+  upgrade = false;
+  // request (server) only
+  url = "";
+  method;
+  // TODO: Support ClientRequest
+  // statusCode = null;
+  // statusMessage = null;
+  // client = socket;
+  _consuming;
+  _dumped;
+  // The underlying ReadableStream
+  _stream = null;
+  constructor() {
+    const streamOptions = {};
+    super(streamOptions);
+    this._readableState.readingMore = true;
+    this._consuming = false;
+    this._dumped = false;
+  }
+  get connection() {
+    return null;
+  }
+  set connection(_socket) {
+    console.error("No support for IncomingMessage.connection");
+  }
+  get headers() {
+    if (!this[kHeaders]) {
+      this[kHeaders] = {};
+      const src = this.rawHeaders;
+      const dst = this[kHeaders];
+      for (let n2 = 0; n2 < this[kHeadersCount]; n2 += 2) {
+        this._addHeaderLine(src[n2], src[n2 + 1], dst);
+      }
+    }
+    return this[kHeaders];
+  }
+  set headers(val) {
+    this[kHeaders] = val;
+  }
+  get headersDistinct() {
+    if (!this[kHeadersDistinct]) {
+      this[kHeadersDistinct] = {};
+      const src = this.rawHeaders;
+      const dst = this[kHeadersDistinct];
+      for (let n2 = 0; n2 < this[kHeadersCount]; n2 += 2) {
+        this._addHeaderLineDistinct(src[n2], src[n2 + 1], dst);
+      }
+    }
+    return this[kHeadersDistinct];
+  }
+  set headersDistinct(val) {
+    this[kHeadersDistinct] = val;
+  }
+  get trailers() {
+    if (!this[kTrailers]) {
+      this[kTrailers] = {};
+      const src = this.rawTrailers;
+      const dst = this[kTrailers];
+      for (let n2 = 0; n2 < this[kTrailersCount]; n2 += 2) {
+        this._addHeaderLine(src[n2], src[n2 + 1], dst);
+      }
+    }
+    return this[kTrailers];
+  }
+  set trailers(val) {
+    this[kTrailers] = val;
+  }
+  get trailersDistinct() {
+    if (!this[kTrailersDistinct]) {
+      this[kTrailersDistinct] = {};
+      const src = this.rawTrailers;
+      const dst = this[kTrailersDistinct];
+      for (let n2 = 0; n2 < this[kTrailersCount]; n2 += 2) {
+        this._addHeaderLineDistinct(src[n2], src[n2 + 1], dst);
+      }
+    }
+    return this[kTrailersDistinct];
+  }
+  set trailersDistinct(val) {
+    this[kTrailersDistinct] = val;
+  }
+  setTimeout(msecs, callback) {
+    return this;
+  }
+  async _read(n2) {
+    if (!this._consuming) {
+      this._readableState.readingMore = false;
+      this._consuming = true;
+    }
+    if (this._stream == null) {
+      this.complete = true;
+      this.push(null);
+      return;
+    }
+    const reader = this._stream.getReader();
+    try {
+      const data = await reader.read();
+      if (data.done) {
+        this.complete = true;
+        this.push(null);
+      } else {
+        this.push(data.value);
+      }
+    } catch (e2) {
+      this.destroy(e2);
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  _destroy(err, cb) {
+    if (!this.readableEnded || !this.complete) {
+      this.aborted = true;
+      this.emit("aborted");
+    }
+    setTimeout(onError, 0, this, err, cb);
+  }
+  _addHeaderLines(headers, n2) {
+    if (headers?.length) {
+      let dest;
+      if (this.complete) {
+        this.rawTrailers = headers;
+        this[kTrailersCount] = n2;
+        dest = this[kTrailers];
+      } else {
+        this.rawHeaders = headers;
+        this[kHeadersCount] = n2;
+        dest = this[kHeaders];
+      }
+      if (dest) {
+        for (let i2 = 0; i2 < n2; i2 += 2) {
+          this._addHeaderLine(headers[i2], headers[i2 + 1], dest);
+        }
+      }
+    }
+  }
+  // Add the given (field, value) pair to the message
+  //
+  // Per RFC2616, section 4.2 it is acceptable to join multiple instances of the
+  // same header with a ', ' if the header in question supports specification of
+  // multiple values this way. The one exception to this is the Cookie header,
+  // which has multiple values joined with a '; ' instead. If a header's values
+  // cannot be joined in either of these ways, we declare the first instance the
+  // winner and drop the second. Extended header fields (those beginning with
+  // 'x-') are always joined.
+  _addHeaderLine(field, value, dest) {
+    field = matchKnownFields(field);
+    const flag = field.charCodeAt(0);
+    if (flag === 0 || flag === 2) {
+      field = field.slice(1);
+      if (typeof dest[field] === "string") {
+        dest[field] += (flag === 0 ? ", " : "; ") + value;
+      } else {
+        dest[field] = value;
+      }
+    } else if (flag === 1) {
+      if (dest["set-cookie"] !== void 0) {
+        dest["set-cookie"].push(value);
+      } else {
+        dest["set-cookie"] = [value];
+      }
+    } else if (this.joinDuplicateHeaders) {
+      if (dest[field] === void 0) {
+        dest[field] = value;
+      } else {
+        dest[field] += ", " + value;
+      }
+    } else if (dest[field] === void 0) {
+      dest[field] = value;
+    }
+  }
+  _addHeaderLineDistinct(field, value, dest) {
+    field = field.toLowerCase();
+    if (!dest[field]) {
+      dest[field] = [value];
+    } else {
+      dest[field].push(value);
+    }
+  }
+  // Call this instead of resume() if we want to just
+  // dump all the data to /dev/null
+  _dump() {
+    if (!this._dumped) {
+      this._dumped = true;
+      this.removeAllListeners("data");
+      this.resume();
+    }
+  }
+};
+function matchKnownFields(field, lowercased = false) {
+  switch (field.length) {
+    case 3:
+      if (field === "Age" || field === "age")
+        return "age";
+      break;
+    case 4:
+      if (field === "Host" || field === "host")
+        return "host";
+      if (field === "From" || field === "from")
+        return "from";
+      if (field === "ETag" || field === "etag")
+        return "etag";
+      if (field === "Date" || field === "date")
+        return "\0date";
+      if (field === "Vary" || field === "vary")
+        return "\0vary";
+      break;
+    case 6:
+      if (field === "Server" || field === "server")
+        return "server";
+      if (field === "Cookie" || field === "cookie")
+        return "cookie";
+      if (field === "Origin" || field === "origin")
+        return "\0origin";
+      if (field === "Expect" || field === "expect")
+        return "\0expect";
+      if (field === "Accept" || field === "accept")
+        return "\0accept";
+      break;
+    case 7:
+      if (field === "Referer" || field === "referer")
+        return "referer";
+      if (field === "Expires" || field === "expires")
+        return "expires";
+      if (field === "Upgrade" || field === "upgrade")
+        return "\0upgrade";
+      break;
+    case 8:
+      if (field === "Location" || field === "location")
+        return "location";
+      if (field === "If-Match" || field === "if-match")
+        return "\0if-match";
+      break;
+    case 10:
+      if (field === "User-Agent" || field === "user-agent")
+        return "user-agent";
+      if (field === "Set-Cookie" || field === "set-cookie")
+        return "
";
+      if (field === "Connection" || field === "connection")
+        return "\0connection";
+      break;
+    case 11:
+      if (field === "Retry-After" || field === "retry-after")
+        return "retry-after";
+      break;
+    case 12:
+      if (field === "Content-Type" || field === "content-type")
+        return "content-type";
+      if (field === "Max-Forwards" || field === "max-forwards")
+        return "max-forwards";
+      break;
+    case 13:
+      if (field === "Authorization" || field === "authorization")
+        return "authorization";
+      if (field === "Last-Modified" || field === "last-modified")
+        return "last-modified";
+      if (field === "Cache-Control" || field === "cache-control")
+        return "\0cache-control";
+      if (field === "If-None-Match" || field === "if-none-match")
+        return "\0if-none-match";
+      break;
+    case 14:
+      if (field === "Content-Length" || field === "content-length")
+        return "content-length";
+      break;
+    case 15:
+      if (field === "Accept-Encoding" || field === "accept-encoding")
+        return "\0accept-encoding";
+      if (field === "Accept-Language" || field === "accept-language")
+        return "\0accept-language";
+      if (field === "X-Forwarded-For" || field === "x-forwarded-for")
+        return "\0x-forwarded-for";
+      break;
+    case 16:
+      if (field === "Content-Encoding" || field === "content-encoding")
+        return "\0content-encoding";
+      if (field === "X-Forwarded-Host" || field === "x-forwarded-host")
+        return "\0x-forwarded-host";
+      break;
+    case 17:
+      if (field === "If-Modified-Since" || field === "if-modified-since")
+        return "if-modified-since";
+      if (field === "Transfer-Encoding" || field === "transfer-encoding")
+        return "\0transfer-encoding";
+      if (field === "X-Forwarded-Proto" || field === "x-forwarded-proto")
+        return "\0x-forwarded-proto";
+      break;
+    case 19:
+      if (field === "Proxy-Authorization" || field === "proxy-authorization")
+        return "proxy-authorization";
+      if (field === "If-Unmodified-Since" || field === "if-unmodified-since")
+        return "if-unmodified-since";
+      break;
+  }
+  if (lowercased) {
+    return "\0" + field;
+  }
+  return matchKnownFields(field.toLowerCase(), true);
+}
+function onError(self, error, cb) {
+  if (self.listenerCount("error") === 0) {
+    cb();
+  } else {
+    cb(error);
+  }
+}
+
+// ../../node_modules/.pnpm/fetch-to-node@2.1.0/node_modules/fetch-to-node/dist/utils/types.js
+function validateString(value, name) {
+  if (typeof value !== "string")
+    throw new ERR_INVALID_ARG_TYPE(name, "string", value);
+}
+var linkValueRegExp = /^(?:<[^>]*>)(?:\s*;\s*[^;"\s]+(?:=(")?[^;"\s]*\1)?)*$/;
+function validateLinkHeaderFormat(value, name) {
+  if (typeof value === "undefined" || !linkValueRegExp.exec(value)) {
+    throw new ERR_INVALID_ARG_VALUE(name, value, 'must be an array or string of format "</styles.css>; rel=preload; as=style"');
+  }
+}
+function validateLinkHeaderValue(hints) {
+  if (typeof hints === "string") {
+    validateLinkHeaderFormat(hints, "hints");
+    return hints;
+  } else if (Array.isArray(hints)) {
+    const hintsLength = hints.length;
+    let result = "";
+    if (hintsLength === 0) {
+      return result;
+    }
+    for (let i2 = 0; i2 < hintsLength; i2++) {
+      const link = hints[i2];
+      validateLinkHeaderFormat(link, "hints");
+      result += link;
+      if (i2 !== hintsLength - 1) {
+        result += ", ";
+      }
+    }
+    return result;
+  }
+  throw new ERR_INVALID_ARG_VALUE("hints", hints, 'must be an array or string of format "</styles.css>; rel=preload; as=style"');
+}
+function isUint8Array(value) {
+  return value != null && value[Symbol.toStringTag] === "Uint8Array";
+}
+
+// ../../node_modules/.pnpm/fetch-to-node@2.1.0/node_modules/fetch-to-node/dist/fetch-to-node/internal-http.js
+var kNeedDrain = Symbol("kNeedDrain");
+var kOutHeaders = Symbol("kOutHeaders");
+function utcDate() {
+  return (/* @__PURE__ */ new Date()).toUTCString();
+}
+
+// ../../node_modules/.pnpm/fetch-to-node@2.1.0/node_modules/fetch-to-node/dist/fetch-to-node/internal-streams-state.js
+function getDefaultHighWaterMark(objectMode) {
+  return objectMode ? 16 : 64 * 1024;
+}
+
+// ../../node_modules/.pnpm/fetch-to-node@2.1.0/node_modules/fetch-to-node/dist/fetch-to-node/http-common.js
+var tokenRegExp = /^[\^_`a-zA-Z\-0-9!#$%&'*+.|~]+$/;
+function checkIsHttpToken(val) {
+  return tokenRegExp.test(val);
+}
+var headerCharRegex = /[^\t\x20-\x7e\x80-\xff]/;
+function checkInvalidHeaderChar(val) {
+  return headerCharRegex.test(val);
+}
+var chunkExpression = /(?:^|\W)chunked(?:$|\W)/i;
+var kCorked = Symbol("corked");
+var kChunkedBuffer = Symbol("kChunkedBuffer");
+var kChunkedLength = Symbol("kChunkedLength");
+var kUniqueHeaders = Symbol("kUniqueHeaders");
+var kBytesWritten = Symbol("kBytesWritten");
+var kErrored = Symbol("errored");
+var kHighWaterMark = Symbol("kHighWaterMark");
+var kRejectNonStandardBodyWrites = Symbol("kRejectNonStandardBodyWrites");
+var nop = () => {
+};
+var RE_CONN_CLOSE = /(?:^|\W)close(?:$|\W)/i;
+function isCookieField(s3) {
+  return s3.length === 6 && s3.toLowerCase() === "cookie";
+}
+function isContentDispositionField(s3) {
+  return s3.length === 19 && s3.toLowerCase() === "content-disposition";
+}
+var WrittenDataBuffer = class {
+  [kCorked] = 0;
+  [kHighWaterMark] = getDefaultHighWaterMark();
+  entries = [];
+  onWrite;
+  constructor(params = {}) {
+    this.onWrite = params.onWrite;
+  }
+  write(data, encoding, callback) {
+    this.entries.push({
+      data,
+      length: data.length,
+      encoding,
+      callback,
+      written: false
+    });
+    this._flush();
+    return true;
+  }
+  cork() {
+    this[kCorked]++;
+  }
+  uncork() {
+    this[kCorked]--;
+    this._flush();
+  }
+  _flush() {
+    if (this[kCorked] <= 0) {
+      for (const [index, entry] of this.entries.entries()) {
+        if (!entry.written) {
+          entry.written = true;
+          if (this.onWrite != null) {
+            this.onWrite(index, entry);
+          }
+          if (entry.callback != null) {
+            entry.callback.call(void 0);
+          }
+        }
+      }
+    }
+  }
+  get writableLength() {
+    return this.entries.reduce((acc, entry) => {
+      return acc + (entry.written && entry.length ? entry.length : 0);
+    }, 0);
+  }
+  get writableHighWaterMark() {
+    return this[kHighWaterMark];
+  }
+  get writableCorked() {
+    return this[kCorked];
+  }
+};
+var FetchOutgoingMessage = class extends stream.Writable {
+  req;
+  outputData;
+  outputSize;
+  // Difference from Node.js -
+  // `writtenHeaderBytes` is the number of bytes the header has taken.
+  // Since Node.js writes both the headers and body into the same outgoing
+  // stream, it helps to keep track of this so that we can skip that many bytes
+  // from the beginning of the stream when providing the outgoing stream.
+  writtenHeaderBytes = 0;
+  _last;
+  chunkedEncoding;
+  shouldKeepAlive;
+  maxRequestsOnConnectionReached;
+  _defaultKeepAlive;
+  useChunkedEncodingByDefault;
+  sendDate;
+  _removedConnection;
+  _removedContLen;
+  _removedTE;
+  strictContentLength;
+  [kBytesWritten];
+  _contentLength;
+  _hasBody;
+  _trailer;
+  [kNeedDrain];
+  finished;
+  _headerSent;
+  [kCorked];
+  [kChunkedBuffer];
+  [kChunkedLength];
+  _closed;
+  // Difference from Node.js -
+  // In Node.js, this is a socket object.
+  // [kSocket]: null;
+  _header;
+  [kOutHeaders];
+  _keepAliveTimeout;
+  _maxRequestsPerSocket;
+  _onPendingData;
+  [kUniqueHeaders];
+  [kErrored];
+  [kHighWaterMark];
+  [kRejectNonStandardBodyWrites];
+  _writtenDataBuffer = new WrittenDataBuffer({
+    onWrite: this._onDataWritten.bind(this)
+  });
+  constructor(req, options) {
+    super();
+    this.req = req;
+    this.outputData = [];
+    this.outputSize = 0;
+    this.destroyed = false;
+    this._last = false;
+    this.chunkedEncoding = false;
+    this.shouldKeepAlive = true;
+    this.maxRequestsOnConnectionReached = false;
+    this._defaultKeepAlive = true;
+    this.useChunkedEncodingByDefault = true;
+    this.sendDate = false;
+    this._removedConnection = false;
+    this._removedContLen = false;
+    this._removedTE = false;
+    this.strictContentLength = false;
+    this[kBytesWritten] = 0;
+    this._contentLength = null;
+    this._hasBody = true;
+    this._trailer = "";
+    this[kNeedDrain] = false;
+    this.finished = false;
+    this._headerSent = false;
+    this[kCorked] = 0;
+    this[kChunkedBuffer] = [];
+    this[kChunkedLength] = 0;
+    this._closed = false;
+    this._header = null;
+    this[kOutHeaders] = null;
+    this._keepAliveTimeout = 0;
+    this._onPendingData = nop;
+    this[kErrored] = null;
+    this[kHighWaterMark] = options?.highWaterMark ?? getDefaultHighWaterMark();
+    this[kRejectNonStandardBodyWrites] = options?.rejectNonStandardBodyWrites ?? false;
+    this[kUniqueHeaders] = null;
+  }
+  _renderHeaders() {
+    if (this._header) {
+      throw new ERR_HTTP_HEADERS_SENT("render");
+    }
+    const headersMap = this[kOutHeaders];
+    const headers = {};
+    if (headersMap !== null) {
+      const keys = Object.keys(headersMap);
+      for (let i2 = 0, l2 = keys.length; i2 < l2; i2++) {
+        const key = keys[i2];
+        headers[headersMap[key][0]] = headersMap[key][1];
+      }
+    }
+    return headers;
+  }
+  cork() {
+    this[kCorked]++;
+    if (this._writtenDataBuffer != null) {
+      this._writtenDataBuffer.cork();
+    }
+  }
+  uncork() {
+    this[kCorked]--;
+    if (this._writtenDataBuffer != null) {
+      this._writtenDataBuffer.uncork();
+    }
+    if (this[kCorked] || this[kChunkedBuffer].length === 0) {
+      return;
+    }
+    const buf = this[kChunkedBuffer];
+    for (const { data, encoding, callback } of buf) {
+      this._send(data ?? "", encoding, callback);
+    }
+    this[kChunkedBuffer].length = 0;
+    this[kChunkedLength] = 0;
+  }
+  setTimeout(msecs, callback) {
+    return this;
+  }
+  destroy(error) {
+    if (this.destroyed) {
+      return this;
+    }
+    this.destroyed = true;
+    this[kErrored] = error;
+    return this;
+  }
+  _send(data, encoding, callback, byteLength) {
+    if (!this._headerSent) {
+      const header = this._header;
+      if (typeof data === "string" && (encoding === "utf8" || encoding === "latin1" || !encoding)) {
+        data = header + data;
+      } else {
+        this.outputData.unshift({
+          data: header,
+          encoding: "latin1",
+          callback: void 0
+        });
+        this.outputSize += header.length;
+        this._onPendingData(header.length);
+      }
+      this._headerSent = true;
+      this.writtenHeaderBytes = header.length;
+      const [statusLine, ...headerLines] = this._header.split("\r\n");
+      const STATUS_LINE_REGEXP = /^HTTP\/1\.1 (?<statusCode>\d+) (?<statusMessage>.*)$/;
+      const statusLineResult = STATUS_LINE_REGEXP.exec(statusLine);
+      if (statusLineResult == null) {
+        throw new Error("Unexpected! Status line was " + statusLine);
+      }
+      const { statusCode: statusCodeText, statusMessage } = statusLineResult.groups ?? {};
+      const statusCode = parseInt(statusCodeText, 10);
+      const headers = [];
+      for (const headerLine of headerLines) {
+        if (headerLine !== "") {
+          const pos = headerLine.indexOf(": ");
+          const k = headerLine.slice(0, pos);
+          const v = headerLine.slice(pos + 2);
+          headers.push([k, v]);
+        }
+      }
+      const event = {
+        statusCode,
+        statusMessage,
+        headers
+      };
+      this.emit("_headersSent", event);
+    }
+    return this._writeRaw(data, encoding, callback, byteLength);
+  }
+  _writeRaw(data, encoding, callback, size) {
+    if (typeof encoding === "function") {
+      callback = encoding;
+      encoding = null;
+    }
+    if (this._writtenDataBuffer != null) {
+      if (this.outputData.length) {
+        this._flushOutput(this._writtenDataBuffer);
+      }
+      return this._writtenDataBuffer.write(data, encoding, callback);
+    }
+    this.outputData.push({ data, encoding, callback });
+    this.outputSize += data.length;
+    this._onPendingData(data.length);
+    return this.outputSize < this[kHighWaterMark];
+  }
+  _onDataWritten(index, entry) {
+    const event = { index, entry };
+    this.emit("_dataWritten", event);
+  }
+  _storeHeader(firstLine, headers) {
+    const state = {
+      connection: false,
+      contLen: false,
+      te: false,
+      date: false,
+      expect: false,
+      trailer: false,
+      header: firstLine
+    };
+    if (headers) {
+      if (headers === this[kOutHeaders]) {
+        for (const key in headers) {
+          const entry = headers[key];
+          processHeader(this, state, entry[0], entry[1], false);
+        }
+      } else if (Array.isArray(headers)) {
+        if (headers.length && Array.isArray(headers[0])) {
+          for (let i2 = 0; i2 < headers.length; i2++) {
+            const entry = headers[i2];
+            processHeader(this, state, entry[0], entry[1], true);
+          }
+        } else {
+          if (headers.length % 2 !== 0) {
+            throw new ERR_INVALID_ARG_VALUE("headers", headers);
+          }
+          for (let n2 = 0; n2 < headers.length; n2 += 2) {
+            processHeader(this, state, headers[n2], headers[n2 + 1], true);
+          }
+        }
+      } else {
+        for (const key in headers) {
+          if (headers.hasOwnProperty(key)) {
+            const _headers = headers;
+            processHeader(this, state, key, _headers[key], true);
+          }
+        }
+      }
+    }
+    let { header } = state;
+    if (this.sendDate && !state.date) {
+      header += "Date: " + utcDate() + "\r\n";
+    }
+    if (this.chunkedEncoding && (this.statusCode === 204 || this.statusCode === 304)) {
+      this.chunkedEncoding = false;
+      this.shouldKeepAlive = false;
+    }
+    if (this._removedConnection) {
+      this._last = !this.shouldKeepAlive;
+    } else if (!state.connection) {
+      const shouldSendKeepAlive = this.shouldKeepAlive && (state.contLen || this.useChunkedEncodingByDefault);
+      if (shouldSendKeepAlive && this.maxRequestsOnConnectionReached) {
+        header += "Connection: close\r\n";
+      } else if (shouldSendKeepAlive) {
+        header += "Connection: keep-alive\r\n";
+        if (this._keepAliveTimeout && this._defaultKeepAlive) {
+          const timeoutSeconds = Math.floor(this._keepAliveTimeout / 1e3);
+          let max = "";
+          if (this._maxRequestsPerSocket && ~~this._maxRequestsPerSocket > 0) {
+            max = `, max=${this._maxRequestsPerSocket}`;
+          }
+          header += `Keep-Alive: timeout=${timeoutSeconds}${max}\r
+`;
+        }
+      } else {
+        this._last = true;
+        header += "Connection: close\r\n";
+      }
+    }
+    if (!state.contLen && !state.te) {
+      if (!this._hasBody) {
+        this.chunkedEncoding = false;
+      } else if (!this.useChunkedEncodingByDefault) {
+        this._last = true;
+      } else if (!state.trailer && !this._removedContLen && typeof this._contentLength === "number") {
+        header += "Content-Length: " + this._contentLength + "\r\n";
+      } else if (!this._removedTE) {
+        header += "Transfer-Encoding: chunked\r\n";
+        this.chunkedEncoding = true;
+      } else {
+        this._last = true;
+      }
+    }
+    if (this.chunkedEncoding !== true && state.trailer) {
+      throw new ERR_HTTP_TRAILER_INVALID();
+    }
+    this._header = header + "\r\n";
+    this._headerSent = false;
+    if (state.expect) {
+      this._send("");
+    }
+  }
+  get _headers() {
+    console.warn("DEP0066: OutgoingMessage.prototype._headers is deprecated");
+    return this.getHeaders();
+  }
+  set _headers(val) {
+    console.warn("DEP0066: OutgoingMessage.prototype._headers is deprecated");
+    if (val == null) {
+      this[kOutHeaders] = null;
+    } else if (typeof val === "object") {
+      const headers = this[kOutHeaders] = /* @__PURE__ */ Object.create(null);
+      const keys = Object.keys(val);
+      for (let i2 = 0; i2 < keys.length; ++i2) {
+        const name = keys[i2];
+        headers[name.toLowerCase()] = [name, val[name]];
+      }
+    }
+  }
+  get connection() {
+    return null;
+  }
+  set connection(_socket) {
+    console.error("No support for OutgoingMessage.connection");
+  }
+  get socket() {
+    return null;
+  }
+  set socket(_socket) {
+    console.error("No support for OutgoingMessage.socket");
+  }
+  get _headerNames() {
+    console.warn("DEP0066: OutgoingMessage.prototype._headerNames is deprecated");
+    const headers = this[kOutHeaders];
+    if (headers !== null) {
+      const out = /* @__PURE__ */ Object.create(null);
+      const keys = Object.keys(headers);
+      for (let i2 = 0; i2 < keys.length; ++i2) {
+        const key = keys[i2];
+        const val = headers[key][0];
+        out[key] = val;
+      }
+      return out;
+    }
+    return null;
+  }
+  set _headerNames(val) {
+    console.warn("DEP0066: OutgoingMessage.prototype._headerNames is deprecated");
+    if (typeof val === "object" && val !== null) {
+      const headers = this[kOutHeaders];
+      if (!headers)
+        return;
+      const keys = Object.keys(val);
+      for (let i2 = 0; i2 < keys.length; ++i2) {
+        const header = headers[keys[i2]];
+        if (header)
+          header[0] = val[keys[i2]];
+      }
+    }
+  }
+  setHeader(name, value) {
+    if (this._header) {
+      throw new ERR_HTTP_HEADERS_SENT("set");
+    }
+    validateHeaderName(name);
+    validateHeaderValue(name, value);
+    let headers = this[kOutHeaders];
+    if (headers === null) {
+      this[kOutHeaders] = headers = { __proto__: null };
+    }
+    headers[name.toLowerCase()] = [name, value];
+    return this;
+  }
+  setHeaders(headers) {
+    if (this._header) {
+      throw new ERR_HTTP_HEADERS_SENT("set");
+    }
+    if (!headers || Array.isArray(headers) || typeof headers.keys !== "function" || typeof headers.get !== "function") {
+      throw new ERR_INVALID_ARG_TYPE("headers", ["Headers", "Map"], headers);
+    }
+    const cookies = [];
+    for (const { 0: key, 1: value } of headers) {
+      if (key === "set-cookie") {
+        if (Array.isArray(value)) {
+          cookies.push(...value);
+        } else {
+          cookies.push(value);
+        }
+        continue;
+      }
+      this.setHeader(key, value);
+    }
+    if (cookies.length) {
+      this.setHeader("set-cookie", cookies);
+    }
+    return this;
+  }
+  appendHeader(name, value) {
+    if (this._header) {
+      throw new ERR_HTTP_HEADERS_SENT("append");
+    }
+    validateHeaderName(name);
+    validateHeaderValue(name, value);
+    const field = name.toLowerCase();
+    const headers = this[kOutHeaders];
+    if (headers === null || !headers[field]) {
+      return this.setHeader(name, value);
+    }
+    if (!Array.isArray(headers[field][1])) {
+      headers[field][1] = [headers[field][1]];
+    }
+    const existingValues = headers[field][1];
+    if (Array.isArray(value)) {
+      for (let i2 = 0, length = value.length; i2 < length; i2++) {
+        existingValues.push(value[i2]);
+      }
+    } else {
+      existingValues.push(value);
+    }
+    return this;
+  }
+  getHeader(name) {
+    validateString(name, "name");
+    const headers = this[kOutHeaders];
+    if (headers === null) {
+      return;
+    }
+    const entry = headers[name.toLowerCase()];
+    return entry?.[1];
+  }
+  getHeaderNames() {
+    return this[kOutHeaders] !== null ? Object.keys(this[kOutHeaders]) : [];
+  }
+  getRawHeaderNames() {
+    const headersMap = this[kOutHeaders];
+    if (headersMap === null)
+      return [];
+    const values = Object.values(headersMap);
+    const headers = Array(values.length);
+    for (let i2 = 0, l2 = values.length; i2 < l2; i2++) {
+      headers[i2] = values[i2][0];
+    }
+    return headers;
+  }
+  getHeaders() {
+    const headers = this[kOutHeaders];
+    const ret = { __proto__: null };
+    if (headers) {
+      const keys = Object.keys(headers);
+      for (let i2 = 0; i2 < keys.length; ++i2) {
+        const key = keys[i2];
+        const val = headers[key][1];
+        ret[key] = val;
+      }
+    }
+    return ret;
+  }
+  hasHeader(name) {
+    validateString(name, "name");
+    return this[kOutHeaders] !== null && !!this[kOutHeaders][name.toLowerCase()];
+  }
+  removeHeader(name) {
+    validateString(name, "name");
+    if (this._header) {
+      throw new ERR_HTTP_HEADERS_SENT("remove");
+    }
+    const key = name.toLowerCase();
+    switch (key) {
+      case "connection":
+        this._removedConnection = true;
+        break;
+      case "content-length":
+        this._removedContLen = true;
+        break;
+      case "transfer-encoding":
+        this._removedTE = true;
+        break;
+      case "date":
+        this.sendDate = false;
+        break;
+    }
+    if (this[kOutHeaders] !== null) {
+      delete this[kOutHeaders][key];
+    }
+  }
+  _implicitHeader() {
+    throw new ERR_METHOD_NOT_IMPLEMENTED("_implicitHeader()");
+  }
+  get headersSent() {
+    return !!this._header;
+  }
+  write(chunk, encoding, callback) {
+    if (typeof encoding === "function") {
+      callback = encoding;
+      encoding = null;
+    }
+    const ret = write_(this, chunk, encoding, callback, false);
+    if (!ret) {
+      this[kNeedDrain] = true;
+    }
+    return ret;
+  }
+  addTrailers(headers) {
+    this._trailer = "";
+    const isArray = Array.isArray(headers);
+    const keys = isArray ? [...headers.keys()] : Object.keys(headers);
+    for (let i2 = 0, l2 = keys.length; i2 < l2; i2++) {
+      let field, value;
+      if (isArray) {
+        const _headers = headers;
+        const key = keys[i2];
+        field = _headers[key][0];
+        value = _headers[key][1];
+      } else {
+        const _headers = headers;
+        const key = keys[i2];
+        field = key;
+        value = _headers[key];
+      }
+      validateHeaderName(field, "Trailer name");
+      if (Array.isArray(value) && value.length > 1 && (!this[kUniqueHeaders] || !this[kUniqueHeaders].has(field.toLowerCase()))) {
+        for (let j = 0, l3 = value.length; j < l3; j++) {
+          if (checkInvalidHeaderChar(value[j])) {
+            throw new ERR_INVALID_CHAR("trailer content", field);
+          }
+          this._trailer += field + ": " + value[j] + "\r\n";
+        }
+      } else {
+        if (Array.isArray(value)) {
+          value = value.join("; ");
+        }
+        if (checkInvalidHeaderChar(String(value))) {
+          throw new ERR_INVALID_CHAR("trailer content", field);
+        }
+        this._trailer += field + ": " + value + "\r\n";
+      }
+    }
+  }
+  end(chunk, encoding, callback) {
+    if (typeof chunk === "function") {
+      callback = chunk;
+      chunk = null;
+      encoding = null;
+    } else if (typeof encoding === "function") {
+      callback = encoding;
+      encoding = null;
+    }
+    if (chunk) {
+      if (this.finished) {
+        onError2(this, new ERR_STREAM_WRITE_AFTER_END(), typeof callback !== "function" ? nop : callback);
+        return this;
+      }
+      if (this._writtenDataBuffer != null) {
+        this._writtenDataBuffer.cork();
+      }
+      write_(this, chunk, encoding, null, true);
+    } else if (this.finished) {
+      if (typeof callback === "function") {
+        if (!this.writableFinished) {
+          this.on("finish", callback);
+        } else {
+          callback(new ERR_STREAM_ALREADY_FINISHED("end"));
+        }
+      }
+      return this;
+    } else if (!this._header) {
+      if (this._writtenDataBuffer != null) {
+        this._writtenDataBuffer.cork();
+      }
+      this._contentLength = 0;
+      this._implicitHeader();
+    }
+    if (typeof callback === "function")
+      this.once("finish", callback);
+    if (strictContentLength(this) && this[kBytesWritten] !== this._contentLength) {
+      throw new ERR_HTTP_CONTENT_LENGTH_MISMATCH(this[kBytesWritten], this._contentLength);
+    }
+    const finish = onFinish.bind(void 0, this);
+    if (this._hasBody && this.chunkedEncoding) {
+      this._send("", "latin1", finish);
+    } else if (!this._headerSent || this.writableLength || chunk) {
+      this._send("", "latin1", finish);
+    } else {
+      setTimeout(finish, 0);
+    }
+    if (this._writtenDataBuffer != null) {
+      this._writtenDataBuffer.uncork();
+    }
+    this[kCorked] = 1;
+    this.uncork();
+    this.finished = true;
+    if (this.outputData.length === 0 && this._writtenDataBuffer != null) {
+      this._finish();
+    }
+    return this;
+  }
+  _finish() {
+    this.emit("prefinish");
+  }
+  // No _flush() implementation?
+  _flush() {
+    if (this._writtenDataBuffer != null) {
+      const ret = this._flushOutput(this._writtenDataBuffer);
+      if (this.finished) {
+        this._finish();
+      } else if (ret && this[kNeedDrain]) {
+        this[kNeedDrain] = false;
+        this.emit("drain");
+      }
+    }
+  }
+  _flushOutput(dataBuffer) {
+    while (this[kCorked]) {
+      this[kCorked]--;
+      dataBuffer.cork();
+    }
+    const outputLength = this.outputData.length;
+    if (outputLength <= 0) {
+      return void 0;
+    }
+    const outputData = this.outputData;
+    dataBuffer.cork();
+    let ret;
+    for (let i2 = 0; i2 < outputLength; i2++) {
+      const { data, encoding, callback } = outputData[i2];
+      outputData[i2].data = null;
+      ret = dataBuffer.write(data ?? "", encoding, callback);
+    }
+    dataBuffer.uncork();
+    this.outputData = [];
+    this._onPendingData(-this.outputSize);
+    this.outputSize = 0;
+    return ret;
+  }
+  flushHeaders() {
+    if (!this._header) {
+      this._implicitHeader();
+    }
+    this._send("");
+  }
+  pipe(destination) {
+    this.emit("error", new ERR_STREAM_CANNOT_PIPE());
+    return destination;
+  }
+};
+function processHeader(self, state, key, value, validate) {
+  if (validate) {
+    validateHeaderName(key);
+  }
+  if (isContentDispositionField(key) && self._contentLength) {
+    if (Array.isArray(value)) {
+      for (let i2 = 0; i2 < value.length; i2++) {
+        value[i2] = String(buffer.Buffer.from(String(value[i2]), "latin1"));
+      }
+    } else {
+      value = String(buffer.Buffer.from(String(value), "latin1"));
+    }
+  }
+  if (Array.isArray(value)) {
+    if ((value.length < 2 || !isCookieField(key)) && (!self[kUniqueHeaders] || !self[kUniqueHeaders].has(key.toLowerCase()))) {
+      for (let i2 = 0; i2 < value.length; i2++) {
+        storeHeader(self, state, key, value[i2], validate);
+      }
+      return;
+    }
+    value = value.join("; ");
+  }
+  storeHeader(self, state, key, String(value), validate);
+}
+function storeHeader(self, state, key, value, validate) {
+  if (validate) {
+    validateHeaderValue(key, value);
+  }
+  state.header += key + ": " + value + "\r\n";
+  matchHeader(self, state, key, value);
+}
+function validateHeaderName(name, label) {
+  if (typeof name !== "string" || !name || !checkIsHttpToken(name)) {
+    throw new ERR_INVALID_HTTP_TOKEN(label || "Header name", name);
+  }
+}
+function validateHeaderValue(name, value) {
+  if (value === void 0) {
+    throw new ERR_HTTP_INVALID_HEADER_VALUE(String(value), name);
+  }
+  if (checkInvalidHeaderChar(String(value))) {
+    throw new ERR_INVALID_CHAR("header content", name);
+  }
+}
+function matchHeader(self, state, field, value) {
+  if (field.length < 4 || field.length > 17)
+    return;
+  field = field.toLowerCase();
+  switch (field) {
+    case "connection":
+      state.connection = true;
+      self._removedConnection = false;
+      if (RE_CONN_CLOSE.exec(value) !== null)
+        self._last = true;
+      else
+        self.shouldKeepAlive = true;
+      break;
+    case "transfer-encoding":
+      state.te = true;
+      self._removedTE = false;
+      if (chunkExpression.exec(value) !== null)
+        self.chunkedEncoding = true;
+      break;
+    case "content-length":
+      state.contLen = true;
+      self._contentLength = +value;
+      self._removedContLen = false;
+      break;
+    case "date":
+    case "expect":
+    case "trailer":
+      state[field] = true;
+      break;
+    case "keep-alive":
+      self._defaultKeepAlive = false;
+      break;
+  }
+}
+function onError2(msg, err, callback) {
+  if (msg.destroyed) {
+    return;
+  }
+  setTimeout(emitErrorNt, 0, msg, err, callback);
+}
+function emitErrorNt(msg, err, callback) {
+  callback(err);
+  if (typeof msg.emit === "function" && !msg.destroyed) {
+    msg.emit("error", err);
+  }
+}
+function strictContentLength(msg) {
+  return msg.strictContentLength && msg._contentLength != null && msg._hasBody && !msg._removedContLen && !msg.chunkedEncoding && !msg.hasHeader("transfer-encoding");
+}
+function write_(msg, chunk, encoding, callback, fromEnd) {
+  if (typeof callback !== "function") {
+    callback = nop;
+  }
+  if (chunk === null) {
+    throw new ERR_STREAM_NULL_VALUES();
+  } else if (typeof chunk !== "string" && !isUint8Array(chunk)) {
+    throw new ERR_INVALID_ARG_TYPE("chunk", ["string", "Buffer", "Uint8Array"], chunk);
+  }
+  let err = void 0;
+  if (msg.finished) {
+    err = new ERR_STREAM_WRITE_AFTER_END();
+  } else if (msg.destroyed) {
+    err = new ERR_STREAM_DESTROYED("write");
+  }
+  if (err) {
+    if (!msg.destroyed) {
+      onError2(msg, err, callback);
+    } else {
+      setTimeout(callback, 0, err);
+    }
+    return false;
+  }
+  let len = void 0;
+  if (msg.strictContentLength) {
+    len ??= typeof chunk === "string" ? buffer.Buffer.byteLength(chunk, encoding ?? void 0) : chunk.byteLength;
+    if (strictContentLength(msg) && (fromEnd ? msg[kBytesWritten] + len !== msg._contentLength : msg[kBytesWritten] + len > (msg._contentLength ?? 0))) {
+      throw new ERR_HTTP_CONTENT_LENGTH_MISMATCH(len + msg[kBytesWritten], msg._contentLength);
+    }
+    msg[kBytesWritten] += len;
+  }
+  if (!msg._header) {
+    if (fromEnd) {
+      len ??= typeof chunk === "string" ? buffer.Buffer.byteLength(chunk, encoding ?? void 0) : chunk.byteLength;
+      msg._contentLength = len;
+    }
+    msg._implicitHeader();
+  }
+  if (!msg._hasBody) {
+    if (msg[kRejectNonStandardBodyWrites]) {
+      throw new ERR_HTTP_BODY_NOT_ALLOWED();
+    } else {
+      setTimeout(callback, 0);
+      return true;
+    }
+  }
+  if (!fromEnd && msg._writtenDataBuffer != null && !msg._writtenDataBuffer.writableCorked) {
+    msg._writtenDataBuffer.cork();
+    setTimeout(connectionCorkNT, 0, msg._writtenDataBuffer);
+  }
+  let ret;
+  if (msg.chunkedEncoding && chunk.length !== 0) {
+    len ??= typeof chunk === "string" ? buffer.Buffer.byteLength(chunk, encoding ?? void 0) : chunk.byteLength;
+    if (msg[kCorked] && msg._headerSent) {
+      msg[kChunkedBuffer].push({ data: chunk, encoding, callback });
+      msg[kChunkedLength] += len;
+      ret = msg[kChunkedLength] < msg[kHighWaterMark];
+    } else {
+      ret = msg._send(chunk, encoding, callback, len);
+    }
+  } else {
+    ret = msg._send(chunk, encoding, callback, len);
+  }
+  return ret;
+}
+function connectionCorkNT(dataBuffer) {
+  dataBuffer.uncork();
+}
+function onFinish(outmsg) {
+  outmsg.emit("finish");
+}
+Object.defineProperties(FetchOutgoingMessage.prototype, {
+  errored: {
+    get() {
+      return this[kErrored];
+    }
+  },
+  closed: {
+    get() {
+      return this._closed;
+    }
+  },
+  writableFinished: {
+    get() {
+      return this.finished && this.outputSize === 0 && (this._writtenDataBuffer == null || this._writtenDataBuffer.writableLength === 0);
+    }
+  },
+  writableObjectMode: {
+    get() {
+      return false;
+    }
+  },
+  writableLength: {
+    get() {
+      return this.outputSize + this[kChunkedLength] + (this._writtenDataBuffer != null ? this._writtenDataBuffer.writableLength : 0);
+    }
+  },
+  writableHighWaterMark: {
+    get() {
+      return this._writtenDataBuffer != null ? this._writtenDataBuffer.writableHighWaterMark : this[kHighWaterMark];
+    }
+  },
+  writableCorked: {
+    get() {
+      return this[kCorked];
+    }
+  },
+  writableEnded: {
+    get() {
+      return this.finished;
+    }
+  },
+  writableNeedDrain: {
+    get() {
+      return !this.destroyed && !this.finished && this[kNeedDrain];
+    }
+  }
+});
+var headerCharRegex2 = /[^\t\x20-\x7e\x80-\xff]/;
+function checkInvalidHeaderChar2(val) {
+  return headerCharRegex2.test(val);
+}
+var STATUS_CODES = {
+  100: "Continue",
+  // RFC 7231 6.2.1
+  101: "Switching Protocols",
+  // RFC 7231 6.2.2
+  102: "Processing",
+  // RFC 2518 10.1 (obsoleted by RFC 4918)
+  103: "Early Hints",
+  // RFC 8297 2
+  200: "OK",
+  // RFC 7231 6.3.1
+  201: "Created",
+  // RFC 7231 6.3.2
+  202: "Accepted",
+  // RFC 7231 6.3.3
+  203: "Non-Authoritative Information",
+  // RFC 7231 6.3.4
+  204: "No Content",
+  // RFC 7231 6.3.5
+  205: "Reset Content",
+  // RFC 7231 6.3.6
+  206: "Partial Content",
+  // RFC 7233 4.1
+  207: "Multi-Status",
+  // RFC 4918 11.1
+  208: "Already Reported",
+  // RFC 5842 7.1
+  226: "IM Used",
+  // RFC 3229 10.4.1
+  300: "Multiple Choices",
+  // RFC 7231 6.4.1
+  301: "Moved Permanently",
+  // RFC 7231 6.4.2
+  302: "Found",
+  // RFC 7231 6.4.3
+  303: "See Other",
+  // RFC 7231 6.4.4
+  304: "Not Modified",
+  // RFC 7232 4.1
+  305: "Use Proxy",
+  // RFC 7231 6.4.5
+  307: "Temporary Redirect",
+  // RFC 7231 6.4.7
+  308: "Permanent Redirect",
+  // RFC 7238 3
+  400: "Bad Request",
+  // RFC 7231 6.5.1
+  401: "Unauthorized",
+  // RFC 7235 3.1
+  402: "Payment Required",
+  // RFC 7231 6.5.2
+  403: "Forbidden",
+  // RFC 7231 6.5.3
+  404: "Not Found",
+  // RFC 7231 6.5.4
+  405: "Method Not Allowed",
+  // RFC 7231 6.5.5
+  406: "Not Acceptable",
+  // RFC 7231 6.5.6
+  407: "Proxy Authentication Required",
+  // RFC 7235 3.2
+  408: "Request Timeout",
+  // RFC 7231 6.5.7
+  409: "Conflict",
+  // RFC 7231 6.5.8
+  410: "Gone",
+  // RFC 7231 6.5.9
+  411: "Length Required",
+  // RFC 7231 6.5.10
+  412: "Precondition Failed",
+  // RFC 7232 4.2
+  413: "Payload Too Large",
+  // RFC 7231 6.5.11
+  414: "URI Too Long",
+  // RFC 7231 6.5.12
+  415: "Unsupported Media Type",
+  // RFC 7231 6.5.13
+  416: "Range Not Satisfiable",
+  // RFC 7233 4.4
+  417: "Expectation Failed",
+  // RFC 7231 6.5.14
+  418: "I'm a Teapot",
+  // RFC 7168 2.3.3
+  421: "Misdirected Request",
+  // RFC 7540 9.1.2
+  422: "Unprocessable Entity",
+  // RFC 4918 11.2
+  423: "Locked",
+  // RFC 4918 11.3
+  424: "Failed Dependency",
+  // RFC 4918 11.4
+  425: "Too Early",
+  // RFC 8470 5.2
+  426: "Upgrade Required",
+  // RFC 2817 and RFC 7231 6.5.15
+  428: "Precondition Required",
+  // RFC 6585 3
+  429: "Too Many Requests",
+  // RFC 6585 4
+  431: "Request Header Fields Too Large",
+  // RFC 6585 5
+  451: "Unavailable For Legal Reasons",
+  // RFC 7725 3
+  500: "Internal Server Error",
+  // RFC 7231 6.6.1
+  501: "Not Implemented",
+  // RFC 7231 6.6.2
+  502: "Bad Gateway",
+  // RFC 7231 6.6.3
+  503: "Service Unavailable",
+  // RFC 7231 6.6.4
+  504: "Gateway Timeout",
+  // RFC 7231 6.6.5
+  505: "HTTP Version Not Supported",
+  // RFC 7231 6.6.6
+  506: "Variant Also Negotiates",
+  // RFC 2295 8.1
+  507: "Insufficient Storage",
+  // RFC 4918 11.5
+  508: "Loop Detected",
+  // RFC 5842 7.2
+  509: "Bandwidth Limit Exceeded",
+  510: "Not Extended",
+  // RFC 2774 7
+  511: "Network Authentication Required"
+  // RFC 6585 6
+};
+var FetchServerResponse = class _FetchServerResponse extends FetchOutgoingMessage {
+  static encoder = new TextEncoder();
+  statusCode = 200;
+  statusMessage;
+  _sent100;
+  _expect_continue;
+  [kOutHeaders] = null;
+  constructor(req, options) {
+    super(req, options);
+    if (req.method === "HEAD") {
+      this._hasBody = false;
+    }
+    this.sendDate = true;
+    this._sent100 = false;
+    this._expect_continue = false;
+    if (req.httpVersionMajor < 1 || req.httpVersionMinor < 1) {
+      this.useChunkedEncodingByDefault = chunkExpression.exec(String(req.headers.te)) !== null;
+      this.shouldKeepAlive = false;
+    }
+    this.fetchResponse = new Promise((resolve) => {
+      let finished = false;
+      this.on("finish", () => {
+        finished = true;
+      });
+      const initialDataChunks = [];
+      const initialDataWrittenHandler = (e2) => {
+        if (finished) {
+          return;
+        }
+        initialDataChunks[e2.index] = this.dataFromDataWrittenEvent(e2);
+      };
+      this.on("_dataWritten", initialDataWrittenHandler);
+      this.on("_headersSent", (e2) => {
+        this.off("_dataWritten", initialDataWrittenHandler);
+        const { statusCode, statusMessage, headers } = e2;
+        resolve(this._toFetchResponse(statusCode, statusMessage, headers, initialDataChunks, finished));
+      });
+    });
+  }
+  dataFromDataWrittenEvent(e2) {
+    const { index, entry } = e2;
+    let { data, encoding } = entry;
+    if (index === 0) {
+      if (typeof data !== "string") {
+        console.error("First chunk should be string, not sure what happened.");
+        throw new ERR_INVALID_ARG_TYPE("packet.data", ["string", "Buffer", "Uint8Array"], data);
+      }
+      data = data.slice(this.writtenHeaderBytes);
+    }
+    if (typeof data === "string") {
+      if (encoding === void 0 || encoding === "utf8" || encoding === "utf-8") {
+        data = _FetchServerResponse.encoder.encode(data);
+      } else {
+        data = buffer.Buffer.from(data, encoding ?? void 0);
+      }
+    }
+    return data ?? buffer.Buffer.from([]);
+  }
+  _finish() {
+    super._finish();
+  }
+  assignSocket(socket) {
+    throw new ERR_METHOD_NOT_IMPLEMENTED("assignSocket");
+  }
+  detachSocket(socket) {
+    throw new ERR_METHOD_NOT_IMPLEMENTED("detachSocket");
+  }
+  writeContinue(callback) {
+    this._writeRaw("HTTP/1.1 100 Continue\r\n\r\n", "ascii", callback);
+    this._sent100 = true;
+  }
+  writeProcessing(callback) {
+    this._writeRaw("HTTP/1.1 102 Processing\r\n\r\n", "ascii", callback);
+  }
+  writeEarlyHints(hints, callback) {
+    let head = "HTTP/1.1 103 Early Hints\r\n";
+    if (hints.link === null || hints.link === void 0) {
+      return;
+    }
+    const link = validateLinkHeaderValue(hints.link);
+    if (link.length === 0) {
+      return;
     }
-    agent.__updateInstructions(instructions);
-    return c2.json(
-      {
-        instructions
-      },
-      200
-    );
-  } catch (error) {
-    return handleError(error, "Error setting agent instructions");
+    head += "Link: " + link + "\r\n";
+    for (const key of Object.keys(hints)) {
+      if (key !== "link") {
+        head += key + ": " + hints[key] + "\r\n";
+      }
+    }
+    head += "\r\n";
+    this._writeRaw(head, "ascii", callback);
   }
-}
-
-// src/server/handlers/client.ts
-var clients = /* @__PURE__ */ new Set();
-function handleClientsRefresh(c2) {
-  const stream3 = new ReadableStream({
-    start(controller) {
-      clients.add(controller);
-      controller.enqueue("data: connected\n\n");
-      c2.req.raw.signal.addEventListener("abort", () => {
-        clients.delete(controller);
-      });
+  _implicitHeader() {
+    this.writeHead(this.statusCode);
+  }
+  writeHead(statusCode, reason, obj) {
+    if (this._header) {
+      throw new ERR_HTTP_HEADERS_SENT("write");
     }
-  });
-  return new Response(stream3, {
-    headers: {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache",
-      Connection: "keep-alive",
-      "Access-Control-Allow-Origin": "*"
+    const originalStatusCode = statusCode;
+    statusCode |= 0;
+    if (statusCode < 100 || statusCode > 999) {
+      throw new ERR_HTTP_INVALID_STATUS_CODE(originalStatusCode);
     }
-  });
-}
-function handleTriggerClientsRefresh(c2) {
-  clients.forEach((controller) => {
-    try {
-      controller.enqueue("data: refresh\n\n");
-    } catch {
-      clients.delete(controller);
+    if (typeof reason === "string") {
+      this.statusMessage = reason;
+    } else {
+      this.statusMessage ||= STATUS_CODES[statusCode] || "unknown";
+      obj ??= reason;
     }
-  });
-  return c2.json({ success: true, clients: clients.size });
-}
-async function getLogsHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const transportId = c2.req.query("transportId");
-    const logs$1 = await logs.getLogsHandler({
-      mastra,
-      transportId
+    this.statusCode = statusCode;
+    let headers;
+    if (this[kOutHeaders]) {
+      let k;
+      if (Array.isArray(obj)) {
+        if (obj.length % 2 !== 0) {
+          throw new ERR_INVALID_ARG_VALUE("headers", obj);
+        }
+        for (let n2 = 0; n2 < obj.length; n2 += 2) {
+          k = obj[n2 + 0];
+          this.removeHeader(String(k));
+        }
+        for (let n2 = 0; n2 < obj.length; n2 += 2) {
+          k = obj[n2];
+          if (k) {
+            this.appendHeader(String(k), obj[n2 + 1]);
+          }
+        }
+      } else if (obj) {
+        const keys = Object.keys(obj);
+        for (let i2 = 0; i2 < keys.length; i2++) {
+          k = keys[i2];
+          if (k) {
+            this.setHeader(k, obj[k]);
+          }
+        }
+      }
+      headers = this[kOutHeaders];
+    } else {
+      headers = obj;
+    }
+    if (checkInvalidHeaderChar2(this.statusMessage)) {
+      throw new ERR_INVALID_CHAR("statusMessage");
+    }
+    const statusLine = `HTTP/1.1 ${statusCode} ${this.statusMessage}\r
+`;
+    if (statusCode === 204 || statusCode === 304 || statusCode >= 100 && statusCode <= 199) {
+      this._hasBody = false;
+    }
+    if (this._expect_continue && !this._sent100) {
+      this.shouldKeepAlive = false;
+    }
+    const convertedHeaders = headers && !Array.isArray(headers) ? headers : headers;
+    this._storeHeader(statusLine, convertedHeaders ?? null);
+    return this;
+  }
+  // Docs-only deprecated: DEP0063
+  writeHeader = this.writeHead;
+  fetchResponse;
+  _toFetchResponse(status, statusText, sentHeaders, initialDataChunks, finished) {
+    const headers = new Headers();
+    for (const [header, value] of sentHeaders) {
+      headers.append(header, value);
+    }
+    const _this = this;
+    let body = this._hasBody ? new ReadableStream({
+      start(controller) {
+        for (const dataChunk of initialDataChunks) {
+          controller.enqueue(dataChunk);
+        }
+        if (finished) {
+          controller.close();
+        } else {
+          _this.on("finish", () => {
+            finished = true;
+            controller.close();
+          });
+          _this.on("_dataWritten", (e2) => {
+            if (finished) {
+              return;
+            }
+            const data = _this.dataFromDataWrittenEvent(e2);
+            controller.enqueue(data);
+          });
+        }
+      }
+    }) : null;
+    if (body != null && typeof FixedLengthStream !== "undefined") {
+      const contentLength = parseInt(headers.get("content-length") ?? "", 10);
+      if (contentLength >= 0) {
+        body = body.pipeThrough(new FixedLengthStream(contentLength));
+      }
+    }
+    return new Response(body, {
+      status,
+      statusText,
+      headers
     });
-    return c2.json(logs$1);
-  } catch (error) {
-    return handleError(error, "Error getting logs");
   }
+};
+function toReqRes(req, options) {
+  const { createIncomingMessage = () => new FetchIncomingMessage(), createServerResponse = (incoming2) => new FetchServerResponse(incoming2), ctx } = {};
+  const incoming = createIncomingMessage(ctx);
+  const serverResponse = createServerResponse(incoming, ctx);
+  const reqUrl = new URL(req.url);
+  const versionMajor = 1;
+  const versionMinor = 1;
+  incoming.httpVersionMajor = versionMajor;
+  incoming.httpVersionMinor = versionMinor;
+  incoming.httpVersion = `${versionMajor}.${versionMinor}`;
+  incoming.url = reqUrl.pathname + reqUrl.search;
+  incoming.upgrade = false;
+  const headers = [];
+  for (const [headerName, headerValue] of req.headers) {
+    headers.push(headerName);
+    headers.push(headerValue);
+  }
+  incoming._addHeaderLines(headers, headers.length);
+  incoming.method = req.method;
+  incoming._stream = req.body;
+  return {
+    req: incoming,
+    res: serverResponse
+  };
+}
+function toFetchResponse(res) {
+  if (!(res instanceof FetchServerResponse)) {
+    throw new Error("toFetchResponse must be called on a ServerResponse generated by toReqRes");
+  }
+  return res.fetchResponse;
 }
-async function getLogsByRunIdHandler(c2) {
+
+// src/server/handlers/mcp.ts
+var getMastra = (c2) => c2.get("mastra");
+var getMcpServerMessageHandler = async (c2) => {
+  const mastra = getMastra(c2);
+  const serverId = c2.req.param("serverId");
+  const { req, res } = toReqRes(c2.req.raw);
+  const server = mastra.getMCPServer(serverId);
+  if (!server) {
+    return c2.json({ error: `MCP server '${serverId}' not found` }, 404);
+  }
   try {
-    const mastra = c2.get("mastra");
-    const runId = c2.req.param("runId");
-    const transportId = c2.req.query("transportId");
-    const logs$1 = await logs.getLogsByRunIdHandler({
-      mastra,
-      runId,
-      transportId
+    await server.startHTTP({
+      url: new URL(c2.req.url),
+      httpPath: `/api/servers/${serverId}/mcp`,
+      req,
+      res,
+      options: {
+        sessionIdGenerator: void 0
+      }
     });
-    return c2.json(logs$1);
+    const toFetchRes = await toFetchResponse(res);
+    return toFetchRes;
   } catch (error) {
-    return handleError(error, "Error getting logs by run ID");
+    return handleError(error, "Error sending MCP message");
   }
-}
-async function getLogTransports(c2) {
+};
+var handleMcpServerSseRoutes = async (c2) => {
+  const mastra = getMastra(c2);
+  const serverId = c2.req.param("serverId");
+  const server = mastra.getMCPServer(serverId);
+  if (!server) {
+    return c2.json({ error: `MCP server '${serverId}' not found` }, 404);
+  }
+  const { req, res } = toReqRes(c2.req.raw);
+  const requestUrl = new URL(c2.req.url);
+  const sseConnectionPath = `/api/servers/${serverId}/sse`;
+  const sseMessagePath = `/api/servers/${serverId}/messages`;
   try {
-    const mastra = c2.get("mastra");
-    const result = await logs.getLogTransports({
-      mastra
+    await server.startSSE({
+      url: requestUrl,
+      ssePath: sseConnectionPath,
+      messagePath: sseMessagePath,
+      req,
+      res
     });
-    return c2.json(result);
+    if (res.writableEnded || res.headersSent) {
+      return toFetchResponse(res);
+    }
+    c2.get("logger")?.warn(
+      { serverId, path: requestUrl.pathname },
+      "MCP SSE handler: MCPServer.startSSE did not seem to handle the response."
+    );
+    return c2.text("Internal Server Error: MCP SSE request not fully processed by server component", 500);
   } catch (error) {
-    return handleError(error, "Error getting log Transports");
+    c2.get("logger")?.error({ err: error, serverId, path: requestUrl.pathname }, "Error in MCP SSE route handler");
+    if (!res.headersSent && !res.writableEnded) {
+      return handleError(error, "Error handling MCP SSE request");
+    }
   }
-}
+};
 async function getMemoryStatusHandler(c2) {
   try {
     const mastra = c2.get("mastra");
@@ -1398,13 +3393,14 @@ function executeToolHandler(tools$1) {
       const runtimeContext = c2.get("runtimeContext");
       const toolId = decodeURIComponent(c2.req.param("toolId"));
       const runId = c2.req.query("runId");
-      const { data } = await c2.req.json();
+      const { data, runtimeContext: runtimeContextFromRequest } = await c2.req.json();
       const result = await tools.executeToolHandler(tools$1)({
         mastra,
         toolId,
         data,
         runtimeContext,
-        runId
+        runId,
+        runtimeContextFromRequest
       });
       return c2.json(result);
     } catch (error) {
@@ -1418,13 +3414,14 @@ async function executeAgentToolHandler(c2) {
     const runtimeContext = c2.get("runtimeContext");
     const agentId = c2.req.param("agentId");
     const toolId = c2.req.param("toolId");
-    const { data } = await c2.req.json();
+    const { data, runtimeContext: runtimeContextFromRequest } = await c2.req.json();
     const result = await tools.executeAgentToolHandler({
       mastra,
       agentId,
       toolId,
       data,
-      runtimeContext
+      runtimeContext,
+      runtimeContextFromRequest
     });
     return c2.json(result);
   } catch (error) {
@@ -1572,11 +3569,13 @@ async function startAsyncVNextWorkflowHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const workflowId = c2.req.param("workflowId");
-    const { inputData, runtimeContext } = await c2.req.json();
+    const runtimeContext = c2.get("runtimeContext");
+    const { inputData, runtimeContext: runtimeContextFromRequest } = await c2.req.json();
     const runId = c2.req.query("runId");
     const result = await vNextWorkflows.startAsyncVNextWorkflowHandler({
       mastra,
       runtimeContext,
+      runtimeContextFromRequest,
       workflowId,
       runId,
       inputData
@@ -1590,11 +3589,13 @@ async function startVNextWorkflowRunHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const workflowId = c2.req.param("workflowId");
-    const { inputData, runtimeContext } = await c2.req.json();
+    const runtimeContext = c2.get("runtimeContext");
+    const { inputData, runtimeContext: runtimeContextFromRequest } = await c2.req.json();
     const runId = c2.req.query("runId");
     await vNextWorkflows.startVNextWorkflowRunHandler({
       mastra,
       runtimeContext,
+      runtimeContextFromRequest,
       workflowId,
       runId,
       inputData
@@ -1615,20 +3616,20 @@ function watchVNextWorkflowHandler(c2) {
     }
     return streaming.stream(
       c2,
-      async (stream3) => {
+      async (stream4) => {
         try {
           const result = await vNextWorkflows.watchVNextWorkflowHandler({
             mastra,
             workflowId,
             runId
           });
-          stream3.onAbort(() => {
+          stream4.onAbort(() => {
             if (!result.locked) {
               return result.cancel();
             }
           });
           for await (const chunk of result) {
-            await stream3.write(chunk.toString() + "");
+            await stream4.write(chunk.toString() + "");
           }
         } catch (err) {
           console.log(err);
@@ -1647,13 +3648,15 @@ async function resumeAsyncVNextWorkflowHandler(c2) {
     const mastra = c2.get("mastra");
     const workflowId = c2.req.param("workflowId");
     const runId = c2.req.query("runId");
-    const { step, resumeData, runtimeContext } = await c2.req.json();
+    const runtimeContext = c2.get("runtimeContext");
+    const { step, resumeData, runtimeContext: runtimeContextFromRequest } = await c2.req.json();
     if (!runId) {
       throw new httpException.HTTPException(400, { message: "runId required to resume workflow" });
     }
     const result = await vNextWorkflows.resumeAsyncVNextWorkflowHandler({
       mastra,
       runtimeContext,
+      runtimeContextFromRequest,
       workflowId,
       runId,
       body: { step, resumeData }
@@ -1850,20 +3853,20 @@ function watchWorkflowHandler(c2) {
     }
     return streaming.stream(
       c2,
-      async (stream3) => {
+      async (stream4) => {
         try {
           const result = await workflows.watchWorkflowHandler({
             mastra,
             workflowId,
             runId
           });
-          stream3.onAbort(() => {
+          stream4.onAbort(() => {
             if (!result.locked) {
               return result.cancel();
             }
           });
           for await (const chunk of result) {
-            await stream3.write(chunk.toString() + "");
+            await stream4.write(chunk.toString() + "");
           }
         } catch (err) {
           console.log(err);
@@ -2093,7 +4096,18 @@ async function createHonoServer(mastra, options = {}) {
   app.onError(errorHandler);
   app.use("*", function setContext(c2, next) {
     const runtimeContext$1 = new runtimeContext.RuntimeContext();
-    c2.set("runtimeContext", runtimeContext$1);
+    const proxyRuntimeContext = new Proxy(runtimeContext$1, {
+      get(target, prop) {
+        if (prop === "get") {
+          return function(key) {
+            const value = target.get(key);
+            return value ?? `<${key}>`;
+          };
+        }
+        return Reflect.get(target, prop);
+      }
+    });
+    c2.set("runtimeContext", proxyRuntimeContext);
     c2.set("mastra", mastra);
     c2.set("tools", tools);
     c2.set("playground", options.playground === true);
@@ -2167,6 +4181,142 @@ async function createHonoServer(mastra, options = {}) {
   if (server?.build?.apiReqLogs) {
     app.use(logger.logger());
   }
+  app.get(
+    "/.well-known/:agentId/agent.json",
+    h({
+      description: "Get agent configuration",
+      tags: ["agents"],
+      parameters: [
+        {
+          name: "agentId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        200: {
+          description: "Agent configuration"
+        }
+      }
+    }),
+    getAgentCardByIdHandler
+  );
+  app.post(
+    "/a2a/:agentId",
+    h({
+      description: "Execute agent via A2A protocol",
+      tags: ["agents"],
+      parameters: [
+        {
+          name: "agentId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                method: {
+                  type: "string",
+                  enum: ["tasks/send", "tasks/sendSubscribe", "tasks/get", "tasks/cancel"],
+                  description: "The A2A protocol method to execute"
+                },
+                params: {
+                  type: "object",
+                  oneOf: [
+                    {
+                      // TaskSendParams
+                      type: "object",
+                      properties: {
+                        id: {
+                          type: "string",
+                          description: "Unique identifier for the task being initiated or continued"
+                        },
+                        sessionId: {
+                          type: "string",
+                          description: "Optional identifier for the session this task belongs to"
+                        },
+                        message: {
+                          type: "object",
+                          description: "The message content to send to the agent for processing"
+                        },
+                        pushNotification: {
+                          type: "object",
+                          nullable: true,
+                          description: "Optional pushNotification information for receiving notifications about this task"
+                        },
+                        historyLength: {
+                          type: "integer",
+                          nullable: true,
+                          description: "Optional parameter to specify how much message history to include in the response"
+                        },
+                        metadata: {
+                          type: "object",
+                          nullable: true,
+                          description: "Optional metadata associated with sending this message"
+                        }
+                      },
+                      required: ["id", "message"]
+                    },
+                    {
+                      // TaskQueryParams
+                      type: "object",
+                      properties: {
+                        id: { type: "string", description: "The unique identifier of the task" },
+                        historyLength: {
+                          type: "integer",
+                          nullable: true,
+                          description: "Optional history length to retrieve for the task"
+                        },
+                        metadata: {
+                          type: "object",
+                          nullable: true,
+                          description: "Optional metadata to include with the operation"
+                        }
+                      },
+                      required: ["id"]
+                    },
+                    {
+                      // TaskIdParams
+                      type: "object",
+                      properties: {
+                        id: { type: "string", description: "The unique identifier of the task" },
+                        metadata: {
+                          type: "object",
+                          nullable: true,
+                          description: "Optional metadata to include with the operation"
+                        }
+                      },
+                      required: ["id"]
+                    }
+                  ]
+                }
+              },
+              required: ["method", "params"]
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "A2A response"
+        },
+        400: {
+          description: "Missing or invalid request parameters"
+        },
+        404: {
+          description: "Agent not found"
+        }
+      }
+    }),
+    getAgentExecutionHandler
+  );
   app.get(
     "/api",
     h({
@@ -3007,7 +5157,8 @@ async function createHonoServer(mastra, options = {}) {
             schema: {
               type: "object",
               properties: {
-                data: { type: "object" }
+                data: { type: "object" },
+                runtimeContext: { type: "object" }
               },
               required: ["data"]
             }
@@ -3025,6 +5176,93 @@ async function createHonoServer(mastra, options = {}) {
     }),
     executeAgentToolHandler
   );
+  app.post(
+    "/api/servers/:serverId/mcp",
+    bodyLimit.bodyLimit(bodyLimitOptions),
+    h({
+      description: "Send a message to an MCP server using Streamable HTTP",
+      tags: ["mcp"],
+      parameters: [
+        {
+          name: "serverId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        content: { "application/json": { schema: { type: "object" } } }
+      },
+      responses: {
+        200: {
+          description: "Streamable HTTP connection processed"
+        },
+        404: {
+          description: "MCP server not found"
+        }
+      }
+    }),
+    getMcpServerMessageHandler
+  );
+  const mcpSseBasePath = "/api/servers/:serverId/sse";
+  const mcpSseMessagePath = "/api/servers/:serverId/messages";
+  app.get(
+    mcpSseBasePath,
+    h({
+      description: "Establish an MCP Server-Sent Events (SSE) connection with a server instance.",
+      tags: ["mcp"],
+      parameters: [
+        {
+          name: "serverId",
+          in: "path",
+          required: true,
+          schema: { type: "string" },
+          description: "The ID of the MCP server instance."
+        }
+      ],
+      responses: {
+        200: {
+          description: "SSE connection established. The client will receive events over this connection. (Content-Type: text/event-stream)"
+        },
+        404: { description: "MCP server instance not found." },
+        500: { description: "Internal server error establishing SSE connection." }
+      }
+    }),
+    handleMcpServerSseRoutes
+  );
+  app.post(
+    mcpSseMessagePath,
+    bodyLimit.bodyLimit(bodyLimitOptions),
+    // Apply body limit for messages
+    h({
+      description: "Send a message to an MCP server over an established SSE connection.",
+      tags: ["mcp"],
+      parameters: [
+        {
+          name: "serverId",
+          in: "path",
+          required: true,
+          schema: { type: "string" },
+          description: "The ID of the MCP server instance."
+        }
+      ],
+      requestBody: {
+        description: "JSON-RPC message to send to the MCP server.",
+        required: true,
+        content: { "application/json": { schema: { type: "object" } } }
+        // MCP messages are typically JSON
+      },
+      responses: {
+        200: {
+          description: "Message received and is being processed by the MCP server. The actual result or error will be sent as an SSE event over the established connection."
+        },
+        400: { description: "Bad request (e.g., invalid JSON payload or missing body)." },
+        404: { description: "MCP server instance not found or SSE connection path incorrect." },
+        503: { description: "SSE connection not established with this server, or server unable to process message." }
+      }
+    }),
+    handleMcpServerSseRoutes
+  );
   app.get(
     "/api/memory/status",
     h({
@@ -3394,7 +5632,10 @@ async function createHonoServer(mastra, options = {}) {
                   oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }]
                 },
                 resumeData: { type: "object" },
-                runtimeContext: { type: "object" }
+                runtimeContext: {
+                  type: "object",
+                  description: "Runtime context for the workflow execution"
+                }
               },
               required: ["step"]
             }
@@ -3435,7 +5676,10 @@ async function createHonoServer(mastra, options = {}) {
                   oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }]
                 },
                 resumeData: { type: "object" },
-                runtimeContext: { type: "object" }
+                runtimeContext: {
+                  type: "object",
+                  description: "Runtime context for the workflow execution"
+                }
               },
               required: ["step"]
             }
@@ -3501,7 +5745,10 @@ async function createHonoServer(mastra, options = {}) {
               type: "object",
               properties: {
                 inputData: { type: "object" },
-                runtimeContext: { type: "object" }
+                runtimeContext: {
+                  type: "object",
+                  description: "Runtime context for the workflow execution"
+                }
               }
             }
           }
@@ -3545,7 +5792,10 @@ async function createHonoServer(mastra, options = {}) {
               type: "object",
               properties: {
                 inputData: { type: "object" },
-                runtimeContext: { type: "object" }
+                runtimeContext: {
+                  type: "object",
+                  description: "Runtime context for the workflow execution"
+                }
               }
             }
           }
@@ -4072,7 +6322,8 @@ async function createHonoServer(mastra, options = {}) {
             schema: {
               type: "object",
               properties: {
-                data: { type: "object" }
+                data: { type: "object" },
+                runtimeContext: { type: "object" }
               },
               required: ["data"]
             }
@@ -4365,7 +6616,7 @@ async function createNodeServer(mastra, options = {}) {
       const host = serverOptions?.host ?? "localhost";
       logger2.info(` Mastra API running on port http://${host}:${port}/api`);
       if (options?.isDev) {
-        logger2.info(`\uFFFD Open API documentation available at http://${host}:${port}/openapi.json`);
+        logger2.info(`\u{1F517} Open API documentation available at http://${host}:${port}/openapi.json`);
       }
       if (options?.isDev) {
         logger2.info(`\u{1F9EA} Swagger UI available at http://${host}:${port}/swagger-ui`);