premanmcp 1.1.15 → 1.1.16

package/bin/eval.js

@@ -379,6 +379,15 @@ export function tracesInProcess(target) {
   return target?.kind === "callable" && target.language === "python" && IN_PROCESS_SHAPES.has(target.shape || "");
 }
 
+/** Shapes whose agent runs in its own process, so the harness needs nothing of the customer's. */
+const OUT_OF_PROCESS_SHAPES = new Set(["node_bridge", "cli_subprocess"]);
+
+/** Record, for the job runner, whether this target's agent is imported into the harness. */
+export function markAgentProcess(target) {
+  process.env.PREMAN_EVAL_AGENT_IN_PROCESS =
+    target?.kind === "callable" && OUT_OF_PROCESS_SHAPES.has(target.shape || "") ? "0" : "1";
+}
+
 /** How long a first resolve may take before it counts as a failure. */
 const COLD_RESOLVE_MS = 600_000;
 
@@ -1268,12 +1277,13 @@ export async function executeEvalRun(
     home = suiteHome(job);
     pruneRuns(home, job);
     laid = materialize(job, home, { trace: process.env.PREMAN_EVAL_TRACE === "1" });
-    // Offered only when the harness is the only thing that has to import
-    // anything. A `callable` target imports the customer's agent in-process, so
-    // it must resolve against an environment that has *their* dependencies —
-    // PreMan's bundle has assert-ai and nothing of theirs.
+    // Only an agent imported into the harness needs the customer's environment:
+    // it must resolve against *their* dependencies, and PreMan's bundle has
+    // assert-ai and nothing of theirs. A node bridge or a command runs the agent
+    // in its own process, so PreMan's runtime is enough there.
+    const agentInProcess = process.env.PREMAN_EVAL_AGENT_IN_PROCESS !== "0";
     const runtime =
-      String(job.target_kind || "") === "callable"
+      String(job.target_kind || "") === "callable" && agentInProcess
         ? ""
         : await ensureRuntime({ log, download, progress: progressLine });
     python = resolveInterpreter({ projectPath, log, runtime });
@@ -1991,6 +2001,7 @@ async function runWithToken(
     // import path, so the harness reads this and inserts it before handing off.
     process.env.PREMAN_EVAL_SYS_PATH = target.sysPath;
   }
+  markAgentProcess(target);
   // On unless PREMAN_EVAL_TRACE=0 (docs/EVAL_AGENT_TRACING.md). Kept only for an
   // agent that runs inside the harness's Python process; a node bridge or a
   // subprocess is invisible to in-process tracing, and tracing it would only

package/bin/eval_harness.py

@@ -309,11 +309,19 @@ def _turn_raw(ref, raw_result):
 
     Carried on ``raw`` because assert-ai stores it verbatim and owns every other
     field of the artifact; the backend reads it back per turn
-    (docs/superpowers/specs/2026-09-30-tool-call-capture-design.md §7.2).
+    (docs/superpowers/specs/2026-09-30-tool-call-capture-design.md §7.2). A
+    proxied agent's token counts become model-call nodes here, as spans would
+    (docs/superpowers/specs/2026-10-08-proxy-tokens-ts-design.md §5).
     """
     raw = {"callable": ref}
     capture = raw_result.get("tool_capture")
     if isinstance(capture, dict):
+        try:
+            built = _proxy_nodes(capture)
+            if built is not None:
+                _add_nodes(raw, *built)
+        except Exception:
+            capture.pop("model_calls", None)
         raw["tool_capture"] = _session._sanitize_endpoint_value(capture)
     return raw
 
@@ -334,6 +342,79 @@ def _attach_capture(result, payload):
             return
 
 
+def _span_tokens_in(events) -> bool:
+    return any(isinstance(e, dict) and isinstance((e.get("raw") or {}).get("_tokens"), dict) for e in events or [])
+
+
+def _proxy_nodes(capture, spans_have_tokens=False):
+    """The proxy's token records for one turn, as the model-call nodes spans would give.
+
+    Pops ``model_calls`` so the stored capture never carries them. All or
+    nothing: one call without counts leaves the turn with none and
+    ``tokens_missing`` saying why, because a partial sum reads as a complete
+    number. Returns (nodes, totals) or None.
+    """
+    if not isinstance(capture, dict):
+        return None
+    calls = capture.pop("model_calls", None)
+    if not calls or spans_have_tokens:
+        return None
+    if not isinstance(calls, list) or not all(isinstance(c, dict) for c in calls):
+        capture["tokens_missing"] = "a model call's token counts could not be read"
+        return None
+    gap = next((c for c in calls if not (isinstance(c.get("input"), int) and isinstance(c.get("output"), int))), None)
+    if gap is not None:
+        capture["tokens_missing"] = gap.get("missing") or "a model call's token counts could not be read"
+        return None
+    nodes = [
+        {
+            "view": ["target", "combined"],
+            "actor": "target",
+            "edit": {"type": "add_message", "message": {"role": "assistant", "content": ""}},
+            "raw": {
+                "_node": c.get("kind") or "model",
+                "_model": c.get("model") or "",
+                "_tokens": {"input": c["input"], "output": c["output"]},
+                "_latency_ms": c.get("ms"),
+                "_source": "proxy",
+            },
+        }
+        for c in calls
+    ]
+    totals = {
+        "total_tokens": {"input": sum(c["input"] for c in calls), "output": sum(c["output"] for c in calls)},
+        "total_latency_ms": round(sum(c["ms"] for c in calls if isinstance(c.get("ms"), (int, float))), 1),
+        "llm_call_count": len(calls),
+    }
+    return nodes, totals
+
+
+def _add_nodes(raw, nodes, totals):
+    raw["trace_events"] = list(raw.get("trace_events") or []) + nodes
+    meta = dict(raw.get("trace_metadata") or {"nodes_visited": [], "tools_called": []})
+    meta.update(totals)
+    raw["trace_metadata"] = meta
+
+
+def _attach_proxy_nodes(result, payload):
+    """Token nodes for a traced turn whose spans carried no tokens (a proxied agent)."""
+    capture = payload.get("tool_capture") if isinstance(payload, dict) else None
+    if not isinstance(capture, dict):
+        return
+    try:
+        raw = result.raw if isinstance(result.raw, dict) else None
+        built = _proxy_nodes(capture, spans_have_tokens=_span_tokens_in((raw or {}).get("trace_events")))
+        if built is None or raw is None:
+            return
+        _add_nodes(raw, *built)
+        for message in reversed(result.interaction_messages):
+            if message.get("role") == "assistant" and isinstance(message.get("raw"), dict):
+                _add_nodes(message["raw"], *built)
+                return
+    except Exception:
+        capture.pop("model_calls", None)  # never fail the turn, never store the raw records
+
+
 async def _callable_run_turn(self, messages: list[Message]) -> TurnResult:
     user_text = ""
     for msg in reversed(messages):
@@ -632,6 +713,7 @@ if os.environ.get("PREMAN_EVAL_TRACE") == "1":
             _use_span_trace(payload, holder)
         except Exception:
             pass  # a trace that cannot be chosen must never fail the turn
+        _attach_proxy_nodes(result, payload)
         _attach_capture(result, payload)
         if payload is None or any(m.get("role") == "tool" for m in result.interaction_messages):
             return result  # nothing reported, or the spans already carry the tools

package/bin/eval_templates.js

@@ -878,10 +878,18 @@ def _runtime() -> str:
     PATH, and the wrapper died inside subprocess with a FileNotFoundError that
     read as a broken wrapper rather than a missing tool. Current Node strips
     TypeScript types by itself, so falling back to "node" is usually right and
-    is always better than a traceback.
+    is always better than a traceback. A repo-local runtime in node_modules/.bin
+    wins over PATH.
     """
     for name in (_WANTED, "node"):
-        if name and shutil.which(name):
+        if not name:
+            continue
+        # A repo's own runtime first: "npm install" puts tsx there, not on PATH.
+        # which() honours PATHEXT, so Windows gets tsx.cmd rather than the shell script beside it.
+        local = shutil.which(name, path=str(_REPO / "node_modules" / ".bin"))
+        if local:
+            return local
+        if shutil.which(name):
             return name
     raise RuntimeError(
         "no JavaScript runtime found: tried %r and 'node'. Install Node, or "
@@ -999,7 +1007,32 @@ console.log = (...args) => process.stderr.write(args.join(" ") + "\n");
 
 const mod = await import(%%NODE_ENTRY%%);
 const agent = mod[%%ENTRY_SYMBOL%%] ?? mod.default;
-if (typeof agent !== "function") {
+
+// The text of a LangChain / LangGraph message list's last message.
+function lastText(messages) {
+  const last = Array.isArray(messages) ? messages[messages.length - 1] : undefined;
+  const content = last?.content;
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((part) => (typeof part === "string" ? part : part?.type === "text" ? part.text ?? "" : "")).join("");
+  }
+  return JSON.stringify(last ?? null);
+}
+
+// A function export is called as before. A LangChain/LangGraph agent or graph is
+// an object with invoke(); a Vercel AI SDK ToolLoopAgent has generate(), which
+// takes messages or prompt, never both.
+const turn =
+  typeof agent === "function"
+    ? (message, history) => agent(message, history)
+    : typeof agent?.invoke === "function"
+      ? async (message, history) =>
+          lastText((await agent.invoke({ messages: [...history, { role: "user", content: message }] }))?.messages)
+      : typeof agent?.generate === "function"
+        ? async (message, history) =>
+            (await agent.generate({ messages: [...history, { role: "user", content: message }] }))?.text ?? ""
+        : null;
+if (turn === null) {
   out(JSON.stringify({ error: %%ENTRY_SYMBOL%% + " is not a function in " + %%NODE_ENTRY%% }) + "\n");
   process.exit(1);
 }
@@ -1008,7 +1041,7 @@ for await (const line of createInterface({ input: process.stdin })) {
   if (!line.trim()) continue;
   try {
     const { message, history } = JSON.parse(line);
-    const reply = await agent(message, history ?? []);
+    const reply = await turn(message, history ?? []);
     const text = typeof reply === "string" ? reply : (reply?.response ?? JSON.stringify(reply));
     out(JSON.stringify({ response: text, events: reply?.events ?? [] }) + "\n");
   } catch (error) {

package/bin/runner.js

@@ -38,7 +38,7 @@ import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
-import { executeEvalRun } from "./eval.js";
+import { executeEvalRun, markAgentProcess } from "./eval.js";
 import { discoverTarget, startAdapter, stepFeed } from "./eval_target.js";
 import { resolveEvalSurface } from "./link.js";
 import { CREDENTIALS_DIR, backendUrl, callBackendJson, cliInvocation, makeArgs, nowMs, onPath, openUrl, packageVersion, resolveApiKey } from "./shared.js";
@@ -746,6 +746,7 @@ async function serveEvalTarget(args, { log }) {
     log(`no agent to evaluate on this machine (${error.message}); eval runs will not be offered`);
     return null;
   }
+  markAgentProcess(target);
 
   try {
     const adapter = await startAdapter(target, args, {

package/bin/tool_proxy.py

@@ -18,6 +18,7 @@ import json
 import os
 import secrets
 import threading
+import time
 import urllib.error
 import urllib.request
 import zlib
@@ -84,6 +85,17 @@ _NO_TOOLS_OFFERED = (
     "(for example, tools named in plain text)"
 )
 _UNSEEN = (_NO_TRAFFIC, _CHANNEL_CLOSED, _NO_TOOLS_OFFERED)
+_UNREAD_PATHS = "the agent's model requests went to %s, which PreMan does not read"
+
+
+def _unread(paths):
+    shown = sorted(set(paths))
+    return _UNREAD_PATHS % ", ".join(shown[:3] + (["…"] if len(shown) > 3 else []))
+
+
+def _unseen(reason):
+    """The proxy saw nothing of the turn it could read, so the agent's own report decides."""
+    return reason in _UNSEEN or str(reason or "").startswith(_UNREAD_PATHS.split("%s")[0])
 
 
 def _call(out, cid, name, args):
@@ -300,6 +312,93 @@ def _decoded(body: bytes, encoding: str) -> bytes:
     raise _Unreadable("a model reply was compressed with %s" % encoding)
 
 
+_TOO_BIG = "a model reply was larger than 2 MB, so it was forwarded without being read"
+_USAGE_NOT_ASKED = (
+    "the reply was streamed without token counts; the agent can add "
+    "stream_options: {include_usage: true} to its request"
+)
+_USAGE_ENDED_EARLY = "the streamed reply ended without its token counts"
+_USAGE_ABSENT = "the reply carried no token counts"
+_USAGE_CUT = "a model reply was cut off before it ended"
+
+
+def _int(value):
+    return value if isinstance(value, int) and not isinstance(value, bool) else None
+
+
+def _counts(kind, usage):
+    """(input, output) from one usage object, or None when either is absent.
+
+    Anthropic input adds both cache fields, as the OpenInference Anthropic plugin
+    does, so a proxied agent's numbers read like a traced Python agent's.
+    """
+    if not isinstance(usage, dict):
+        return None
+    if kind == "openai_chat":
+        tokens_in, tokens_out = _int(usage.get("prompt_tokens")), _int(usage.get("completion_tokens"))
+    else:
+        tokens_in, tokens_out = _int(usage.get("input_tokens")), _int(usage.get("output_tokens"))
+        if kind == "anthropic" and tokens_in is not None:
+            tokens_in += (_int(usage.get("cache_creation_input_tokens")) or 0) + (
+                _int(usage.get("cache_read_input_tokens")) or 0
+            )
+    if tokens_in is None or tokens_out is None:
+        return None
+    return tokens_in, tokens_out
+
+
+def _usage_in_reply(kind, reply):
+    """(model, counts) from a whole JSON reply."""
+    return str(reply.get("model") or ""), _counts(kind, reply.get("usage"))
+
+
+def _usage_in_stream(kind, raw: bytes):
+    """(model, counts) from a streamed reply.
+
+    Anthropic's message_delta usage holds running totals, so a later value
+    replaces an earlier one; nothing is added across events.
+    """
+    model, usage = "", None
+    if kind == "openai_chat":
+        for event in _sse(raw):
+            model = event.get("model") or model
+            if isinstance(event.get("usage"), dict):
+                usage = event["usage"]
+    elif kind == "openai_responses":
+        for event in _sse(raw):
+            response = event.get("response")
+            if isinstance(response, dict):
+                model = response.get("model") or model
+                if event.get("type") == "response.completed":
+                    usage = response.get("usage")
+    elif kind == "anthropic":
+        usage = {}
+        for event in _sse(raw):
+            if event.get("type") == "message_start":
+                message = event.get("message") or {}
+                model = message.get("model") or model
+                source = message.get("usage")
+            elif event.get("type") == "message_delta":
+                source = event.get("usage")
+            else:
+                continue
+            if isinstance(source, dict):
+                usage.update({key: value for key, value in source.items() if value is not None})
+    return str(model or ""), _counts(kind, usage)
+
+
+def _request_facts(body: bytes):
+    """The request's model, and whether it asked for streamed token counts."""
+    try:
+        request = json.loads(body or b"{}")
+    except ValueError:
+        return "", False
+    if not isinstance(request, dict):
+        return "", False
+    options = request.get("stream_options")
+    return str(request.get("model") or ""), bool(isinstance(options, dict) and options.get("include_usage"))
+
+
 def _not_visible(reason):
     return {"state": "not_visible", "source": "proxy", "watched": [], "missing": [], "reason": reason}
 
@@ -313,12 +412,15 @@ class _Turn:
         self.results = {}    # id -> content
         self.asked = []      # ids the model asked for in a reply during this turn
         self.model_requests = 0
+        self.other_paths = []  # POSTs to paths the proxy does not read
         self.problem = ""
         self.reused_id = False  # a reply asked for an id an earlier turn already reported
         self.reused_in_turn = False  # a reply asked for an id already seen in this turn
         self.offered_tools = False  # some model request in the turn offered the model tools
         self.last_reply_failed = False  # the most recent model reply was an HTTP error
         self.unrecorded = []  # keys of tool items PreMan cannot record, filed as reported at the end
+        self.model_calls = []  # one per model reply read this turn: token counts or why they are missing
+        self.in_flight = 0  # model requests forwarded this turn whose reply has not been read yet
         self.already = already if already is not None else set()
         # Ids asked for in an earlier turn of this channel whose result never
         # went back, with their (name, args): a result for one arriving now
@@ -345,18 +447,62 @@ class _Turn:
         with self._lock:
             self.problem = self.problem or reason
 
+    def _model_call(self, kind, model, counts, ms, missing):
+        self.model_calls.append({
+            "kind": kind,
+            "model": model,
+            "input": counts[0] if counts else None,
+            "output": counts[1] if counts else None,
+            "ms": round(float(ms), 1) if isinstance(ms, (int, float)) else None,
+            "missing": None if counts else missing,
+        })
+
+    def _saw_tokens(self, kind, raw, reply, streamed, ms, cut, request_model, asked_usage):
+        if cut:
+            return self._model_call(kind, request_model, None, ms, _USAGE_CUT)
+        try:
+            model, counts = _usage_in_stream(kind, raw) if streamed else _usage_in_reply(kind, reply)
+        except _Unreadable as exc:
+            return self._model_call(kind, request_model, None, ms, str(exc))
+        except Exception:
+            return self._model_call(kind, request_model, None, ms, "a model reply's token counts could not be read")
+        missing = None
+        if counts is None:
+            if streamed and kind == "openai_chat":
+                missing = _USAGE_ENDED_EARLY if asked_usage else _USAGE_NOT_ASKED
+            else:
+                missing = _USAGE_ABSENT
+        self._model_call(kind, model or request_model, counts, ms, missing)
+
     def saw_request(self, kind, body):
         with self._lock:
             return self._saw_request(kind, body)
 
-    def saw_reply(self, kind, status, content_type, content_encoding, body, truncated, conv=None):
+    def request_started(self):
+        with self._lock:
+            self.in_flight += 1
+
+    def request_ended(self):
+        with self._lock:
+            self.in_flight = max(0, self.in_flight - 1)
+
+    def saw_other(self, path):
         with self._lock:
-            return self._saw_reply(kind, status, content_type, content_encoding, body, truncated, conv)
+            self.other_paths.append(path)
+
+    def saw_reply(self, kind, status, content_type, content_encoding, body, truncated, conv=None,
+                  *, ms=None, cut=False, request_model="", asked_usage=False):
+        with self._lock:
+            return self._saw_reply(kind, status, content_type, content_encoding, body, truncated, conv,
+                                   ms=ms, cut=cut, request_model=request_model, asked_usage=asked_usage)
 
     def outcome(self):
         with self._lock:
             events, capture = self._outcome()
             capture["trace"] = self._trace(self._counted)
+            if self.in_flight > 0:
+                self._model_call("", "", None, None, "a model reply was still arriving when the turn ended")
+            capture["model_calls"] = list(self.model_calls)
             return events, capture
 
     def _conversation(self, referenced):
@@ -447,20 +593,35 @@ class _Turn:
                 self.unrecorded.append("item:" + key)
             self._fail(reason)
 
-    def _saw_reply(self, kind, status, content_type, content_encoding, body, truncated, conv=None):
+    def _saw_reply(self, kind, status, content_type, content_encoding, body, truncated, conv=None,
+                   *, ms=None, cut=False, request_model="", asked_usage=False):
+        self.in_flight = max(0, self.in_flight - 1)
         if status >= 400:
             self.last_reply_failed = True  # asks for no tool; cleared if a retry succeeds
             return
         self.last_reply_failed = False
         if truncated:
-            return self._fail("a model reply was larger than 2 MB, so it was forwarded without being read")
+            self._model_call(kind, request_model, None, ms, _TOO_BIG)
+            return self._fail(_TOO_BIG)
+        streamed = "text/event-stream" in (content_type or "")
+        reply = None
         try:
             raw = _decoded(body, content_encoding)
-            if "text/event-stream" in (content_type or ""):
+            if not streamed:
+                reply = json.loads(raw or b"{}")
+        except _Unreadable as exc:
+            self._model_call(kind, request_model, None, ms, str(exc))
+            return self._fail(str(exc))
+        except (ValueError, OSError, zlib.error):
+            self._model_call(kind, request_model, None, ms, "a model reply could not be read")
+            return self._fail("a model reply could not be read")
+        self._saw_tokens(kind, raw, reply if isinstance(reply, dict) else {}, streamed, ms, cut,
+                         request_model, asked_usage)
+        try:
+            if streamed:
                 calls = _requests_in_stream(kind, raw)
                 unrecorded = _unrecorded_in_stream(kind, raw)
             else:
-                reply = json.loads(raw or b"{}")
                 calls = _requests_in_reply(kind, reply) if isinstance(reply, dict) else []
                 unrecorded = _unrecorded_in_reply(kind, reply) if isinstance(reply, dict) else []
         except _Unreadable as exc:
@@ -529,7 +690,7 @@ class _Turn:
         if orphan_results:
             return events, _not_visible("a tool result went back to the model for a call PreMan could not read")
         if not self.model_requests:
-            return events, _not_visible(_NO_TRAFFIC)
+            return events, _not_visible(_unread(self.other_paths) if self.other_paths else _NO_TRAFFIC)
         if self.last_reply_failed:
             return events, _not_visible(
                 "the model's last reply in this turn was an HTTP error, so the agent may have answered "
@@ -547,6 +708,24 @@ class _Turn:
 
 DEFAULT_UPSTREAM = {"openai": "https://api.openai.com/v1", "anthropic": "https://api.anthropic.com"}
 ENV_VAR = {"openai": "OPENAI_BASE_URL", "anthropic": "ANTHROPIC_BASE_URL"}
+# Names LangChain.js reads before ENV_VAR's: OPENAI_API_BASE (@langchain/openai
+# chat_models/base.js:234) and ANTHROPIC_API_URL (@langchain/anthropic
+# chat_models.js:670). Each gets its own path and upstream, so every client keeps
+# the address it would have used: the official SDKs read only ENV_VAR's names.
+ALIASES = {"openai-api-base": ("openai", "OPENAI_API_BASE"), "anthropic-api-url": ("anthropic", "ANTHROPIC_API_URL")}
+ROUTES = {**{provider: (provider, var) for provider, var in ENV_VAR.items()}, **ALIASES}  # path segment -> (provider, variable)
+
+
+def _upstreams(given=None):
+    """Where each route forwards: its own variable, else (an alias) the provider's
+    ENV_VAR, which is what LangChain falls back to, else the provider's default.
+    A ``given`` map keyed by provider fills the alias routes of that provider too."""
+    if given:
+        return {**{route: given[provider] for route, (provider, _) in ROUTES.items() if provider in given}, **given}
+    return {
+        route: (os.environ.get(var) or os.environ.get(ENV_VAR[provider]) or DEFAULT_UPSTREAM[provider]).rstrip("/")
+        for route, (provider, var) in ROUTES.items()
+    }
 TIMEOUT = float(os.environ.get("PREMAN_AGENT_TIMEOUT", "600"))
 _HOP = {
     "connection", "keep-alive", "proxy-connection", "proxy-authorization", "transfer-encoding",
@@ -579,10 +758,7 @@ def version() -> str:
 
 class Proxy:
     def __init__(self, upstream=None):
-        self.upstream = upstream or {
-            provider: (os.environ.get(var) or DEFAULT_UPSTREAM[provider]).rstrip("/")
-            for provider, var in ENV_VAR.items()
-        }
+        self.upstream = _upstreams(upstream)
         self._channels = {}
         self._lock = threading.Lock()
         self._server = _Server(("127.0.0.1", 0), _handler(self))
@@ -597,7 +773,7 @@ class Proxy:
         return token
 
     def env(self, token: str) -> dict:
-        env = {var: "http://127.0.0.1:%d/%s/%s" % (self.port, token, provider) for provider, var in ENV_VAR.items()}
+        env = {var: "http://127.0.0.1:%d/%s/%s" % (self.port, token, route) for route, (_, var) in ROUTES.items()}
         # An agent behind HTTP(S)_PROXY must still reach this local proxy directly.
         hosts = [h.strip() for h in (os.environ.get("NO_PROXY") or os.environ.get("no_proxy") or "").split(",") if h.strip()]
         hosts += [h for h in ("127.0.0.1", "localhost") if h not in hosts]
@@ -616,6 +792,7 @@ class Proxy:
             if channel is None:
                 capture = _not_visible(_CHANNEL_CLOSED)
                 capture["trace"] = {"links": "order_only", "reason": _CHANNEL_CLOSED, "known": [], "unknown": {}, "calls": []}
+                capture["model_calls"] = []
                 capture["proxy_version"] = version()
                 return [], capture
             turn, channel["turn"] = channel["turn"], None
@@ -625,6 +802,7 @@ class Proxy:
             capture = dict(
                 _not_visible("a model request arrived between turns, so it was not filed under any of them"),
                 trace=capture.get("trace"),
+                model_calls=capture.get("model_calls", []),
             )
         capture["proxy_version"] = version()
         return events, capture
@@ -684,21 +862,29 @@ def _handler(proxy):
             self.close_connection = True
 
         def _forward(self):
-            parts = self.path.split("/", 3)  # ["", token, provider, rest]
-            if len(parts) < 3 or parts[2] not in ENV_VAR:
+            parts = self.path.split("/", 3)  # ["", token, route, rest]
+            if len(parts) < 3 or parts[2] not in ROUTES:
                 return self._refuse(404, "not a PreMan proxy address")
-            token, provider = parts[1], parts[2]
+            token, route = parts[1], parts[2]
+            provider = ROUTES[route][0]
             rest = "/" + parts[3] if len(parts) > 3 else ""
             kind = kind_of(provider, rest)
             turn, known = proxy._turn_for(token, kind)
             if not known:
                 return self._refuse(404, "not a PreMan proxy address")
+            plain = rest.split("?", 1)[0]
+            if turn is not None and not kind and self.command == "POST" and not plain.rstrip("/").endswith("count_tokens"):
+                turn.saw_other(plain)
             try:
                 body = self._body()
             except ValueError:
                 return self._refuse(400, "malformed request body")
             conv = None
+            started = time.monotonic()
+            facts = ("", False)
             if turn is not None and kind:
+                facts = _request_facts(body)
+                turn.request_started()
                 try:
                     conv = turn.saw_request(kind, body)
                 except Exception:
@@ -706,7 +892,7 @@ def _handler(proxy):
 
             headers = {k: v for k, v in self.headers.items() if k.lower() not in _HOP}
             request = urllib.request.Request(
-                proxy.upstream[provider] + rest,
+                proxy.upstream[route] + rest,
                 data=body if body or self.command in ("POST", "PUT", "PATCH") else None,
                 headers=headers,
                 method=self.command,
@@ -717,6 +903,8 @@ def _handler(proxy):
                 reply = exc  # a 4xx/5xx reply still goes back to the agent unchanged
             except OSError:
                 self.close_connection = True  # unreachable: the agent sees a dropped connection
+                if turn is not None and kind:
+                    turn.request_ended()
                 return
 
             bodyless = reply.status < 200 or reply.status in (204, 304)
@@ -766,6 +954,10 @@ def _handler(proxy):
                         bytes(copy),
                         len(copy) > MAX_BODY,
                         conv,
+                        ms=(time.monotonic() - started) * 1000,
+                        cut=cut,
+                        request_model=facts[0],
+                        asked_usage=facts[1],
                     )
                 except Exception:
                     turn._fail("a model reply could not be read")
@@ -796,6 +988,15 @@ def shared() -> Proxy:
 
 
 def choose(proxied, reported=None):
+    """The turn's account (see _choose), always carrying the proxy's token records:
+    an agent's own report says nothing about tokens."""
+    chosen = _choose(proxied, reported)
+    if "model_calls" in chosen[1] or "model_calls" not in proxied[1]:
+        return chosen
+    return chosen[0], dict(chosen[1], model_calls=proxied[1]["model_calls"])
+
+
+def _choose(proxied, reported=None):
     """The proxy's account when it saw the turn; otherwise (it saw no traffic, its
     channel closed, or no tools were offered) the agent's own report if that one
     was recorded. One source per
@@ -814,7 +1015,7 @@ def choose(proxied, reported=None):
             return proxied[0], capture
     if proxied[1].get("state") == "recorded" or reported is None:
         return proxied
-    if reported[1].get("state") == "recorded" and proxied[1].get("reason") in _UNSEEN:
+    if reported[1].get("state") == "recorded" and _unseen(proxied[1].get("reason")):
         capture = dict(reported[1])
         capture["proxy_version"] = proxied[1].get("proxy_version", version())
         return reported[0], capture

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "premanmcp",
-  "version": "1.1.15",
+  "version": "1.1.16",
   "description": "PreMan CLI and stdio proxy for PreMan's hosted MCP server",
   "type": "module",
   "bin": {