pi-agent-flow 1.0.0 → 1.0.2

package/config.ts

@@ -0,0 +1,67 @@
+/**
+ * Load flow tier model configuration from Pi settings files.
+ *
+ * Reads global (~/.pi/agent/settings.json) and project (.pi/settings.json)
+ * settings, with project overriding global for flowModels.
+ */
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+export interface FlowModelConfig {
+	lite?: string;
+	flash?: string;
+	full?: string;
+}
+
+function readSettingsJson(filePath: string): Record<string, unknown> | null {
+	try {
+		const content = fs.readFileSync(filePath, "utf-8");
+		return JSON.parse(content) as Record<string, unknown>;
+	} catch {
+		return null;
+	}
+}
+
+function extractFlowModels(settings: Record<string, unknown> | null): FlowModelConfig {
+	if (!settings) return {};
+	const flowModels = settings.flowModels;
+	if (!flowModels || typeof flowModels !== "object" || Array.isArray(flowModels)) {
+		return {};
+	}
+	const obj = flowModels as Record<string, unknown>;
+	const result: FlowModelConfig = {};
+	for (const key of ["lite", "flash", "full"] as const) {
+		if (typeof obj[key] === "string") {
+			result[key] = obj[key] as string;
+		}
+	}
+	return result;
+}
+
+function getGlobalSettingsPath(): string {
+	const agentDir = process.env["PI_CODING_AGENT_DIR"]?.trim() || path.join(os.homedir(), ".pi", "agent");
+	return path.join(agentDir, "settings.json");
+}
+
+function getProjectSettingsPath(cwd: string): string {
+	return path.join(cwd, ".pi", "settings.json");
+}
+
+/**
+ * Load flowModels from global and project settings.json.
+ * Project overrides global (shallow merge per key).
+ */
+export function loadFlowModels(cwd: string): FlowModelConfig {
+	const globalSettings = readSettingsJson(getGlobalSettingsPath());
+	const globalModels = extractFlowModels(globalSettings);
+
+	const projectSettings = readSettingsJson(getProjectSettingsPath(cwd));
+	const projectModels = extractFlowModels(projectSettings);
+
+	return {
+		...globalModels,
+		...projectModels,
+	};
+}

package/flow.ts

@@ -12,7 +12,7 @@ import * as path from "node:path";
 import type { AgentToolResult } from "@mariozechner/pi-agent-core";
 import { type FlowConfig, getFlowTier } from "./agents.js";
 import { parseFlowCliArgs } from "./runner-cli.js";
-import { processFlowJsonLine, drainStreamingText, drainStreamingEstimate, drainCtxEstimate } from "./runner-events.js";
+import { processFlowJsonLine, drainStreamingText, drainStreamingEstimate, drainCtxEstimate, updateSmoothedTps, drainSmoothedTps } from "./runner-events.js";
 import {
 	type SingleResult,
 	type FlowDetails,
@@ -42,12 +42,14 @@ function mergeStreamingUsage(
 	actual: SingleResult["usage"],
 	estimatedOutputTokens: number,
 	ctxEstimate: number,
+	smoothedTps: number,
 ): SingleResult["usage"] {
-	if (estimatedOutputTokens <= 0 && ctxEstimate <= 0) return actual;
+	if (estimatedOutputTokens <= 0 && ctxEstimate <= 0 && smoothedTps <= 0) return actual;
 	return {
 		...actual,
 		...(estimatedOutputTokens > 0 ? { output: Math.max(actual.output, estimatedOutputTokens) } : {}),
 		...(ctxEstimate > 0 ? { contextTokens: Math.max(actual.contextTokens, ctxEstimate) } : {}),
+		...(smoothedTps > 0 ? { smoothedTps } : {}),
 	};
 }
 
@@ -238,7 +240,9 @@ export async function runFlow(opts: RunFlowOptions): Promise<SingleResult> {
 		const streaming = drainStreamingText(result);
 		const estimatedTokens = drainStreamingEstimate(result);
 		const ctxEst = drainCtxEstimate(result);
-		const mergedUsage = mergeStreamingUsage(result.usage, estimatedTokens, ctxEst);
+		updateSmoothedTps(result, estimatedTokens);
+		const smoothedTps = drainSmoothedTps(result);
+		const mergedUsage = mergeStreamingUsage(result.usage, estimatedTokens, ctxEst, smoothedTps);
 		onUpdate?.({
 			content: [
 				{

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "pi-agent-flow",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Flow-state delegation extension for Pi coding agent.",
   "type": "module",
   "main": "index.ts",
   "files": [
     "index.ts",
     "agents.ts",
+    "config.ts",
     "flow.ts",
     "hooks.ts",
     "runner-cli.js",

package/render-utils.ts

@@ -37,11 +37,17 @@ export function formatFlowTypeName(type: string): string {
 	return lower.padEnd(targetWidth, " ");
 }
 
+/** Format tokens-per-second to a 5-char display (e.g., " 42.3", "    -"). */
+function formatTps(value: number | undefined): string {
+	if (!value || value <= 0) return "    -";
+	return value.toFixed(1).padStart(5);
+}
+
 export function formatCompactStats(usage: Partial<UsageStats>, model?: string, maxWidth?: number): string {
 	const parts: string[] = [];
 	parts.push(`↑ ${formatFixedTokens(usage.input || 0)}`);
 	parts.push(`↓ ${formatFixedTokens(usage.output || 0)}`);
-	parts.push(`act: ${formatFixedTokens(usage.toolCalls || 0)}`);
+	parts.push(`tps: ${formatTps(usage.smoothedTps)}`);
 	parts.push(`ctx: ${formatFixedTokens(usage.contextTokens || 0)}`);
 
 	let result = parts.join(" · ") + (model ? ` · ${model}` : "");
@@ -52,7 +58,7 @@ export function formatCompactStats(usage: Partial<UsageStats>, model?: string, m
 		if (visibleLength(narrow) <= maxWidth) return narrow;
 
 		// Drop context tokens
-		const narrowParts = parts.slice(0, 3); // up to act
+		const narrowParts = parts.slice(0, 3); // up to tps
 		narrow = narrowParts.join(" · ");
 		if (visibleLength(narrow) <= maxWidth) return narrow;
 

package/render.ts

@@ -249,12 +249,13 @@ function renderFlowCollapsed(
 		container.addChild(new TruncatedText(`${theme.fg("dim", "├─ dir:")} ${theme.fg("dim", dirContent)}`, 0, 0));
 	}
 
-	// act: line (last tool call)
+	// act: line (last tool call with count)
 	const lastTool = getLastToolCall(r.messages);
 	if (lastTool) {
 		const actStr = formatFlowToolCall(lastTool.name, lastTool.args, theme.fg.bind(theme));
+		const actPrefix = `act: [${r.usage.toolCalls}] - `;
 		const actContent = truncateChars(actStr, contentBudget(10));
-		container.addChild(new TruncatedText(`${theme.fg("dim", "├─ act:")} ${actContent}`, 0, 0));
+		container.addChild(new TruncatedText(`${theme.fg("dim", "├─ " + actPrefix)}${actContent}`, 0, 0));
 	}
 
 	// log: line (last assistant text or streaming)
@@ -380,12 +381,13 @@ function renderActivityPanel(
 			container.addChild(new TruncatedText(`${theme.fg("dim", indent + "├─ dir:")} ${theme.fg("dim", dirContent)}`, 0, 0));
 		}
 
-		// act: line (last tool call)
+		// act: line (last tool call with count)
 		const lastTool = getLastToolCall(r.messages);
 		if (lastTool) {
 			const actStr = formatFlowToolCall(lastTool.name, lastTool.args, theme.fg.bind(theme));
+			const actPrefix = `act: [${r.usage.toolCalls}] - `;
 			const actContent = truncateChars(actStr, contentBudget(10));
-			container.addChild(new TruncatedText(`${theme.fg("dim", indent + "├─ act:")} ${actContent}`, 0, 0));
+			container.addChild(new TruncatedText(`${theme.fg("dim", indent + "├─ " + actPrefix)}${actContent}`, 0, 0));
 		}
 
 		// log: line (last assistant text)

package/runner-events.js

@@ -51,6 +51,9 @@ export function drainStreamingText(result) {
 /** Chars per token heuristic for output estimation. */
 const CHARS_PER_TOKEN = 4;
 
+/** EMA smoothing factor for tokens-per-second (higher = more responsive). */
+const EMA_ALPHA = 0.3;
+
 function getStreamingEstimate(result) {
   if (!Object.prototype.hasOwnProperty.call(result, "__streamingEstimate")) {
     Object.defineProperty(result, "__streamingEstimate", {
@@ -63,6 +66,62 @@ function getStreamingEstimate(result) {
   return result.__streamingEstimate;
 }
 
+/**
+ * Lazily initialize TPS tracking properties on the result object.
+ * - __lastEmitTime: timestamp (ms) of the last streaming emit
+ * - __smoothedTps: EMA-smoothed tokens-per-second value
+ */
+function getTpsTracker(result) {
+  if (!Object.prototype.hasOwnProperty.call(result, "__smoothedTps")) {
+    Object.defineProperty(result, "__smoothedTps", {
+      value: 0,
+      enumerable: false,
+      configurable: false,
+      writable: true,
+    });
+    Object.defineProperty(result, "__lastEmitTime", {
+      value: 0,
+      enumerable: false,
+      configurable: false,
+      writable: true,
+    });
+  }
+  return result;
+}
+
+/**
+ * Update the EMA-smoothed tokens-per-second based on a new sample.
+ * Called from emitUpdate() with the estimated output tokens since last emit.
+ * Skips the update when delta time or tokens are zero (e.g., first emit).
+ */
+export function updateSmoothedTps(result, estimatedTokens) {
+  if (estimatedTokens <= 0) return;
+  const tracker = getTpsTracker(result);
+  const now = Date.now();
+  if (tracker.__lastEmitTime === 0) {
+    // First emit — seed the value directly
+    tracker.__lastEmitTime = now;
+    return;
+  }
+  const deltaSec = (now - tracker.__lastEmitTime) / 1000;
+  if (deltaSec <= 0) return;
+  const instantRate = estimatedTokens / deltaSec;
+  if (tracker.__smoothedTps === 0) {
+    tracker.__smoothedTps = instantRate;
+  } else {
+    tracker.__smoothedTps = EMA_ALPHA * instantRate + (1 - EMA_ALPHA) * tracker.__smoothedTps;
+  }
+  tracker.__lastEmitTime = now;
+}
+
+/**
+ * Return the current EMA-smoothed tokens-per-second value.
+ */
+export function drainSmoothedTps(result) {
+  const tracker = getTpsTracker(result);
+  return tracker.__smoothedTps;
+}
+
 /**
  * Lazily initialize ctx baseline tracking properties on the result object.
  * - __ctxBaseline: last known real totalTokens from message_end
@@ -279,22 +338,68 @@ export function getFlowFinalText(messages) {
   return "";
 }
 
+function extractNonReadToolCalls(messages) {
+  const calls = [];
+  if (!Array.isArray(messages)) return calls;
+  for (const msg of messages) {
+    if (msg.role !== "assistant" || !Array.isArray(msg.content)) continue;
+    for (const part of msg.content) {
+      if (part.type === "toolCall" && part.name !== "read") {
+        calls.push({ name: part.name, args: part.arguments || part.input || {} });
+      }
+    }
+  }
+  return calls;
+}
+
+function formatToolCallShort(tc) {
+  const args = tc.args || {};
+  switch (tc.name) {
+    case "edit":
+    case "write":
+      return `${tc.name} ${(args.file_path || args.path || "?").split("/").pop()}`;
+    case "bash": {
+      const cmd = (args.command || "").replace(/[\n\r\t]+/g, " ").replace(/ +/g, " ").trim();
+      return `bash ${cmd.length > 40 ? cmd.slice(0, 40) + "..." : cmd}`;
+    }
+    case "grep":
+      return `grep /${args.pattern || "?"}/ in ${args.path || "."}`;
+    case "find":
+      return `find ${args.pattern || "*"} in ${args.path || "."}`;
+    case "ls":
+      return `ls ${args.path || "."}`;
+    default:
+      return tc.name;
+  }
+}
+
 export function getFlowSummaryText(result) {
   const finalText = getFlowFinalText(result?.messages);
   if (finalText) return finalText;
 
-  if (typeof result?.errorMessage === "string" && result.errorMessage.trim()) {
-    return result.errorMessage.trim();
-  }
-
   const isError =
     (typeof result?.exitCode === "number" && result.exitCode > 0) ||
     result?.stopReason === "error" ||
     result?.stopReason === "aborted";
 
-  if (isError && typeof result?.stderr === "string" && result.stderr.trim()) {
-    return result.stderr.trim();
+  // Build base message for failed/aborted flows
+  let base = "";
+  if (typeof result?.errorMessage === "string" && result.errorMessage.trim()) {
+    base = result.errorMessage.trim();
+  } else if (isError && typeof result?.stderr === "string" && result.stderr.trim()) {
+    base = result.stderr.trim();
+  } else if (isError) {
+    base = "Flow failed";
+  } else {
+    return "(no output)";
+  }
+
+  // Surface partial tool calls (excluding read) for failed/aborted flows
+  const toolCalls = extractNonReadToolCalls(result?.messages);
+  if (toolCalls.length > 0) {
+    const formatted = toolCalls.map(formatToolCallShort).join(", ");
+    return `${base}\nPartial work: ${formatted}`;
   }
 
-  return "(no output)";
+  return base;
 }

package/types.ts

@@ -15,6 +15,7 @@ export interface UsageStats {
 	contextTokens: number;
 	turns: number;
 	toolCalls: number;
+	smoothedTps?: number;
 }
 
 /** Result of a single flow invocation. */
@@ -47,7 +48,7 @@ export type DisplayItem =
 
 /** Create an empty UsageStats object. */
 export function emptyFlowUsage(): UsageStats {
-	return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0, toolCalls: 0 };
+	return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0, toolCalls: 0, smoothedTps: 0 };
 }
 
 /** Sum usage across multiple results. */
@@ -61,6 +62,9 @@ export function aggregateFlowUsage(results: SingleResult[]): UsageStats {
 		total.cost += r.usage.cost;
 		total.turns += r.usage.turns;
 		total.toolCalls += r.usage.toolCalls;
+		if ((r.usage.smoothedTps ?? 0) > (total.smoothedTps ?? 0)) {
+			total.smoothedTps = r.usage.smoothedTps;
+		}
 	}
 	return total;
 }