cortad 0.3.1-rc.8 → 0.3.1-rc.9

package/lib/pyhook/sitecustomize.py

@@ -579,7 +579,7 @@ def _install():
     # person's latest message on, and Anthropic document and search_result blocks. The app's own
     # instructions are not passages: only what sits under such a label is.
     passage_text, passages_max = 3000, 6
-    material = re.compile(r"\b(?:retriev\w*|context|knowledge|documents?|sources?|search[ _-]?results?|references?|passages?|excerpts?|snippets?|chunks?|background|faq)\b|检索|知识|参考资料|资料|上下文|文档|背景", re.I)
+    material = re.compile(r"\b(?:retriev\w*|context|knowledge|documents?|sources?|search[ _-]?results?|references?|passages?|excerpts?|snippets?|chunks?|background|faq|relevant)\b|检索|知识|参考资料|资料|上下文|文档|背景|相关", re.I)
     heading = re.compile(r"^\s*(?:#{1,6}\s+[^\n]{1,80}|[^\n]{1,80}[:：]\s*(?:\([^\n)]*\))?|\[[^\n\]]{1,80}\]|={2,}\s*[^\n]{1,80}?\s*={2,})\s*$")
     # An inline label is a noun phrase that ends in the material word ("context:", "background:",
     # "retrieved passages:"): "4. Knowledge:" in a numbered instruction and a JSON key are not.
@@ -587,6 +587,36 @@ def _install():
     named = re.compile(r"(?:" + material.pattern + r")\s*$", re.I)
     tagged = re.compile(r"<([A-Za-z][\w-]*)[^>]*>([\s\S]*?)</\1>")
 
+    # A label's block runs on to the next heading of its own kind: "资料：" over retrieved chunks
+    # that open on markdown headings holds every chunk, where stopping at its first paragraph kept
+    # one chunk of five and the reader called the knowledge base's own 1% fee made up. A markdown
+    # label holds deeper headings. A closing paragraph that opens on a label of its own ("问题：...",
+    # "Question: ...") is the prompt's ask, not material. A long block is several passages, cut
+    # between its paragraphs.
+    markdown = re.compile(r"^\s*(#{1,6})\s")
+
+    def ends_block(label, line):
+        if not heading.match(line):
+            return False
+        outer, inner = markdown.match(label), markdown.match(line)
+        return not inner or bool(outer and len(inner.group(1)) <= len(outer.group(1)))
+
+    def asks(para):
+        m = inline.match(para.split("\n")[0])
+        return bool(m and not named.search(m.group(1)))
+
+    # A heading inside a fenced block is the material's own text: a README chunk's "## Features".
+    fence = re.compile(r"^\s*(?:```|~~~)", re.M)
+
+    def add_block(add, name, paras):
+        text = ""
+        for p in paras:
+            if text and len(text) + len(p) + 2 > passage_text:
+                add(name, text)
+                text = ""
+            text += ("\n\n" if text else "") + p
+        add(name, text)
+
     def labelled(text, add):
         def lift(m):
             if material.search(m.group(1).replace("_", " ")):
@@ -599,13 +629,14 @@ def _install():
             lines = paras[i].split("\n")
             head = lines[0]
             if heading.match(head) and material.search(head):
-                body = "\n".join(lines[1:])
-                # A heading alone on its paragraph labels what follows, up to the next heading.
-                if not body.strip():
-                    while i + 1 < len(paras) and len(body) < passage_text and not heading.match(paras[i + 1].split("\n")[0]):
-                        i += 1
-                        body += ("\n\n" if body else "") + paras[i]
-                add(re.sub(r"[#:：\[\]=]", "", head).strip(), body)
+                block = ["\n".join(lines[1:])]
+                fenced = len(fence.findall(block[0])) % 2 == 1
+                while i + 1 < len(paras) and (fenced or (not ends_block(head, paras[i + 1].split("\n")[0]) and not (i + 2 == len(paras) and asks(paras[i + 1])))):
+                    i += 1
+                    block.append(paras[i])
+                    if len(fence.findall(paras[i])) % 2 == 1:
+                        fenced = not fenced
+                add_block(add, re.sub(r"[#:：\[\]=]", "", head).strip(), block)
             else:
                 label = next((m for m in (inline.match(l) for l in lines) if m and named.search(m.group(1))), None)
                 if label:
@@ -855,7 +886,76 @@ def _install():
         except Exception:
             return ""
 
-    def meter(url, sent, status, kind, raw, turn=None):
+    # Which of the app's own lines made a model call, nearest first: the run names the code path that
+    # ran by it, where the read could only name the door. Its frames on this stack outside installed
+    # packages, then, when the call runs in a task another task awaits (LangChain runs each step of a
+    # chain as its own task), the awaiting task's. Relative to the folder the app was started in.
+    root = os.getcwd().replace(os.sep, "/").rstrip("/") + "/"
+    installed = re.compile(r"/(?:site-packages|dist-packages|\.venv|venv|__pypackages__)/|/lib/python\d")
+
+    def ours(frame, out):
+        f = frame.f_code.co_filename.replace(os.sep, "/")
+        if f.startswith(root) and not installed.search(f[len(root) - 1:]):
+            at = "%s:%d" % (f[len(root):], frame.f_lineno)
+            if at not in out:
+                out.append(at)
+        return len(out) >= 3
+
+    # The task that waits on this one: its wake-up is among this one's callbacks, directly, or behind
+    # the future an asyncio.gather callback closes over.
+    def awaiting(fut, depth=0):
+        for cb in getattr(fut, "_callbacks", None) or ():
+            fn = cb[0] if isinstance(cb, tuple) else cb
+            owner = getattr(fn, "__self__", None)
+            if owner is not None and owner is not fut and hasattr(owner, "get_coro"):
+                return owner
+            for cell in (getattr(fn, "__closure__", None) or ()) if depth < 2 else ():
+                try:
+                    inner = cell.cell_contents
+                except ValueError:
+                    continue
+                found = awaiting(inner, depth + 1) if inner is not fut and hasattr(inner, "_callbacks") else None
+                if found is not None:
+                    return found
+        return None
+
+    # An embedding call answers nobody, so where it was made names no path a reply came down.
+    embedding = re.compile(r"/embeddings$", re.I)
+
+    def callers_now(url):
+        if embedding.search(urlsplit(str(url)).path or ""):
+            return None
+        out = []
+        try:
+            # Below the event loop's own frames is whatever started the loop, not this call's path.
+            frame = sys._getframe(1)
+            while frame is not None and not frame.f_code.co_filename.replace(os.sep, "/").endswith("/asyncio/events.py"):
+                if ours(frame, out):
+                    return out
+                frame = frame.f_back
+            aio = sys.modules.get("asyncio")
+            try:
+                task = aio.current_task() if aio else None
+            except RuntimeError:
+                task = None
+            for _ in range(8):
+                task = awaiting(task) if task is not None else None
+                if task is None:
+                    break
+                chain, coro = [], task.get_coro()
+                while coro is not None and len(chain) < 64:
+                    f = getattr(coro, "cr_frame", None) or getattr(coro, "gi_frame", None) or getattr(coro, "ag_frame", None)
+                    if f is not None:
+                        chain.append(f)
+                    coro = getattr(coro, "cr_await", None) or getattr(coro, "gi_yieldfrom", None) or getattr(coro, "ag_await", None)
+                for f in reversed(chain):
+                    if ours(f, out):
+                        return out
+        except Exception:
+            pass
+        return out or None
+
+    def meter(url, sent, status, kind, raw, turn=None, caller=None):
         try:
             tokens, model, events = read_reply(kind, (raw or "")[:reply_max])
             parts = urlsplit(str(url))
@@ -878,6 +978,8 @@ def _install():
             passages = passages_in(as_text)
             if passages:
                 row["passages"] = passages
+            if caller:
+                row["caller"] = caller
             write({"call": row})
         except Exception:
             pass
@@ -1425,7 +1527,7 @@ def _install():
                 finally:
                     self.finish()
 
-        def watch(request, response, sent):
+        def watch(request, response, sent, caller):
             model = is_model_call(request.url)
             if not model and not is_retrieval(request.url):
                 dep(request.url, response.status_code)
@@ -1433,13 +1535,13 @@ def _install():
             kind = response.headers.get("content-type", "")
             if getattr(response, "_content", None) is not None:
                 if model:
-                    meter(request.url, sent, response.status_code, kind, response.content.decode("utf-8", "replace"))
+                    meter(request.url, sent, response.status_code, kind, response.content.decode("utf-8", "replace"), caller=caller)
                 else:
                     dep(request.url, response.status_code, passages=passages_from(response.content.decode("utf-8", "replace")))
                 return response
             turn = turn_now()
             if model:
-                done = lambda raw: meter(request.url, sent, response.status_code, kind, unpacked(raw, response.headers.get("content-encoding")), turn)
+                done = lambda raw: meter(request.url, sent, response.status_code, kind, unpacked(raw, response.headers.get("content-encoding")), turn, caller)
             else:
                 done = lambda raw: dep(request.url, response.status_code, passages=passages_from(unpacked(raw, response.headers.get("content-encoding"))), turn=turn)
             stream = response.stream
@@ -1448,7 +1550,7 @@ def _install():
             elif hasattr(stream, "__iter__"):
                 response.stream = SyncKept(stream, done)
             elif model:
-                meter(request.url, sent, response.status_code, kind, "")
+                meter(request.url, sent, response.status_code, kind, "", caller=caller)
             else:
                 dep(request.url, response.status_code)
             return response
@@ -1458,6 +1560,7 @@ def _install():
             if cls is module.Client:
                 def sync_send(self, request, *a, _send=send, **k):
                     sent = sent_of(request)
+                    caller = callers_now(request.url) if is_model_call(request.url) else None
                     try:
                         note(request.url, sent)
                     except Exception:
@@ -1466,18 +1569,19 @@ def _install():
                         response = _send(self, request, *a, **k)
                     except Exception as err:
                         if is_model_call(request.url):
-                            meter(request.url, sent, 0, "", "")
+                            meter(request.url, sent, 0, "", "", caller=caller)
                         else:
                             dep(request.url, 0, type(err).__name__)
                         raise
                     try:
-                        return watch(request, response, sent)
+                        return watch(request, response, sent, caller)
                     except Exception:
                         return response
                 cls.send = sync_send
             else:
                 async def async_send(self, request, *a, _send=send, **k):
                     sent = sent_of(request)
+                    caller = callers_now(request.url) if is_model_call(request.url) else None
                     try:
                         note(request.url, sent)
                     except Exception:
@@ -1486,12 +1590,12 @@ def _install():
                         response = await _send(self, request, *a, **k)
                     except Exception as err:
                         if is_model_call(request.url):
-                            meter(request.url, sent, 0, "", "")
+                            meter(request.url, sent, 0, "", "", caller=caller)
                         else:
                             dep(request.url, 0, type(err).__name__)
                         raise
                     try:
-                        return watch(request, response, sent)
+                        return watch(request, response, sent, caller)
                     except Exception:
                         return response
                 cls.send = async_send
@@ -1500,6 +1604,7 @@ def _install():
         send = module.Session.send
 
         def sent(self, request, *a, **k):
+            caller = callers_now(request.url) if is_model_call(request.url) else None
             try:
                 note(request.url, request.body)
             except Exception:
@@ -1517,7 +1622,7 @@ def _install():
                 if is_model_call(request.url):
                     # A streamed reply is counted as a call whose counts were not read.
                     raw = response.content.decode("utf-8", "replace") if getattr(response, "_content_consumed", False) else ""
-                    meter(request.url, text(request.body), response.status_code, response.headers.get("content-type", ""), raw)
+                    meter(request.url, text(request.body), response.status_code, response.headers.get("content-type", ""), raw, caller=caller)
             except Exception:
                 pass
             return response
@@ -1540,7 +1645,7 @@ def _install():
                     dep(str_or_url, 0, type(err).__name__)
                 raise
             if is_model_call(str_or_url):
-                response._cortad = (str_or_url, text(body), turn_now())
+                response._cortad = (str_or_url, text(body), turn_now(), callers_now(str_or_url))
             elif is_retrieval(str_or_url):
                 response._cortad_dep = (str_or_url, turn_now())
             else:
@@ -1559,7 +1664,7 @@ def _install():
             call = getattr(self, "_cortad", None)
             if call:
                 self._cortad = None
-                meter(call[0], call[1], self.status, self.headers.get("content-type", ""), (raw or b"").decode("utf-8", "replace"), call[2])
+                meter(call[0], call[1], self.status, self.headers.get("content-type", ""), (raw or b"").decode("utf-8", "replace"), call[2], call[3])
             return raw
 
         def release_kept(self, *a, **k):
@@ -1570,7 +1675,7 @@ def _install():
             call = getattr(self, "_cortad", None)
             if call:
                 self._cortad = None
-                meter(call[0], call[1], self.status, self.headers.get("content-type", ""), "", call[2])
+                meter(call[0], call[1], self.status, self.headers.get("content-type", ""), "", call[2], call[3])
             return release(self, *a, **k)
 
         module.ClientSession._request = requested

package/lib/replay.mjs

@@ -121,6 +121,9 @@ const calledOf = (v) => {
   return called.length ? { called } : {};
 };
 const passagesOf = (v) => (texts(v).length ? { passages: texts(v).slice(0, 6) } : {});
+// Which of the app's own lines made the call, nearest first, as "path:line".
+const AT = /^[^\n\r\t]{1,300}:\d{1,7}$/;
+const callerOf = (v) => { const caller = Array.isArray(v) ? v.filter((c) => typeof c === "string" && AT.test(c)).slice(0, 3) : []; return caller.length ? { caller } : {}; };
 const meter = (() => {
   const rows = [];
   const deps = [];
@@ -131,7 +134,7 @@ const meter = (() => {
       rows.push({
         at: count(call.at), host: call.host.slice(0, 253), model: String(call.model ?? "").slice(0, 160), status: count(call.status),
         promptTokens: count(call.promptTokens), cachedTokens: count(call.cachedTokens), completionTokens: count(call.completionTokens),
-        usage: call.usage === true, ...turnOf(call.turn), ...rulesOf(call.rules), ...toolsOf(call.tools), ...calledOf(call.called), ...passagesOf(call.passages),
+        usage: call.usage === true, ...turnOf(call.turn), ...rulesOf(call.rules), ...toolsOf(call.tools), ...calledOf(call.called), ...passagesOf(call.passages), ...callerOf(call.caller),
       });
       if (rows.length > ROWS) rows.splice(0, rows.length - ROWS);
     },
@@ -159,7 +162,7 @@ const meter = (() => {
       }
       return {
         totals: [...totals.values()].sort((a, b) => b.calls - a.calls),
-        rows: rows.slice(-400).reverse().map(({ at, host, model, status, turn, rules, tools, called, passages }) => ({ at, host, model, status, ...(turn ? { turn } : {}), ...(rules ? { rules } : {}), ...(tools ? { tools } : {}), ...(called ? { called } : {}), ...(passages ? { passages } : {}) })),
+        rows: rows.slice(-400).reverse().map(({ at, host, model, status, turn, rules, tools, called, passages, caller }) => ({ at, host, model, status, ...(turn ? { turn } : {}), ...(rules ? { rules } : {}), ...(tools ? { tools } : {}), ...(called ? { called } : {}), ...(passages ? { passages } : {}), ...(caller ? { caller } : {}) })),
         deps: deps.slice(-400).reverse(),
       };
     },

package/lib/text.mjs

@@ -159,13 +159,19 @@ const sideText = (m) => (m.rate ? rateText(m.rate) : m.unavailable ? null : move
 // Over zero pairs there is no move to print: the line says verification is unavailable and why,
 // never "no change, 0 points" measured on nothing. The visible side's reason is the said line.
 function verifyLines(v) {
-  // An access verify is a re-knock, not a trial move: the routes side by side, then the count.
+  // An access verify is a re-knock, not a trial move: the routes side by side, then the count. Only
+  // a route knocked and answered both times is compared; one the app no longer has or did not answer
+  // is named as such, never read as a closed gate.
   if (v.access) {
     const lines = [`Verify of ${v.findingId}.`];
     for (const r of v.routes ?? []) {
-      const then = r.wasOpen ? `answered ${r.before} with no sign-in` : `refused (${r.before || "no answer"})`;
-      const now = r.nowOpen ? `answers ${r.after} with no sign-in` : r.after ? `refuses (${r.after})` : "did not answer";
-      lines.push(`  ${r.method} ${r.route}: ${then}, now ${now}.`);
+      const then = r.wasOpen ? `answered ${r.before} with no sign-in` : `refused (${r.before})`;
+      const now =
+        r.state === "answered" ? (r.nowOpen ? `now answers ${r.after} with no sign-in` : `now refuses (${r.after})`)
+        : r.state === "gone" ? "your app no longer has this route"
+        : r.state === "no-answer" ? "your app did not answer this time"
+        : "was not knocked again";
+      lines.push(`  ${r.method} ${r.route}: ${then}, ${now}.`);
     }
     if (v.said) lines.push(v.said);
     return lines;
@@ -355,6 +361,9 @@ function findingBlock(f, placed) {
     // investigation itself.
     if (q.asked) lines.push(`  Asked: "${clip(q.asked, 300)}"`);
     lines.push(`  Reply ${q.reply}: "${clip(q.quote, 400)}"${about ? ` (${about})` : ""}`);
+    // What the reader checked the reply against: what their app retrieved for it, the start of each.
+    if (q.checked) lines.push(`    ${q.checked}`);
+    for (const p of (q.passages ?? []).slice(0, 3)) lines.push(`    Passage${p.source ? ` (${clip(p.source, 60)})` : ""}: "${clip(p.text, 240)}"`);
     // What a developer reproduces it from: the request as sent, the body back, the app's own log.
     if (q.request) lines.push(`    Request: ${q.request.method} ${q.request.path}${q.request.body ? ` ${clip(q.request.body, 600)}` : ""}`);
     if (has(q.response)) lines.push(`    Response: ${q.response ? clip(q.response, 600) : "(empty body)"}`);

package/lib/trace.cjs

@@ -119,15 +119,33 @@ if (FILE) {
       .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 frames of the stack it is called from, nearest first, outside this hook and node_modules,
+    // relative to the folder the app was started in. An awaited call keeps its awaiting frames in
+    // the stack, and an SDK is deeper than the default ten frames.
+    const stackFrames = () => {
+      const limit = Error.stackTraceLimit;
+      Error.stackTraceLimit = 60;
+      const stack = String(new Error().stack);
+      Error.stackTraceLimit = limit;
+      const out = [];
+      for (const line of stack.split("\n")) {
+        const m = /\(?(?:file:\/\/)?(\/[^()]+?):(\d+):\d+\)?$/.exec(line.trim());
+        if (m && m[1] !== __filename && !m[1].includes("/node_modules/")) out.push({ file: nodePath.relative(process.cwd(), decodeURI(m[1])), line: Number(m[2]) });
+      }
+      return out;
+    };
     // 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;
+    const callerFile = () => { const f = stackFrames()[0]; return f && !f.file.startsWith("..") ? f.file : ""; };
+    // Which of the app's own lines made a model call, nearest first: the run names the code path that
+    // ran by it, where the read could only name the door.
+    const callers = () => {
+      const out = [];
+      for (const f of stackFrames()) {
+        const at = `${f.file}:${f.line}`;
+        if (!f.file.startsWith("..") && !out.includes(at)) out.push(at);
+        if (out.length === 3) break;
       }
-      return "";
+      return out.length ? out : undefined;
     };
     const seen = new Set();
     let nest = false;
@@ -561,13 +579,36 @@ if (FILE) {
     // person's latest message on, and Anthropic document and search_result blocks. The app's own
     // instructions are not passages: only what sits under such a label is.
     const PASSAGE_TEXT = 3000, PASSAGES_MAX = 6;
-    const MATERIAL = /\b(?:retriev\w*|context|knowledge|documents?|sources?|search[ _-]?results?|references?|passages?|excerpts?|snippets?|chunks?|background|faq)\b|检索|知识|参考资料|资料|上下文|文档|背景/i;
+    const MATERIAL = /\b(?:retriev\w*|context|knowledge|documents?|sources?|search[ _-]?results?|references?|passages?|excerpts?|snippets?|chunks?|background|faq|relevant)\b|检索|知识|参考资料|资料|上下文|文档|背景|相关/i;
     const HEADING = /^\s*(?:#{1,6}\s+[^\n]{1,80}|[^\n]{1,80}[:：]\s*(?:\([^\n)]*\))?|\[[^\n\]]{1,80}\]|={2,}\s*[^\n]{1,80}?\s*={2,})\s*$/;
     // An inline label is a noun phrase that ends in the material word ("context:", "background:",
     // "retrieved passages:"): "4. Knowledge:" in a numbered instruction and a JSON key are not.
     const INLINE = /^\s*(?:[-*]\s+)?([A-Za-z\u4e00-\u9fff][A-Za-z\u4e00-\u9fff '’_-]{0,29})[:：]\s*\S/;
     const NAMED = new RegExp(`(?:${MATERIAL.source})\\s*$`, "i");
     const TAGGED = /<([A-Za-z][\w-]*)[^>]*>([\s\S]*?)<\/\1>/g;
+    // A label's block runs on to the next heading of its own kind: "资料：" over retrieved chunks
+    // that open on markdown headings holds every chunk, where stopping at its first paragraph kept
+    // one chunk of five and the reader called the knowledge base's own 1% fee made up. A markdown
+    // label holds deeper headings. A closing paragraph that opens on a label of its own ("问题：...",
+    // "Question: ...") is the prompt's ask, not material. A long block is several passages, cut
+    // between its paragraphs.
+    const MARKDOWN = /^\s*(#{1,6})\s/;
+    const endsBlock = (label, line) => {
+      if (!HEADING.test(line)) return false;
+      const outer = MARKDOWN.exec(label), inner = MARKDOWN.exec(line);
+      return !inner || Boolean(outer && inner[1].length <= outer[1].length);
+    };
+    const asks = (para) => { const m = INLINE.exec(para.split("\n")[0]); return Boolean(m && !NAMED.test(m[1])); };
+    // A heading inside a fenced block is the material's own text: a README chunk's "## Features".
+    const fences = (para) => (para.match(/^\s*(?:```|~~~)/gm) || []).length;
+    const addBlock = (add, name, paras) => {
+      let text = "";
+      for (const p of paras) {
+        if (text && text.length + p.length + 2 > PASSAGE_TEXT) { add(name, text); text = ""; }
+        text += (text ? "\n\n" : "") + p;
+      }
+      add(name, text);
+    };
     const labelled = (text, add) => {
       const rest = String(text || "").replace(TAGGED, (all, tag, inner) => { if (MATERIAL.test(tag.replace(/_/g, " "))) { add(tag, inner); return ""; } return all; });
       const paras = rest.split(/\n\s*\n/);
@@ -575,10 +616,13 @@ if (FILE) {
         const lines = paras[i].split("\n");
         const head = lines[0];
         if (HEADING.test(head) && MATERIAL.test(head)) {
-          let body = lines.slice(1).join("\n");
-          // A heading alone on its paragraph labels what follows, up to the next heading.
-          if (!body.trim()) while (i + 1 < paras.length && body.length < PASSAGE_TEXT && !HEADING.test(paras[i + 1].split("\n")[0])) body += (body ? "\n\n" : "") + paras[++i];
-          add(head.replace(/[#:：[\]=]/g, "").trim(), body);
+          const block = [lines.slice(1).join("\n")];
+          let fenced = fences(block[0]) % 2 === 1;
+          while (i + 1 < paras.length && (fenced || (!endsBlock(head, paras[i + 1].split("\n")[0]) && !(i + 2 === paras.length && asks(paras[i + 1]))))) {
+            block.push(paras[++i]);
+            if (fences(paras[i]) % 2 === 1) fenced = !fenced;
+          }
+          addBlock(add, head.replace(/[#:：[\]=]/g, "").trim(), block);
           continue;
         }
         const inline = lines.map((l) => INLINE.exec(l)).find((m) => m && NAMED.test(m[1]));
@@ -636,6 +680,8 @@ if (FILE) {
     // 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;
+    // An embedding call answers nobody, so where it was made names no path a reply came down.
+    const EMBEDDING = /\/embeddings$/i;
     const isModelCall = (host, path) => {
       const h = String(host || "").replace(/:\d+$/, "");
       const p = String(path || "").split("?")[0];
@@ -790,14 +836,14 @@ 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, turn }) => {
+    const meter = ({ host, path, sent, status, type, body, turn, caller }) => {
       try {
         const reply = readReply(type, String(body || "").slice(0, REPLY_MAX));
         const rules = rulesIn(sent);
         const tools = toolsIn(sent);
         const called = calledIn(sent, reply.events);
         const passages = passagesIn(sent);
-        row({ call: { 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 } : {}), ...(called ? { called } : {}), ...(passages ? { passages } : {}) } });
+        row({ call: { 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 } : {}), ...(called ? { called } : {}), ...(passages ? { passages } : {}), ...(caller ? { caller } : {}) } });
       } catch { /* the command is gone */ }
     };
 
@@ -1014,7 +1060,7 @@ if (FILE) {
         }
         const sent = bodyText(init && init.body);
         note(als.getStore(), sent);
-        const call = { host: url.host, path: url.pathname, sent, turn: (als.getStore() || {}).turn };
+        const call = { host: url.host, path: url.pathname, sent, turn: (als.getStore() || {}).turn, caller: EMBEDDING.test(url.pathname) ? undefined : callers() };
         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.
@@ -1043,7 +1089,8 @@ 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], turn: ctx && ctx.turn };
+            const bare = String(path || "").split("?")[0];
+            const call = { host: String(host || ""), path: bare, turn: ctx && ctx.turn, caller: EMBEDDING.test(bare) ? undefined : callers() };
             let done = false;
             const once = (row) => { if (!done) { done = true; meter({ ...call, sent, ...row }); } };
             req.once("error", () => once({ status: 0, type: "", body: "" }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cortad",
-  "version": "0.3.1-rc.8",
+  "version": "0.3.1-rc.9",
   "description": "Connects the AI app on your machine to Cortad for test conversations, and gives your coding agent the MCP and skill to run them. No dependencies.",
   "bin": {
     "cortad": "local.mjs"