@stigmer/react 3.1.16 → 3.2.0

package/src/workflow/__tests__/WorkflowUsageTab.test.tsx

@@ -0,0 +1,163 @@
+import { describe, it, expect, afterEach } from "vitest";
+import { render, screen, cleanup } from "@testing-library/react";
+import { WorkflowTaskKind } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/enum_pb";
+import type {
+  DerivedCostSummary,
+  DerivedTaskState,
+} from "../../internal/store/workflow-execution-event-store";
+import { WorkflowUsageTab } from "../facets/WorkflowUsageTab";
+
+function costSummary(overrides: Partial<DerivedCostSummary> = {}): DerivedCostSummary {
+  return {
+    costConsumedMicros: 0n,
+    costRemainingMicros: -1n,
+    tokensConsumed: 0n,
+    tokensRemaining: -1n,
+    thresholdBreached: false,
+    ...overrides,
+  };
+}
+
+function taskState(overrides: Partial<DerivedTaskState> & { taskName: string }): DerivedTaskState {
+  return {
+    taskKind: WorkflowTaskKind.llm_call,
+    status: "completed",
+    durationMs: 0,
+    costMicros: 0n,
+    tokensUsed: 0n,
+    attemptNumber: 1,
+    error: "",
+    childExecutionId: "",
+    agentSlug: "",
+    currentToolName: "",
+    messagesCount: 0,
+    toolCallsCount: 0,
+    inputSummary: null,
+    outputSummary: null,
+    approvalRequest: null,
+    approvalResolution: null,
+    ...overrides,
+  };
+}
+
+function statesOf(...states: DerivedTaskState[]): ReadonlyMap<string, DerivedTaskState> {
+  return new Map(states.map((s) => [s.taskName, s]));
+}
+
+afterEach(cleanup);
+
+describe("WorkflowUsageTab", () => {
+  it("shows the empty state before any usage accrues", () => {
+    render(
+      <WorkflowUsageTab costSummary={costSummary()} taskStates={new Map()} />,
+    );
+    expect(
+      screen.getByText(
+        "No usage data yet. Cost and token stats will appear here.",
+      ),
+    ).toBeTruthy();
+  });
+
+  it("renders the aggregate alone when no task qualifies for the breakdown (e.g. snapshot-fallback states)", () => {
+    render(
+      <WorkflowUsageTab
+        costSummary={costSummary({ costConsumedMicros: 190_000n, tokensConsumed: 12_400n })}
+        taskStates={statesOf(taskState({ taskName: "zeroed_by_fallback" }))}
+      />,
+    );
+    expect(screen.getByText("$0.19")).toBeTruthy();
+    expect(screen.getByText(/12\.4K tokens/)).toBeTruthy();
+    expect(screen.queryByText("By task")).toBeNull();
+    expect(screen.queryByRole("list")).toBeNull();
+  });
+
+  it("renders the budget limit when the stream reports remaining amounts", () => {
+    render(
+      <WorkflowUsageTab
+        costSummary={costSummary({
+          costConsumedMicros: 250_000n,
+          costRemainingMicros: 750_000n,
+          tokensConsumed: 1_000n,
+          tokensRemaining: 9_000n,
+        })}
+        taskStates={new Map()}
+      />,
+    );
+    expect(screen.getByText("of $1.00 budget")).toBeTruthy();
+    expect(screen.getByText(/1\.0K tokens of 10\.0K/)).toBeTruthy();
+  });
+
+  it("omits budget limits when remaining is unknown (-1 sentinel)", () => {
+    render(
+      <WorkflowUsageTab
+        costSummary={costSummary({ costConsumedMicros: 250_000n, tokensConsumed: 1_000n })}
+        taskStates={new Map()}
+      />,
+    );
+    expect(screen.queryByText(/budget/)).toBeNull();
+  });
+
+  it("announces a breached threshold in text, not color alone", () => {
+    render(
+      <WorkflowUsageTab
+        costSummary={costSummary({ costConsumedMicros: 900_000n, thresholdBreached: true })}
+        taskStates={new Map()}
+      />,
+    );
+    expect(screen.getByText("Budget threshold breached")).toBeTruthy();
+  });
+
+  it("renders the per-task breakdown most-expensive-first with kind labels", () => {
+    render(
+      <WorkflowUsageTab
+        costSummary={costSummary({ costConsumedMicros: 900_000n })}
+        taskStates={statesOf(
+          taskState({ taskName: "cheap_task", costMicros: 10_000n, tokensUsed: 100n }),
+          taskState({
+            taskName: "call_agent",
+            taskKind: WorkflowTaskKind.agent_call,
+            costMicros: 800_000n,
+            tokensUsed: 40_000n,
+          }),
+        )}
+      />,
+    );
+    expect(screen.getByText("By task")).toBeTruthy();
+    const items = screen.getAllByRole("listitem");
+    expect(items).toHaveLength(2);
+    expect(items[0].textContent).toContain("call_agent");
+    expect(items[0].textContent).toContain("Agent Call");
+    expect(items[0].textContent).toContain("$0.80");
+    expect(items[1].textContent).toContain("cheap_task");
+  });
+
+  it("marks in-flight tasks so live usage reads as live", () => {
+    render(
+      <WorkflowUsageTab
+        costSummary={costSummary({ tokensConsumed: 1_200n })}
+        taskStates={statesOf(
+          taskState({
+            taskName: "call_agent",
+            taskKind: WorkflowTaskKind.agent_call,
+            status: "running",
+            tokensUsed: 1_200n,
+          }),
+        )}
+      />,
+    );
+    expect(screen.getByRole("listitem").textContent).toContain("running");
+  });
+
+  it("renders rows as static (non-interactive) entries — the breakdown reports, never navigates (T06)", () => {
+    render(
+      <WorkflowUsageTab
+        costSummary={costSummary({ costConsumedMicros: 100_000n })}
+        taskStates={statesOf(
+          taskState({ taskName: "expensive_task", costMicros: 100_000n }),
+        )}
+      />,
+    );
+    expect(screen.getByRole("listitem").textContent).toContain("expensive_task");
+    expect(screen.queryByRole("button")).toBeNull();
+  });
+});

package/src/workflow/__tests__/agent-call-live-experience.test.ts

@@ -4,7 +4,6 @@
  * Covers:
  * - WorkflowExecutionEventStore: agentCallProgress handler
  * - ExecutionBadge: approval tool name + agent activity rendering
- * - AgentCallTab: live/static/pending view switching based on task state
  * - ExecutionInspector: Approval tab visibility
  */
 
@@ -369,58 +368,12 @@ describe("ExecutionBadge agent activity", () => {
   });
 });
 
-// ---------------------------------------------------------------------------
-// AgentCallTab view switching
-// ---------------------------------------------------------------------------
-
-describe("AgentCallTab view switching", () => {
-  it("shows live view when task is running and childExecutionId is available", () => {
-    const taskStatus = "running" as const;
-    const childExecutionId = "aex_abc123";
-    const isTabActive = true;
-
-    const shouldSubscribe = isTabActive && (taskStatus === "running" || taskStatus === "waiting_approval") && !!childExecutionId;
-    expect(shouldSubscribe).toBe(true);
-  });
-
-  it("shows pending view when task is running but no childExecutionId", () => {
-    const taskStatus = "running" as const;
-    const childExecutionId = "";
-    const isTabActive = true;
-
-    const isRunning = taskStatus === "running" || taskStatus === "waiting_approval";
-    const hasChildId = !!childExecutionId;
-    const shouldSubscribe = isTabActive && isRunning && hasChildId;
-
-    expect(shouldSubscribe).toBe(false);
-    expect(isRunning && !hasChildId).toBe(true);
-  });
-
-  it("shows static view when task is completed", () => {
-    const taskStatus: string = "completed";
-
-    const isRunning = taskStatus === "running" || taskStatus === "waiting_approval";
-    expect(isRunning).toBe(false);
-  });
-
-  it("does not subscribe when tab is not active", () => {
-    const taskStatus = "running" as const;
-    const childExecutionId = "aex_abc123";
-    const isTabActive = false;
-
-    const shouldSubscribe = isTabActive && (taskStatus === "running" || taskStatus === "waiting_approval") && !!childExecutionId;
-    expect(shouldSubscribe).toBe(false);
-  });
-
-  it("subscribes when task is waiting_approval with childExecutionId", () => {
-    const taskStatus: string = "waiting_approval";
-    const childExecutionId = "aex_abc123";
-    const isTabActive = true;
-
-    const shouldSubscribe = isTabActive && (taskStatus === "running" || taskStatus === "waiting_approval") && !!childExecutionId;
-    expect(shouldSubscribe).toBe(true);
-  });
-});
+// NOTE: the "AgentCallTab view switching" suite that lived here tested the
+// tab's embedded-thumbnail subscription gating. S4 replaced the thumbnail
+// with a launcher (no subscription in the inspector at all); the launcher's
+// behavior is covered by component tests in agent-call-tab.test.tsx, and the
+// transcript's fetch/stream lifecycle by useLiveAgentExecution.test.tsx +
+// WorkflowAgentExecutionDocument.test.tsx.
 
 // ---------------------------------------------------------------------------
 // Inspector Approval tab visibility

package/src/workflow/__tests__/derive-execution-overlays.test.ts

@@ -32,6 +32,10 @@ function makeDerivedState(
     currentToolName: "",
     messagesCount: 0,
     toolCallsCount: 0,
+    inputSummary: null,
+    outputSummary: null,
+    approvalRequest: null,
+    approvalResolution: null,
     ...overrides,
   };
 }

package/src/workflow/__tests__/deriveWorkflowArtifactItems.test.ts

@@ -0,0 +1,71 @@
+import { describe, it, expect } from "vitest";
+import { create } from "@bufbuild/protobuf";
+import { ArtifactSchema } from "@stigmer/protos/ai/stigmer/agentic/artifact/v1/api_pb";
+import { deriveWorkflowArtifactItems } from "../deriveWorkflowArtifactItems";
+
+function artifact(id: string, displayName: string, taskName = "") {
+  return create(ArtifactSchema, {
+    metadata: { id, name: displayName },
+    spec: {
+      displayName,
+      contentType: "application/json",
+      source: { workflowExecutionId: "wex_1", taskName },
+    },
+    status: { sizeBytes: 100n },
+  });
+}
+
+describe("deriveWorkflowArtifactItems", () => {
+  it("returns an empty list for no artifacts", () => {
+    expect(deriveWorkflowArtifactItems([])).toEqual([]);
+  });
+
+  it("sorts alphabetically by display name, case-insensitive", () => {
+    const entries = deriveWorkflowArtifactItems([
+      artifact("art_1", "zeta.json"),
+      artifact("art_2", "Alpha.json"),
+      artifact("art_3", "beta.json"),
+    ]);
+    expect(entries.map((e) => e.item.name)).toEqual([
+      "Alpha.json",
+      "beta.json",
+      "zeta.json",
+    ]);
+  });
+
+  it("does not deduplicate — every immutable Artifact record is a distinct row", () => {
+    const entries = deriveWorkflowArtifactItems([
+      artifact("art_1", "output.json", "task_a"),
+      artifact("art_2", "output.json", "task_b"),
+    ]);
+    expect(entries).toHaveLength(2);
+  });
+
+  it("flags name collisions with the producing task as subtitle", () => {
+    const entries = deriveWorkflowArtifactItems([
+      artifact("art_1", "output.json", "task_a"),
+      artifact("art_2", "output.json", "task_b"),
+      artifact("art_3", "unique.json", "task_c"),
+    ]);
+    const subtitles = new Map(
+      entries.map((e) => [e.artifact.metadata?.id, e.item.subtitlePath]),
+    );
+    expect(subtitles.get("art_1")).toBe("task_a");
+    expect(subtitles.get("art_2")).toBe("task_b");
+    expect(subtitles.get("art_3")).toBeNull();
+  });
+
+  it("treats display-name collisions case-insensitively", () => {
+    const entries = deriveWorkflowArtifactItems([
+      artifact("art_1", "Report.md", "task_a"),
+      artifact("art_2", "report.md", "task_b"),
+    ]);
+    expect(entries.every((e) => e.item.subtitlePath !== null)).toBe(true);
+  });
+
+  it("does not mutate the input array's order", () => {
+    const input = [artifact("art_1", "zeta.json"), artifact("art_2", "alpha.json")];
+    deriveWorkflowArtifactItems(input);
+    expect(input[0].metadata?.id).toBe("art_1");
+  });
+});

package/src/workflow/__tests__/deriveWorkflowUsageItems.test.ts

@@ -0,0 +1,132 @@
+import { describe, it, expect } from "vitest";
+import { WorkflowTaskKind } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/enum_pb";
+import type { DerivedTaskState } from "../../internal/store/workflow-execution-event-store";
+import { deriveWorkflowUsageItems } from "../deriveWorkflowUsageItems";
+
+function taskState(overrides: Partial<DerivedTaskState> & { taskName: string }): DerivedTaskState {
+  return {
+    taskKind: WorkflowTaskKind.llm_call,
+    status: "completed",
+    durationMs: 0,
+    costMicros: 0n,
+    tokensUsed: 0n,
+    attemptNumber: 1,
+    error: "",
+    childExecutionId: "",
+    agentSlug: "",
+    currentToolName: "",
+    messagesCount: 0,
+    toolCallsCount: 0,
+    inputSummary: null,
+    outputSummary: null,
+    approvalRequest: null,
+    approvalResolution: null,
+    ...overrides,
+  };
+}
+
+function statesOf(...states: DerivedTaskState[]): ReadonlyMap<string, DerivedTaskState> {
+  return new Map(states.map((s) => [s.taskName, s]));
+}
+
+describe("deriveWorkflowUsageItems", () => {
+  it("returns an empty list for no task states", () => {
+    expect(deriveWorkflowUsageItems(new Map())).toEqual([]);
+  });
+
+  it("drops zero-usage rows (zero cost AND zero tokens) — the snapshot fallback degrades to empty, not fake $0.00 rows", () => {
+    const items = deriveWorkflowUsageItems(
+      statesOf(
+        taskState({ taskName: "no_usage_a" }),
+        taskState({ taskName: "no_usage_b", status: "running" }),
+      ),
+    );
+    expect(items).toEqual([]);
+  });
+
+  it("keeps rows with tokens but no cost (live agent-call progress reports tokens before cost)", () => {
+    const items = deriveWorkflowUsageItems(
+      statesOf(
+        taskState({
+          taskName: "call_agent",
+          taskKind: WorkflowTaskKind.agent_call,
+          status: "running",
+          tokensUsed: 1200n,
+        }),
+      ),
+    );
+    expect(items).toHaveLength(1);
+    expect(items[0].taskName).toBe("call_agent");
+    expect(items[0].tokensUsed).toBe(1200n);
+    expect(items[0].costMicros).toBe(0n);
+  });
+
+  it("excludes skipped tasks via the zero-usage filter (the store zeroes their cost and tokens)", () => {
+    const items = deriveWorkflowUsageItems(
+      statesOf(
+        taskState({ taskName: "skipped_task", status: "skipped" }),
+        taskState({ taskName: "real_task", costMicros: 100n, tokensUsed: 50n }),
+      ),
+    );
+    expect(items.map((i) => i.taskName)).toEqual(["real_task"]);
+  });
+
+  it("includes a retrying task that kept its prior attempt's usage", () => {
+    const items = deriveWorkflowUsageItems(
+      statesOf(
+        taskState({ taskName: "flaky_task", status: "retrying", costMicros: 250n, tokensUsed: 900n }),
+      ),
+    );
+    expect(items).toHaveLength(1);
+    expect(items[0].status).toBe("retrying");
+    expect(items[0].costMicros).toBe(250n);
+  });
+
+  it("sorts by cost descending — the most expensive task first", () => {
+    const items = deriveWorkflowUsageItems(
+      statesOf(
+        taskState({ taskName: "cheap", costMicros: 100n, tokensUsed: 10n }),
+        taskState({ taskName: "expensive", costMicros: 900_000n, tokensUsed: 10n }),
+        taskState({ taskName: "middle", costMicros: 5_000n, tokensUsed: 10n }),
+      ),
+    );
+    expect(items.map((i) => i.taskName)).toEqual(["expensive", "middle", "cheap"]);
+  });
+
+  it("breaks cost ties by tokens descending, then name (case-insensitive)", () => {
+    const items = deriveWorkflowUsageItems(
+      statesOf(
+        taskState({ taskName: "Beta", costMicros: 100n, tokensUsed: 10n }),
+        taskState({ taskName: "alpha", costMicros: 100n, tokensUsed: 10n }),
+        taskState({ taskName: "more_tokens", costMicros: 100n, tokensUsed: 999n }),
+      ),
+    );
+    expect(items.map((i) => i.taskName)).toEqual(["more_tokens", "alpha", "Beta"]);
+  });
+
+  it("orders bigint costs beyond Number.MAX_SAFE_INTEGER correctly (no Number() coercion)", () => {
+    // Two values that collapse to the same Number() but differ as bigints.
+    const huge = 9_007_199_254_740_993n; // 2^53 + 1
+    const hugeMinusOne = 9_007_199_254_740_992n; // 2^53
+    const items = deriveWorkflowUsageItems(
+      statesOf(
+        taskState({ taskName: "slightly_smaller", costMicros: hugeMinusOne, tokensUsed: 1n }),
+        taskState({ taskName: "slightly_larger", costMicros: huge, tokensUsed: 1n }),
+      ),
+    );
+    expect(items.map((i) => i.taskName)).toEqual(["slightly_larger", "slightly_smaller"]);
+  });
+
+  it("labels kinds through the shared kind metadata", () => {
+    const items = deriveWorkflowUsageItems(
+      statesOf(
+        taskState({
+          taskName: "call_agent",
+          taskKind: WorkflowTaskKind.agent_call,
+          costMicros: 100n,
+        }),
+      ),
+    );
+    expect(items[0].kindLabel).toBe("Agent Call");
+  });
+});

package/src/workflow/__tests__/execution-graph.test.ts

@@ -148,6 +148,10 @@ spec:
           currentToolName: "",
           messagesCount: 0,
           toolCallsCount: 0,
+          inputSummary: null,
+          outputSummary: null,
+          approvalRequest: null,
+          approvalResolution: null,
         },
       ],
       [
@@ -166,6 +170,10 @@ spec:
           currentToolName: "",
           messagesCount: 0,
           toolCallsCount: 0,
+          inputSummary: null,
+          outputSummary: null,
+          approvalRequest: null,
+          approvalResolution: null,
         },
       ],
     ]);