@sebastiantuyu/agest 0.3.3-next.6 → 0.3.3-next.7

package/dist/adapters/tracing.js

@@ -48,6 +48,7 @@ export async function createTracingHandle(baselineMs) {
             const endMs = now() - baselineMs;
             const tokens = extractTokensFromLLMOutput(output);
             const providerCost = extractProviderCost(output);
+            const cachedInputTokens = extractCachedTokens(output);
             const name = open.name ?? extractModelNameFromOutput(output) ?? "model";
             if (name && name !== "model")
                 lastModelName = name;
@@ -64,6 +65,7 @@ export async function createTracingHandle(baselineMs) {
                 endMs,
                 durationMs: Math.max(0, endMs - open.startMs),
                 tokens,
+                cachedInputTokens,
                 cost: stripCostIfEmpty(cost),
             });
         }
@@ -82,10 +84,10 @@ export async function createTracingHandle(baselineMs) {
                 error: err?.message ?? String(err),
             });
         }
-        handleToolStart(tool, _input, runId) {
+        handleToolStart(tool, _input, runId, _parentRunId, _tags, _metadata, runName) {
             openTools.set(runId, {
                 startMs: now() - baselineMs,
-                name: extractToolName(tool) ?? "tool",
+                name: extractToolName(tool, runName) ?? "tool",
             });
         }
         handleToolEnd(_output, runId) {
@@ -252,30 +254,82 @@ function extractTokensFromLLMOutput(output) {
         return undefined;
     return { input, output: out };
 }
+/** Collect the usage-bearing objects LangChain/OpenRouter may attach to an LLM result. */
+function usageObjects(output) {
+    const msg = output?.generations?.[0]?.[0]?.message;
+    return [
+        output?.llmOutput?.usage,
+        output?.llmOutput?.tokenUsage,
+        output?.llmOutput?.estimatedTokenUsage,
+        output?.llmOutput,
+        msg?.usage_metadata,
+        msg?.response_metadata?.usage,
+        msg?.response_metadata?.tokenUsage,
+        msg?.response_metadata?.estimatedTokenUsage,
+        msg?.response_metadata,
+        msg?.additional_kwargs?.usage,
+    ].filter((u) => u && typeof u === "object");
+}
+/**
+ * OpenRouter (with `usage: { include: true }`) reports real USD cost. LangChain
+ * surfaces it inconsistently across versions, so scan the known usage objects
+ * for a numeric `cost` / `total_cost`.
+ */
 function extractProviderCost(output) {
-    const candidates = [
-        output?.llmOutput?.usage?.cost,
-        output?.llmOutput?.cost,
-        output?.generations?.[0]?.[0]?.message?.usage_metadata?.total_cost,
-        output?.generations?.[0]?.[0]?.message?.response_metadata?.usage?.cost,
-        output?.generations?.[0]?.[0]?.message?.response_metadata?.cost,
-    ];
-    for (const c of candidates) {
+    for (const u of usageObjects(output)) {
+        const c = (typeof u.cost === "number" ? u.cost : undefined) ??
+            (typeof u.total_cost === "number" ? u.total_cost : undefined) ??
+            (typeof u.cost_usd === "number" ? u.cost_usd : undefined) ??
+            (typeof u.cost_details?.upstream_inference_cost === "number"
+                ? u.cost_details.upstream_inference_cost
+                : undefined);
         if (typeof c === "number" && Number.isFinite(c))
             return c;
     }
     return undefined;
 }
-function extractToolName(tool) {
-    if (!tool)
-        return undefined;
-    if (typeof tool.name === "string")
-        return tool.name;
-    if (Array.isArray(tool.id) && tool.id.length > 0) {
-        return String(tool.id[tool.id.length - 1]);
+/**
+ * Cached (prompt-cache hit) input tokens, when the provider reports them.
+ * Charged at a fraction of the normal input rate, so surfacing them lets the
+ * report explain why provider cost is below the flat-table estimate.
+ */
+function extractCachedTokens(output) {
+    for (const u of usageObjects(output)) {
+        const cached = u.input_token_details?.cache_read ??
+            u.prompt_tokens_details?.cached_tokens ??
+            u.cache_read_input_tokens ??
+            u.cached_tokens;
+        if (typeof cached === "number" && cached > 0)
+            return cached;
     }
     return undefined;
 }
+const TOOL_CLASS_NAMES = new Set([
+    "DynamicStructuredTool",
+    "DynamicTool",
+    "StructuredTool",
+    "Tool",
+]);
+function extractToolName(tool, runName) {
+    // `runName` is the actual tool name LangChain assigns the run (e.g.
+    // "search_recipes"); prefer it over the serialized class name.
+    if (runName && !TOOL_CLASS_NAMES.has(runName))
+        return runName;
+    if (tool) {
+        if (typeof tool.name === "string" && !TOOL_CLASS_NAMES.has(tool.name))
+            return tool.name;
+        if (typeof tool.kwargs?.name === "string")
+            return tool.kwargs.name;
+        if (Array.isArray(tool.id) && tool.id.length > 0) {
+            const last = String(tool.id[tool.id.length - 1]);
+            if (!TOOL_CLASS_NAMES.has(last))
+                return last;
+        }
+        if (typeof tool.name === "string")
+            return tool.name;
+    }
+    return runName;
+}
 function stripCostIfEmpty(cost) {
     if (cost.source === "unavailable" && cost.totalUsd == null)
         return undefined;

package/dist/preview.js

@@ -222,6 +222,7 @@ function renderWaterfallHtml(report) {
                 `${e.kind}: ${e.name}`,
                 `start ${Math.round(e.startMs)}ms · ${Math.round(e.durationMs)}ms`,
                 e.tokens ? `${e.tokens.input}→${e.tokens.output} tok` : "",
+                e.cachedInputTokens ? `${e.cachedInputTokens} cached` : "",
                 e.costUsd != null ? fmtUsdHtml(e.costUsd) : "",
                 e.error ? `error: ${e.error}` : "",
             ]

package/dist/reporter.js

@@ -126,6 +126,9 @@ function renderTimelineEvent(e) {
     if (e.tokens) {
         out.push(`                tokens: { input: ${e.tokens.input}, output: ${e.tokens.output} }`);
     }
+    if (e.cachedInputTokens != null && e.cachedInputTokens > 0) {
+        out.push(`                cached_input_tokens: ${e.cachedInputTokens}`);
+    }
     if (e.cost?.totalUsd != null) {
         out.push(`                cost_usd: ${formatUsd(e.cost.totalUsd)}`);
         out.push(`                cost_source: ${e.cost.source}`);

package/dist/reports.d.ts

@@ -18,6 +18,7 @@ export interface ParsedTimelineEvent {
         input: number;
         output: number;
     };
+    cachedInputTokens?: number;
     costUsd?: number;
     costSource?: string;
     runIndex?: number;

package/dist/reports.js

@@ -205,6 +205,9 @@ export function parseScenes(content) {
                 case "tokens":
                     event.tokens = parseTokens(value);
                     break;
+                case "cached_input_tokens":
+                    event.cachedInputTokens = parseInt(value, 10);
+                    break;
                 case "cost_usd":
                     event.costUsd = parseFloat(value);
                     break;

package/dist/types.d.ts

@@ -21,6 +21,8 @@ export interface TimelineEvent {
         input: number;
         output: number;
     };
+    /** Prompt-cache-hit input tokens (subset of tokens.input), when reported by the provider */
+    cachedInputTokens?: number;
     cost?: CostBreakdown;
     /** Index of the run this event belongs to (only set when aggregating across multi-run scenes) */
     runIndex?: number;

package/dist/waterfall.js

@@ -39,7 +39,8 @@ export function renderTerminalWaterfall(events, opts = {}) {
         const nameLabel = truncate(e.name, nameWidth).padEnd(nameWidth);
         const dur = `${Math.round(e.durationMs)}ms`.padStart(7);
         const cost = e.cost?.totalUsd != null ? `  ${fmtUsd(e.cost.totalUsd)}` : "";
+        const cached = e.cachedInputTokens ? `  ${c.dim(`(${e.cachedInputTokens} cached)`)}` : "";
         const err = e.error ? `  ${c.red("✗ " + truncate(e.error, 40))}` : "";
-        return `${indent}${c.dim(kindLabel)} ${nameLabel} ${bar} ${c.dim(dur)}${c.dim(cost)}${err}`;
+        return `${indent}${c.dim(kindLabel)} ${nameLabel} ${bar} ${c.dim(dur)}${c.dim(cost)}${cached}${err}`;
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sebastiantuyu/agest",
-  "version": "0.3.3-next.6",
+  "version": "0.3.3-next.7",
   "description": "A testing library for agents",
   "repository": {
     "type": "git",