cortad 0.2.2 → 0.3.0-rc.10

package/lib/trace.cjs

@@ -20,8 +20,284 @@ if (FILE) {
     row({ hello: isBun ? "bun" : "node", pid: process.pid });
     // Which port this process serves. Every process the start command spawns loads this file, turbo's
     // own launcher included, so "loaded" is not "watching your app": only a listener on the app's port is.
-    const listening = (port) => { if (Number.isInteger(port) && port > 0) row({ listen: port, pid: process.pid }); };
+    const listening = (port) => { if (Number.isInteger(port) && port > 0) { row({ listen: port, pid: process.pid }); sayRoutes(port); } };
+
+    // The app's own route table, so the run knows every door it has before a message is sent.
+    // Express keeps no mount prefix once a router is built (Express 5 layers keep no path at all),
+    // so its registrations are watched as they happen; the others are read off the app.
+    const ROUTES_MAX = 400;
+    const pathOf = (p) => String(p)
+      .replace(/\{(\/?[:*][^{}]*)\}/g, "$1")
+      .replace(/:(\w+)(?:\{[^{}]*\})?\??/g, "{$1}")
+      .replace(/\*(\w+)/g, "{$1}");
+    const joined = (a, b) => ("/" + [a, b].map((s) => String(s).replace(/^\/+|\/+$/g, "")).filter(Boolean).join("/"));
+    const nodePath = require("node:path");
+    // The file that registered a route: the first frame outside this hook and outside node_modules.
+    const callerFile = () => {
+      for (const line of String(new Error().stack).split("\n").slice(2)) {
+        const m = /\(?(?:file:\/\/)?(\/[^()]+?):\d+:\d+\)?$/.exec(line.trim());
+        if (!m || m[1] === __filename || m[1].includes("/node_modules/")) continue;
+        const rel = nodePath.relative(process.cwd(), decodeURI(m[1]));
+        return rel.startsWith("..") ? "" : rel;
+      }
+      return "";
+    };
+    const seen = new Set();
+    let nest = false;
+
+    const expressRoutes = [];
+    const expressMounts = [];
+    const OWNER = Symbol("cortad.router");
+    const isApp = (o) => typeof o === "function" && typeof o.set === "function" && typeof o.handle === "function";
+    const isRouter = (o) => typeof o === "function" && Array.isArray(o.stack) && typeof o.handle === "function";
+    const useArgs = (args) => {
+      let first = args[0];
+      while (Array.isArray(first) && first.length) first = first[0];
+      const pathed = typeof first !== "function";
+      return { paths: pathed ? [].concat(args[0]).filter((p) => typeof p === "string") : ["/"], fns: args.slice(pathed ? 1 : 0).flat(Infinity) };
+    };
+    const patchExpress = (express) => {
+      seen.add("express");
+      const routerProto = typeof express.Router.prototype.route === "function" ? express.Router.prototype : express.Router;
+      const mounting = (proto, wanted) => {
+        const use = proto.use;
+        proto.use = function (...args) {
+          try {
+            const { paths, fns } = useArgs(args);
+            for (const fn of fns) if (wanted(fn)) for (const path of paths) expressMounts.push({ parent: this, child: fn, path });
+          } catch { /* not ours to fail */ }
+          return use.apply(this, args);
+        };
+      };
+      // Express 4 and 5 both pass a plain router through to the router's own use, and hide a
+      // mounted sub-app behind a wrapper there, so each level records only what it can see.
+      mounting(routerProto, isRouter);
+      mounting(express.application, isApp);
+      const route = routerProto.route;
+      routerProto.route = function (...args) {
+        const made = route.apply(this, args);
+        try { made[OWNER] = this; } catch { /* frozen */ }
+        return made;
+      };
+      for (const verb of ["get", "post", "put", "patch", "delete", "all"]) {
+        const add = express.Route.prototype[verb];
+        if (typeof add !== "function") continue;
+        express.Route.prototype[verb] = function (...args) {
+          try {
+            if (expressRoutes.length < ROUTES_MAX * 4) {
+              const fns = args.flat(Infinity);
+              expressRoutes.push({ owner: this[OWNER], verb, paths: [].concat(this.path).filter((p) => typeof p === "string"), handler: fns[fns.length - 1], file: callerFile() });
+            }
+          } catch { /* not ours to fail */ }
+          return add.apply(this, args);
+        };
+      }
+    };
+    const expressTable = (add) => {
+      // An app is known by its router once it has one: routes are registered on the router.
+      // Express 4's app.router getter throws; its router is _router, made on the first route.
+      const own = (o) => {
+        if (!isApp(o) || o._router) return (o && o._router) || o;
+        try { return o.router || o; } catch { return o; }
+      };
+      const ups = new Map();
+      for (const m of expressMounts) {
+        const child = own(m.child);
+        if (!ups.has(child)) ups.set(child, []);
+        ups.get(child).push({ parent: own(m.parent), path: m.path });
+      }
+      const prefixes = (router, depth) => (!ups.has(router) || depth > 8 ? [""] : ups.get(router).flatMap((m) => prefixes(m.parent, depth + 1).map((p) => joined(p, m.path))));
+      for (const r of expressRoutes) {
+        for (const prefix of prefixes(own(r.owner), 0)) for (const path of r.paths) add(r.verb === "all" ? null : [r.verb], joined(prefix, path), r.handler, r.file);
+      }
+    };
+
+    // Fastify says each instance it makes on a diagnostics channel, and a root onRoute hook sees
+    // every route with its plugin prefix already applied.
+    const fastifyRoutes = [];
+    try {
+      require("node:diagnostics_channel").subscribe("fastify.initialization", ({ fastify }) => {
+        seen.add("fastify");
+        try {
+          fastify.addHook("onRoute", (o) => {
+            if (fastifyRoutes.length < ROUTES_MAX * 2) fastifyRoutes.push({ methods: [].concat(o.method), path: o.url, handler: o.handler, file: callerFile() });
+          });
+        } catch { /* an instance that takes no hooks */ }
+      });
+    } catch { /* no diagnostics channel */ }
+
+    // Hono and Koa keep their tables on the app, so their apps are held as they are made. Only
+    // what is loaded through require is seen: Hono's ES module build never passes through here.
+    const honoApps = new Set();
+    const koaApps = new Set();
+    const holding = new WeakMap();
+    const heldHono = (exported) => {
+      const d = Object.getOwnPropertyDescriptor(exported, "Hono");
+      if (!d || ("value" in d && !d.writable && !d.configurable)) return exported;
+      seen.add("hono");
+      const Hono = new Proxy(exported.Hono, { construct(t, a, nt) { const app = Reflect.construct(t, a, nt); if (honoApps.size < 50) honoApps.add(app); return app; } });
+      return new Proxy(exported, { get: (t, k, r) => (k === "Hono" ? Hono : Reflect.get(t, k, r)) });
+    };
+    const patchKoa = (Koa) => {
+      seen.add("koa");
+      const callback = Koa.prototype.callback;
+      Koa.prototype.callback = function (...a) { if (koaApps.size < 50) koaApps.add(this); return callback.apply(this, a); };
+    };
+    const adopted = (request, exported) => {
+      if (!exported || !/(?:^|node_modules\/)(?:express|koa|hono|@nestjs\/core)(?:\/index\.js)?$|\/lib\/(?:express|application)(?:\.js)?$/.test(request)) return exported;
+      if (holding.has(exported)) return holding.get(exported);
+      let out = exported;
+      if (typeof exported === "function" && exported.application && typeof exported.Router === "function" && typeof exported.Route === "function") patchExpress(exported);
+      else if (typeof exported === "function" && exported.prototype && typeof exported.prototype.callback === "function" && typeof exported.prototype.createContext === "function") patchKoa(exported);
+      else if (typeof exported.Hono === "function") out = heldHono(exported);
+      else if (exported.NestFactory) nest = true;
+      holding.set(exported, out);
+      return out;
+    };
+    const Module = require("node:module");
+    const load = Module._load;
+    Module._load = function (request, ...rest) {
+      const exported = load.call(this, request, ...rest);
+      try { return adopted(String(request), exported); } catch { return exported; }
+    };
+
+    let bunRoutes = [];
+    const table = () => {
+      const out = new Map();
+      const from = new Set();
+      const add = (framework) => (methods, path, handler, file) => {
+        if (typeof path !== "string") return;
+        for (const m of methods || ["POST", "GET"]) {
+          const method = String(m).toUpperCase();
+          const at = pathOf(path.startsWith("/") ? path : "/" + path);
+          if (method === "HEAD" || method === "OPTIONS" || out.size >= ROUTES_MAX || out.has(`${method} ${at}`)) continue;
+          from.add(framework);
+          out.set(`${method} ${at}`, { method, path: at.slice(0, 1024), file: String(file || "").slice(0, 512), handler: String((handler && handler.name) || "").slice(0, 200) });
+        }
+      };
+      expressTable(add("express"));
+      for (const r of fastifyRoutes) add("fastify")(r.methods, r.path, r.handler, r.file);
+      // A sub-app's routes are copied into the app that mounts it, so the widest table is the app.
+      const hono = [...honoApps].reduce((a, b) => (Array.isArray(b.routes) && b.routes.length > ((a && a.routes.length) || 0) ? b : a), null);
+      for (const r of hono ? hono.routes : []) if (r.method !== "ALL" || !r.path.endsWith("*")) add("hono")(r.method === "ALL" ? null : [r.method], r.path, r.handler, "");
+      for (const app of koaApps) for (const mw of app.middleware || []) for (const layer of (mw.router && mw.router.stack) || []) {
+        if (layer.methods && layer.methods.length) add("koa")(layer.methods, layer.path, layer.stack && layer.stack[layer.stack.length - 1], "");
+      }
+      for (const r of bunRoutes) add(seen.has("elysia") ? "elysia" : "unknown")(r.methods, r.path, r.handler, "");
+      const framework = nest ? "nest" : [...from][0] || [...seen][0] || "unknown";
+      return { framework, routes: [...out.values()] };
+    };
+    let routesSaid = -1, lastPort = null;
+    function sayRoutes(port) {
+      try {
+        lastPort = port;
+        const { framework, routes } = table();
+        routesSaid = routes.length;
+        row({ routes: { framework, port, routes, openapi: null } });
+      } catch { /* the table is a courtesy; the app is not */ }
+    }
+    // Routes an app adds after it starts listening are there by its first request.
+    let recheck = true;
+    const recheckRoutes = () => {
+      if (!recheck || lastPort === null) return;
+      recheck = false;
+      setImmediate(() => { try { if (table().routes.length !== routesSaid) sayRoutes(lastPort); } catch { /* as above */ } });
+    };
     const MAX = 65536;
+    // The turn a message came in under, when the run tagged it: one opaque id per request, so a
+    // model call and its prompt can be pinned to the reply they produced even while five turns are
+    // in flight. It is read here and never shown to your app's own code path beyond the header.
+    const TURN = /^[A-Za-z0-9:_.-]{1,80}$/;
+    const turnOf = (headers) => {
+      const t = headers && (typeof headers.get === "function" ? headers.get("x-cortad-turn") : headers["x-cortad-turn"]);
+      return typeof t === "string" && TURN.test(t) ? t : undefined;
+    };
+    // The customer's own rule sentences, written beside the trace by the run, so each model call can
+    // say which of them its prompt carried: a rule is then asked only of a reply whose call was told
+    // it. Absent file, nothing is claimed either way. Reloaded when the file changes.
+    const RULES = process.env.CORTAD_RULES_FILE;
+    let rules = null, rulesAt = -1;
+    const norm = (s) => String(s || "")
+      .replace(/\\u([0-9a-fA-F]{4})/g, (_, h) => String.fromCharCode(parseInt(h, 16)))
+      .replace(/\\[nrt]/g, " ").replace(/\\"/g, '"').replace(/\\\\/g, "\\")
+      .toLowerCase().replace(/\s+/g, " ").trim();
+    // A sentence with a slot in it ("answer in {language}") is matched by its literal parts.
+    const partsOf = (text) => text.split(/\{[^}]*\}|\$\{[^}]*\}|%[sd]|<[^>]{1,40}>/).map(norm).filter((p) => p.length >= 12);
+    const rulesNow = () => {
+      if (!RULES) return null;
+      try {
+        const at = fs.statSync(RULES).mtimeMs;
+        if (at !== rulesAt) {
+          rulesAt = at;
+          const list = JSON.parse(fs.readFileSync(RULES, "utf8"));
+          rules = Array.isArray(list)
+            ? list.filter((r) => r && typeof r.id === "string" && typeof r.text === "string").map((r) => ({ id: r.id, parts: partsOf(r.text) })).filter((r) => r.parts.length)
+            : [];
+        }
+      } catch { /* not written yet, or gone */ }
+      return rules;
+    };
+    // What the app's tools answered, as the prompt of the next model call carries them: the tool
+    // messages of a chat body, the function outputs of a responses body, the tool_result blocks of
+    // an Anthropic one, the functionResponse parts of a Gemini one. They are the material a reply's
+    // facts rest on, and without them a real ticket id read as invented. Bounded per call.
+    const TOOL_TEXT = 3000, TOOLS_MAX = 12;
+    const textOf = (v) => (typeof v === "string" ? v : Array.isArray(v) ? v.map((p) => (p && typeof p === "object" ? (p.text || p.content || "") : String(p || ""))).filter(Boolean).join("\n") : v && typeof v === "object" ? JSON.stringify(v) : "");
+    const toolsIn = (sent) => {
+      let body; try { body = JSON.parse(sent); } catch { return undefined; }
+      if (!body || typeof body !== "object") return undefined;
+      const out = [];
+      const names = new Map();
+      const add = (name, text) => { const t = textOf(text).slice(0, TOOL_TEXT); if (t.trim() && out.length < TOOLS_MAX && !out.some((o) => o.text === t)) out.push({ name: String(name || "").slice(0, 80), text: t }); };
+      for (const m of Array.isArray(body.messages) ? body.messages : []) {
+        if (!m || typeof m !== "object") continue;
+        for (const c of Array.isArray(m.tool_calls) ? m.tool_calls : []) if (c && c.id && c.function) names.set(c.id, c.function.name);
+        if (Array.isArray(m.content)) for (const c of m.content) if (c && c.type === "tool_use" && c.id) names.set(c.id, c.name);
+      }
+      for (const m of Array.isArray(body.messages) ? body.messages : []) {
+        if (!m || typeof m !== "object") continue;
+        if (m.role === "tool" || m.role === "function") add(m.name || names.get(m.tool_call_id), m.content);
+        if (Array.isArray(m.content)) for (const c of m.content) if (c && c.type === "tool_result") add(names.get(c.tool_use_id), c.content);
+      }
+      const items = Array.isArray(body.input) ? body.input : [];
+      for (const it of items) if (it && it.type === "function_call" && it.call_id) names.set(it.call_id, it.name);
+      for (const it of items) if (it && it.type === "function_call_output") add(names.get(it.call_id), it.output);
+      for (const c of Array.isArray(body.contents) ? body.contents : []) for (const p of c && Array.isArray(c.parts) ? c.parts : []) if (p && p.functionResponse) add(p.functionResponse.name, p.functionResponse.response);
+      return out.length ? out : undefined;
+    };
+    // A framework that folds its tools' answers into the next prompt as plain text (an agent loop
+    // writing "Observation: ..." into a user message) sends no tool message to find. Within one
+    // turn, what the second call's prompt carries that the first one did not, outside the model's
+    // own words, is that material. The first call of a turn holds the customer's message and the
+    // system prompt, and both are in every later call, so neither is ever counted.
+    const textsOf = (body) => {
+      const out = new Set();
+      const take = (v) => { const t = textOf(v).trim(); if (t) out.add(t.slice(0, TOOL_TEXT)); };
+      for (const m of Array.isArray(body.messages) ? body.messages : []) if (m && typeof m === "object" && m.role !== "assistant") take(m.content);
+      for (const it of Array.isArray(body.input) ? body.input : []) if (it && typeof it === "object" && it.role !== "assistant" && it.type !== "function_call") take(it.content ?? it.output);
+      if (typeof body.system === "string") take(body.system);
+      for (const c of Array.isArray(body.contents) ? body.contents : []) if (c && c.role !== "model") for (const p of Array.isArray(c.parts) ? c.parts : []) if (p && typeof p.text === "string") take(p.text);
+      return out;
+    };
+    const seenByTurn = new Map();
+    const materialIn = (sent, turn) => {
+      if (!turn) return undefined;
+      let body; try { body = JSON.parse(sent); } catch { return undefined; }
+      if (!body || typeof body !== "object") return undefined;
+      const now = textsOf(body);
+      const before = seenByTurn.get(turn);
+      seenByTurn.set(turn, now);
+      if (seenByTurn.size > 200) seenByTurn.delete(seenByTurn.keys().next().value);
+      if (!before) return undefined;
+      const fresh = [...now].filter((t) => !before.has(t)).slice(0, TOOLS_MAX).map((t) => ({ name: "", text: t }));
+      return fresh.length ? fresh : undefined;
+    };
+    const rulesIn = (sent) => {
+      const list = rulesNow();
+      if (!list) return undefined;
+      const body = norm(sent);
+      return list.filter((r) => r.parts.every((p) => body.includes(p))).map((r) => r.id);
+    };
     // Where models are served, by host, and the paths every OpenAI-shaped or vendor endpoint ends with.
     const MODEL_HOST = /(?:^|\.)(?:openai\.com|anthropic\.com|fireworks\.ai|openrouter\.ai|groq\.com|mistral\.ai|together\.xyz|together\.ai|deepseek\.com|cohere\.ai|cohere\.com|perplexity\.ai|x\.ai|googleapis\.com|openai\.azure\.com|cognitiveservices\.azure\.com|amazonaws\.com|replicate\.com|huggingface\.co|cerebras\.ai|deepinfra\.com|novita\.ai|moonshot\.cn|dashscope\.aliyuncs\.com|bigmodel\.cn|ai-gateway\.vercel\.sh|gateway\.ai\.cloudflare\.com|helicone\.ai|portkey\.ai)$/i;
     const MODEL_PATH = /\/(?:chat\/completions|completions|responses|messages|embeddings)$|:(?:generateContent|streamGenerateContent)|\/invoke(?:-with-response-stream)?$|\/api\/(?:chat|generate)$/i;
@@ -49,8 +325,10 @@ if (FILE) {
     const emit = http.Server.prototype.emit;
     http.Server.prototype.emit = function (type, req, ...rest) {
       if (type === "listening") { try { listening(this.address()?.port); } catch { /* not a TCP server */ } }
+      if (type === "request") recheckRoutes();
       if (type !== "request" || !req || !req.method || /^(?:GET|HEAD|OPTIONS)$/.test(req.method)) return emit.call(this, type, req, ...rest);
-      const ctx = { method: req.method, path: req.url || "/", headers: { ...req.headers }, chunks: [], size: 0, noted: false };
+      const { "x-cortad-turn": _turn, ...headers } = req.headers;
+      const ctx = { method: req.method, path: req.url || "/", headers, chunks: [], size: 0, noted: false, turn: turnOf(req.headers) };
       const push = req.push;
       req.push = function (chunk, encoding) {
         if (chunk && ctx.size < MAX) { const b = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding); ctx.chunks.push(b); ctx.size += b.length; }
@@ -82,10 +360,11 @@ if (FILE) {
     // is read from a clone, so the app's own reader is untouched.
     if (isBun) {
       const inside = (handler, self) => function (req, server) {
+        recheckRoutes();
         if (!req || /^(?:GET|HEAD|OPTIONS)$/.test(req.method)) return handler.call(self, req, server);
         let path = "/";
         try { const u = new URL(req.url); path = u.pathname + u.search; } catch { /* keep "/" */ }
-        const ctx = { method: req.method, path, headers: Object.fromEntries(req.headers), chunks: [], size: 0, noted: false };
+        const ctx = { method: req.method, path, headers: Object.fromEntries([...req.headers].filter(([k]) => k !== "x-cortad-turn")), chunks: [], size: 0, noted: false, turn: turnOf(req.headers) };
         // ponytail: a body is copied only when it is small or says it is text; an upload is left alone.
         const size = Number(req.headers.get("content-length") || 0);
         if (size <= MAX || /json|text|form/i.test(req.headers.get("content-type") || "")) {
@@ -105,6 +384,11 @@ if (FILE) {
         }
         return out;
       };
+      // Bun's own route table: a handler per path, or a handler per method.
+      const bunTable = (table) => Object.entries(table && typeof table === "object" ? table : {}).map(([path, value]) => (
+        typeof value === "function" ? { methods: null, path, handler: value }
+          : value instanceof Response ? { methods: ["GET"], path, handler: null }
+            : { methods: Object.keys(value || {}), path, handler: null }));
       const serve = Bun.serve;
       Bun.serve = function (options, ...rest) {
         let wrapped = options;
@@ -115,6 +399,10 @@ if (FILE) {
             if (options.routes) wrapped.routes = routes(options.routes);
           }
         } catch { wrapped = options; }
+        try {
+          if (Object.keys(require.cache).some((k) => k.includes("/node_modules/elysia/"))) seen.add("elysia");
+          bunRoutes = bunTable(options && options.routes);
+        } catch { /* no table */ }
         const server = serve.call(this, wrapped, ...rest);
         try { listening(server && server.port); } catch { /* not ours to fail */ }
         return server;
@@ -166,10 +454,12 @@ if (FILE) {
       const m = /\/models\/([^/:]+):|\/model\/([^/]+)\/(?:invoke|converse)/.exec(path || "");
       return m ? decodeURIComponent(m[1] || m[2]) : "";
     };
-    const meter = ({ host, path, sent, status, type, body }) => {
+    const meter = ({ host, path, sent, status, type, body, turn }) => {
       try {
         const reply = readReply(type, String(body || "").slice(0, REPLY_MAX));
-        const row = { at: Date.now(), host: String(host).replace(/:443$/, ""), model: String(askedFor(path, sent) || reply.model || "").slice(0, 160), status, ...(reply.tokens || { promptTokens: 0, cachedTokens: 0, completionTokens: 0 }), usage: Boolean(reply.tokens) };
+        const rules = rulesIn(sent);
+        const tools = toolsIn(sent) ?? materialIn(sent, turn);
+        const row = { at: Date.now(), host: String(host).replace(/:443$/, ""), model: String(askedFor(path, sent) || reply.model || "").slice(0, 160), status, ...(reply.tokens || { promptTokens: 0, cachedTokens: 0, completionTokens: 0 }), usage: Boolean(reply.tokens), ...(turn ? { turn } : {}), ...(rules ? { rules } : {}), ...(tools ? { tools } : {}) };
         fs.appendFileSync(FILE, JSON.stringify({ call: row }) + "\n", { mode: 0o600 });
       } catch { /* the command is gone */ }
     };
@@ -196,7 +486,8 @@ if (FILE) {
       } catch { return null; }
     };
     const depRow = (dep, status, code) => {
-      try { fs.appendFileSync(FILE, JSON.stringify({ dep: { at: Date.now(), env: dep.env, host: dep.host, status, code: code ? String(code).slice(0, 40) : undefined } }) + "\n", { mode: 0o600 }); } catch { /* the command is gone */ }
+      const turn = (als.getStore() || {}).turn;
+      try { fs.appendFileSync(FILE, JSON.stringify({ dep: { at: Date.now(), ...(dep.env ? { env: dep.env } : {}), host: dep.host, status, code: code ? String(code).slice(0, 40) : undefined, ...(turn ? { turn } : {}) } }) + "\n", { mode: 0o600 }); } catch { /* the command is gone */ }
     };
 
     // Outbound: the model call your app makes while it handles that request.
@@ -210,7 +501,10 @@ if (FILE) {
           if (isModelCall(u.host, u.pathname)) url = u;
         } catch { /* not a URL we can read */ }
         if (!url) {
-          const dep = depOf(input);
+          // Every outbound host, named by the setting that points at it when one does, and by the
+          // host alone otherwise: the search provider behind TAVILY_API_KEY has no URL setting.
+          let dep = depOf(input);
+          if (!dep) { try { const u = new URL(typeof input === "string" ? input : input && input.url ? input.url : String(input)); if (/^https?:$/.test(u.protocol) && !/^(localhost|127\.0\.0\.1|\[::1\])$/.test(u.hostname)) dep = { host: u.hostname }; } catch { /* not a URL */ } }
           if (!dep) return realFetch.apply(this, arguments);
           return realFetch.apply(this, arguments).then(
             (res) => { depRow(dep, res.status); return res; },
@@ -219,7 +513,7 @@ if (FILE) {
         }
         const sent = bodyText(init && init.body);
         note(als.getStore(), sent);
-        const call = { host: url.host, path: url.pathname, sent };
+        const call = { host: url.host, path: url.pathname, sent, turn: (als.getStore() || {}).turn };
         return realFetch.apply(this, arguments).then((res) => {
           try {
             // A clone is a tee: your app's branch gets every byte as fast as it reads, this one is read to the end.
@@ -248,7 +542,7 @@ if (FILE) {
             const end = req.end;
             req.write = function (chunk, ...r) { if (chunk && typeof chunk !== "function") parts.push(Buffer.from(chunk)); return write.call(this, chunk, ...r); };
             req.end = function (chunk, ...r) { if (chunk && typeof chunk !== "function") parts.push(Buffer.from(chunk)); sent = Buffer.concat(parts).toString("utf8"); note(ctx, sent); return end.call(this, chunk, ...r); };
-            const call = { host: String(host || ""), path: String(path || "").split("?")[0] };
+            const call = { host: String(host || ""), path: String(path || "").split("?")[0], turn: ctx && ctx.turn };
             let done = false;
             const once = (row) => { if (!done) { done = true; meter({ ...call, sent, ...row }); } };
             req.once("error", () => once({ status: 0, type: "", body: "" }));