@danypops/jittor 0.9.0 → 0.10.0

package/README.md

@@ -72,7 +72,7 @@ The graph fetches metrics per distinct provider/model scope (`jittor metrics dis
 
 ### Cost per Papyrus task
 
-Jittor observes Papyrus's task-focus lifecycle in real time over a shared Pi extension event bus (`papyrus.task-focus.v1`) -- Papyrus never depends on Jittor, it only broadcasts which task is currently focused. Every token/cost metric Jittor already records on a finalized Pi assistant message is tagged with the currently focused task's id the moment it is recorded (no time-window estimation, no new instrumentation). A paused or cleared focus stops tagging; spend recorded with nothing focused is reported separately as unattributed, never dropped or folded into an invented task. Run `jittor metrics cost-by-task --since <ms> --until <ms> [--json]` for a bounded per-task breakdown of cost and input/output/cache tokens.
+Jittor observes Papyrus's task-focus lifecycle in real time over a shared Pi extension event bus (`papyrus.task-focus.v1`) -- Papyrus never depends on Jittor, it only broadcasts which task is currently focused. Every token/cost metric Jittor already records on a finalized Pi assistant message is tagged with the currently focused task's id, and the provider/model/thinking level active at that moment, the instant it is recorded (no time-window estimation, no new instrumentation). A paused or cleared focus stops tagging; spend recorded with nothing focused is reported separately as unattributed, never dropped or folded into an invented task. Run `jittor metrics cost-by-task --since <ms> --until <ms> [--json]` for a bounded per-task breakdown of cost and input/output/cache tokens, broken down further by which provider/model/thinking combination each task actually spent on.
 
 Series are colored with a categorical palette chosen to avoid this UI's own status colors ("success"/"warning"/"error" already mean something specific elsewhere in this panel, so reusing them for arbitrary model identity would make a model's bar segment look like a warning or a failure) and instead reuses the theme's syntax-highlighting roles, which are already tuned by theme authors to stay mutually distinguishable on screen — the same design problem as a categorical data palette. Once more series are active than there are hues, a series reuses a hue in bold rather than repeating an indistinguishable color. Multiple models active within the same cumulative time frame are rendered as one bar stacked by color, not separate bars.
 

package/extension/src/index.ts

@@ -230,8 +230,12 @@ async function applyDecision(
 	return halt(ctx, `Jittor could not apply any authenticated Pi route after ${decision.route.provider}/${decision.route.model} became unavailable`);
 }
 
-/** taskId, when a Papyrus task is currently focused in this session, tags the metric for real-time cost-per-task correlation without any new instrumentation surface. */
-function assistantUsageMetrics(message: unknown, observedAt: number, taskId: string | null = null): MetricObservation[] {
+/**
+ * taskId, when a Papyrus task is focused, tags the metric for cost-per-task correlation. thinking
+ * comes from pi.getThinkingLevel() at message_end time, not from the message itself -- AssistantMessage
+ * has no thinking field of its own, and the level can't have changed mid-message.
+ */
+function assistantUsageMetrics(message: unknown, observedAt: number, taskId: string | null = null, thinking: string | null = null): MetricObservation[] {
 	if (typeof message !== "object" || message === null || Array.isArray(message)) return [];
 	const value = message as Record<string, unknown>;
 	if (value["role"] !== "assistant" || typeof value["usage"] !== "object" || value["usage"] === null) return [];
@@ -239,7 +243,7 @@ function assistantUsageMetrics(message: unknown, observedAt: number, taskId: str
 	const provider = typeof value["provider"] === "string" ? value["provider"] : "unknown";
 	const model = typeof value["model"] === "string" ? value["model"] : "unknown";
 	const scope = `${provider}:${model}`;
-	const attributes = { provider, model, ...(taskId === null ? {} : { taskId }) };
+	const attributes = { provider, model, ...(taskId === null ? {} : { taskId }), ...(thinking === null || thinking.length === 0 ? {} : { thinking }) };
 	const metrics: MetricObservation[] = [];
 	for (const [field, metric] of [["input", "input-tokens"], ["output", "output-tokens"], ["cacheRead", "cache-read-tokens"], ["cacheWrite", "cache-write-tokens"]] as const) {
 		const amount = usage[field];
@@ -796,7 +800,7 @@ export function registerJittorExtension(
 			}
 			lastAnthropicVertexResponse = {};
 		}
-		const metrics = assistantUsageMetrics(event.message, Date.now(), focusedTaskId);
+		const metrics = assistantUsageMetrics(event.message, Date.now(), focusedTaskId, pi.getThinkingLevel());
 		if (metrics.length > 0) {
 			const amount = (name: string): number => metrics.filter((metric) => metric.metric === name && typeof metric.value === "number").reduce((sum, metric) => sum + (metric.value ?? 0), 0);
 			compactionTelemetry.observeProviderUsage({ input: amount("input-tokens"), output: amount("output-tokens"), cacheRead: amount("cache-read-tokens"), cacheWrite: amount("cache-write-tokens") });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/jittor",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "Just-in-Time Token Optimizing Router for Pi",
   "type": "module",
   "keywords": ["pi-package", "llm-router", "token-budget"],

package/src/cli.ts

@@ -573,7 +573,10 @@ function formatUsdAmount(amount: number): string {
 export function formatCostByTask(summary: TaskCostSummary): string {
 	const lines = [
 		`Cost by task: ${summary.entries.length.toLocaleString()} task(s)${summary.truncated ? " (query limit reached; totals are a lower bound)" : ""}`,
-		...summary.entries.map((entry) => `- ${humanField(entry.taskId)}: ${formatUsdAmount(entry.costUsd)} · ↑${entry.inputTokens.toLocaleString()} ↓${entry.outputTokens.toLocaleString()} R${entry.cacheReadTokens.toLocaleString()} W${entry.cacheWriteTokens.toLocaleString()}`),
+		...summary.entries.flatMap((entry) => [
+			`- ${humanField(entry.taskId)}: ${formatUsdAmount(entry.costUsd)} · ↑${entry.inputTokens.toLocaleString()} ↓${entry.outputTokens.toLocaleString()} R${entry.cacheReadTokens.toLocaleString()} W${entry.cacheWriteTokens.toLocaleString()}`,
+			...entry.byModel.map((model) => `    · ${humanField(model.provider)}/${humanField(model.model)} (${humanField(model.thinking)}): ${formatUsdAmount(model.costUsd)} · ↑${model.inputTokens.toLocaleString()} ↓${model.outputTokens.toLocaleString()} R${model.cacheReadTokens.toLocaleString()} W${model.cacheWriteTokens.toLocaleString()}`),
+		]),
 		`Unattributed spend (no task was focused): ${formatUsdAmount(summary.unattributedCostUsd)}`,
 	];
 	return lines.join("\n");

package/src/domain/task-cost.ts

@@ -1,5 +1,16 @@
 import type { StoredMetricObservation } from "./metric.ts";
 
+export interface TaskCostBreakdown {
+	provider: string;
+	model: string;
+	thinking: string;
+	costUsd: number;
+	inputTokens: number;
+	outputTokens: number;
+	cacheReadTokens: number;
+	cacheWriteTokens: number;
+}
+
 export interface TaskCostEntry {
 	taskId: string;
 	costUsd: number;
@@ -7,6 +18,7 @@ export interface TaskCostEntry {
 	outputTokens: number;
 	cacheReadTokens: number;
 	cacheWriteTokens: number;
+	byModel: TaskCostBreakdown[];
 }
 
 export interface TaskCostSummary {
@@ -25,20 +37,35 @@ export interface TaskCostSummaryOptions {
 
 const TOKEN_METRICS = new Set(["input-tokens", "output-tokens", "cache-read-tokens", "cache-write-tokens"]);
 
+function attributeText(attributes: Record<string, unknown>, key: string): string {
+	return typeof attributes[key] === "string" && attributes[key].length > 0 ? attributes[key] : "unknown";
+}
+
 function entryFor(byTask: Map<string, TaskCostEntry>, taskId: string): TaskCostEntry {
 	const existing = byTask.get(taskId);
 	if (existing) return existing;
-	const created: TaskCostEntry = { taskId, costUsd: 0, inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 };
+	const created: TaskCostEntry = { taskId, costUsd: 0, inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, byModel: [] };
 	byTask.set(taskId, created);
 	return created;
 }
 
+function breakdownFor(byModel: Map<string, TaskCostBreakdown>, provider: string, model: string, thinking: string): TaskCostBreakdown {
+	const key = `${provider}\u0000${model}\u0000${thinking}`;
+	const existing = byModel.get(key);
+	if (existing) return existing;
+	const created: TaskCostBreakdown = { provider, model, thinking, costUsd: 0, inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 };
+	byModel.set(key, created);
+	return created;
+}
+
 /**
  * Groups already-recorded "pi" source cost/token metrics by the Papyrus task focused when each was
- * recorded (see the papyrus.task-focus.v1 real-time tagging in the extension), rather than by
- * provider/model identity. Rows recorded with nothing focused have no attributes.taskId and are
- * reported separately as unattributedCostUsd -- they are real spend, just not attributable to any
- * task, and must never be silently dropped or folded into an invented "unknown" task bucket.
+ * recorded (see the papyrus.task-focus.v1 real-time tagging in the extension), with a secondary
+ * breakdown per provider/model/thinking within each task. Rows recorded with nothing focused have
+ * no attributes.taskId and are reported separately as unattributedCostUsd -- they are real spend,
+ * just not attributable to any task, and must never be silently dropped or folded into an invented
+ * "unknown" task bucket. A row missing provider/model/thinking (recorded before that attribution
+ * existed) falls into an "unknown" breakdown bucket instead, since the task-level total is real.
  *
  * This queries a single bounded time window without per-task fairness partitioning (unlike
  * buildUsageGraph/buildCostGraph's per-scope fetch): a task's own working period is typically a far
@@ -48,6 +75,7 @@ function entryFor(byTask: Map<string, TaskCostEntry>, taskId: string): TaskCostE
  */
 export function buildTaskCostSummary(rows: StoredMetricObservation[], options: TaskCostSummaryOptions): TaskCostSummary {
 	const byTask = new Map<string, TaskCostEntry>();
+	const byTaskModel = new Map<string, Map<string, TaskCostBreakdown>>();
 	let unattributedCostUsd = 0;
 	for (const row of rows) {
 		if (row.source !== "pi" || typeof row.value !== "number" || !Number.isFinite(row.value) || row.value < 0) continue;
@@ -56,14 +84,21 @@ export function buildTaskCostSummary(rows: StoredMetricObservation[], options: T
 		if (row.metric === "cost" && row.unit === "usd") {
 			if (taskId === undefined) { unattributedCostUsd += row.value; continue; }
 			entryFor(byTask, taskId).costUsd += row.value;
+			if (!byTaskModel.has(taskId)) byTaskModel.set(taskId, new Map());
+			breakdownFor(byTaskModel.get(taskId)!, attributeText(row.attributes, "provider"), attributeText(row.attributes, "model"), attributeText(row.attributes, "thinking")).costUsd += row.value;
 			continue;
 		}
 		if (taskId === undefined || row.unit !== "tokens" || !TOKEN_METRICS.has(row.metric)) continue;
 		const entry = entryFor(byTask, taskId);
-		if (row.metric === "input-tokens") entry.inputTokens += row.value;
-		else if (row.metric === "output-tokens") entry.outputTokens += row.value;
-		else if (row.metric === "cache-read-tokens") entry.cacheReadTokens += row.value;
-		else entry.cacheWriteTokens += row.value;
+		if (!byTaskModel.has(taskId)) byTaskModel.set(taskId, new Map());
+		const breakdown = breakdownFor(byTaskModel.get(taskId)!, attributeText(row.attributes, "provider"), attributeText(row.attributes, "model"), attributeText(row.attributes, "thinking"));
+		if (row.metric === "input-tokens") { entry.inputTokens += row.value; breakdown.inputTokens += row.value; }
+		else if (row.metric === "output-tokens") { entry.outputTokens += row.value; breakdown.outputTokens += row.value; }
+		else if (row.metric === "cache-read-tokens") { entry.cacheReadTokens += row.value; breakdown.cacheReadTokens += row.value; }
+		else { entry.cacheWriteTokens += row.value; breakdown.cacheWriteTokens += row.value; }
+	}
+	for (const [taskId, entry] of byTask) {
+		entry.byModel = [...(byTaskModel.get(taskId)?.values() ?? [])].sort((left, right) => right.costUsd - left.costUsd || left.model.localeCompare(right.model));
 	}
 	const entries = [...byTask.values()].sort((left, right) => right.costUsd - left.costUsd || left.taskId.localeCompare(right.taskId));
 	return { since: options.since, until: options.until, entries, unattributedCostUsd, truncated: options.truncated === true };