stageflow 0.15.0 → 0.16.0

package/dist/runstore/stageExecution.d.ts

@@ -1,10 +1,13 @@
 import type { StageEnvelope } from "../types/envelope.js";
+import type { StageUsage } from "../types/usage.js";
 import type { StageLogEvent, StageSnapshot } from "./port.js";
 export type StageExecutionPatch = {
     status?: StageSnapshot["status"];
     started_at?: string;
     finished_at?: string;
     envelope?: StageEnvelope | null;
+    cost_usd?: number;
+    usage?: StageUsage;
 };
 export declare function executionStatusFromEvents(events: StageLogEvent[]): StageSnapshot["status"];
 export declare function deriveExecutionPatchFromEvent(event: StageLogEvent, current: Pick<StageSnapshot, "status"> & {

package/dist/runstore/stageExecution.js

@@ -14,9 +14,13 @@ export function deriveExecutionPatchFromEvent(event, current) {
     else if (eventName === "waiting_for_input") {
         patch.status = "waiting_for_input";
     }
-    else if (eventName === "succeeded" || eventName === "failed") {
-        patch.status = eventName;
+    else if (event.event === "succeeded" || event.event === "failed") {
+        patch.status = event.event;
         patch.finished_at = at;
+        if (event.usage) {
+            patch.cost_usd = event.usage.costUsd;
+            patch.usage = event.usage;
+        }
     }
     return patch;
 }

package/dist/runstore/stageSnapshot.js

@@ -18,11 +18,14 @@ export async function buildStageSnapshotFromStore(store, runId, stageId, workspa
     let status;
     let envelope;
     let attempt_count;
+    let cost_usd;
     if (latest !== null) {
         events = await store.listStageEvents(runId, stageId, latest.attempt);
         status = stageStatusFromEvents(events);
         envelope = await tryReadEnvelope(store, runId, stageId, latest);
         attempt_count = await store.countStageAttempts(runId, stageId);
+        const executions = await store.listStageExecutions(runId, stageId);
+        cost_usd = sumStageExecutionCost(executions);
     }
     else {
         events = await store.listStageEvents(runId, stageId);
@@ -42,5 +45,13 @@ export async function buildStageSnapshotFromStore(store, runId, stageId, workspa
         last_at,
         attempt_count,
         ...(pending ? { pending_prompt: pending } : {}),
+        ...(cost_usd !== undefined ? { cost_usd } : {}),
     };
 }
+/** Sum cost across every attempt — retries are real spend too, so a stage's total isn't just its latest attempt. */
+function sumStageExecutionCost(executions) {
+    const costs = executions.map((e) => e.cost_usd).filter((c) => c !== undefined);
+    if (costs.length === 0)
+        return undefined;
+    return costs.reduce((sum, c) => sum + c, 0);
+}

package/dist/runtime/stageRunner.js

@@ -54,7 +54,7 @@ async function finalizeStageResult(options) {
             store,
             runId,
             stageId,
-            event: { event: "failed", reason: result.reason },
+            event: { event: "failed", reason: result.reason, usage: result.usage },
             attemptCtx,
         });
         console.error(`Stage ${stageId} failed: ${result.reason}`);
@@ -64,7 +64,7 @@ async function finalizeStageResult(options) {
         store,
         runId,
         stageId,
-        event: { event: "succeeded" },
+        event: { event: "succeeded", usage: result.usage },
         attemptCtx,
     });
     console.error(`Stage ${stageId} succeeded.`);

package/dist/types/usage.d.ts

@@ -0,0 +1,16 @@
+/** Per-model token/cost breakdown, as computed by the backend SDK itself. */
+export type ModelUsageBreakdown = {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadInputTokens: number;
+    cacheCreationInputTokens: number;
+    costUsd: number;
+};
+/** Accumulated LLM usage/cost for one stage attempt, across every turn/call it made. */
+export type StageUsage = {
+    costUsd: number;
+    models: Record<string, ModelUsageBreakdown>;
+};
+/** Merge one model's usage from a single call into an accumulator, in place. */
+export declare function addModelUsage(usage: StageUsage, model: string, delta: Partial<ModelUsageBreakdown>): void;
+export declare function emptyStageUsage(): StageUsage;

package/dist/types/usage.js

@@ -0,0 +1,24 @@
+function emptyBreakdown() {
+    return {
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadInputTokens: 0,
+        cacheCreationInputTokens: 0,
+        costUsd: 0,
+    };
+}
+/** Merge one model's usage from a single call into an accumulator, in place. */
+export function addModelUsage(usage, model, delta) {
+    const current = usage.models[model] ?? emptyBreakdown();
+    usage.models[model] = {
+        inputTokens: current.inputTokens + (delta.inputTokens ?? 0),
+        outputTokens: current.outputTokens + (delta.outputTokens ?? 0),
+        cacheReadInputTokens: current.cacheReadInputTokens + (delta.cacheReadInputTokens ?? 0),
+        cacheCreationInputTokens: current.cacheCreationInputTokens + (delta.cacheCreationInputTokens ?? 0),
+        costUsd: current.costUsd + (delta.costUsd ?? 0),
+    };
+    usage.costUsd += delta.costUsd ?? 0;
+}
+export function emptyStageUsage() {
+    return { costUsd: 0, models: {} };
+}