@stigmer/react 3.12.5 → 3.12.6

package/src/composer/__tests__/SessionComposer-thinkingMode.test.tsx

@@ -0,0 +1,176 @@
+import { describe, it, expect, vi, afterEach, beforeAll } from "vitest";
+import { render, screen, cleanup, fireEvent, waitFor } from "@testing-library/react";
+import { type ReactNode } from "react";
+import type { Stigmer } from "@stigmer/sdk";
+import { StigmerContext } from "../../context";
+import { ModelRegistryContext } from "../../models/ModelRegistryContext";
+import type { ModelInfo } from "../../models/registry";
+import { SessionComposer } from "../SessionComposer";
+
+// Shim ResizeObserver for Base UI's positioner (the
+// scheduleCreation.test.tsx pattern).
+beforeAll(() => {
+  if (!("ResizeObserver" in globalThis)) {
+    (globalThis as unknown as { ResizeObserver: unknown }).ResizeObserver =
+      class {
+        observe() {}
+        unobserve() {}
+        disconnect() {}
+      };
+  }
+});
+
+/**
+ * End-to-end composer wiring for the thinking mode (stigmer/stigmer#772) —
+ * the SessionComposer-serviceTier twin. The toolbar's ModelSelector toggle
+ * must reach composer state, and an active enabled selection must ride the
+ * submit context to execution create. This seam (SessionComposer →
+ * ComposerToolbar props → submit context) is exactly where the #357 tier
+ * toggle originally shipped dead while every layer unit-tested green.
+ */
+
+const THINKING_CAPABLE: ModelInfo = {
+  modelId: "claude-haiku-4-5",
+  provider: "anthropic",
+  displayName: "Haiku 4.5",
+  shortDescription: "Fast Claude with optional thinking",
+  speedTier: "fast",
+  costTier: "economy",
+  harness: "cursor",
+  featured: true,
+  serviceTiers: [],
+  thinkingCapable: true,
+};
+
+const NOT_CAPABLE: ModelInfo = {
+  modelId: "composer-2.5",
+  provider: "cursor",
+  displayName: "Composer 2.5",
+  shortDescription: "Fast agentic model",
+  speedTier: "fastest",
+  costTier: "economy",
+  harness: "cursor",
+  featured: true,
+  serviceTiers: ["fast"],
+  thinkingCapable: false,
+};
+
+function createMinimalStigmerMock(): Stigmer {
+  return {
+    agentExecution: { uploadAttachment: vi.fn() },
+    environment: { getPersonal: vi.fn().mockResolvedValue(null) },
+    baseUrl: "http://localhost:8080",
+    getAuthCredential: vi.fn().mockResolvedValue("test-token"),
+    config: {
+      baseUrl: "http://localhost:8080",
+      getAccessToken: vi.fn().mockResolvedValue(""),
+    },
+  } as unknown as Stigmer;
+}
+
+function createWrapper(client: Stigmer) {
+  return function Wrapper({ children }: { children: ReactNode }) {
+    return (
+      <StigmerContext.Provider value={client}>
+        <ModelRegistryContext.Provider
+          value={{
+            models: [THINKING_CAPABLE, NOT_CAPABLE],
+            isLoading: false,
+            error: null,
+            refetch: vi.fn(),
+          }}
+        >
+          {children}
+        </ModelRegistryContext.Provider>
+      </StigmerContext.Provider>
+    );
+  };
+}
+
+function renderComposer(defaultModelId = "claude-haiku-4-5") {
+  const client = createMinimalStigmerMock();
+  const onSubmit = vi.fn();
+
+  const result = render(
+    <SessionComposer
+      onSubmit={onSubmit}
+      harness="cursor"
+      defaultModelId={defaultModelId}
+    />,
+    { wrapper: createWrapper(client) },
+  );
+
+  return { ...result, onSubmit };
+}
+
+function submitMessage(message: string) {
+  const textarea = screen.getByRole("textbox");
+  fireEvent.change(textarea, { target: { value: message } });
+  fireEvent.keyDown(textarea, { key: "Enter", shiftKey: false });
+}
+
+/**
+ * Open the model selector popover (Base UI portals mount asynchronously in
+ * jsdom — the switch is awaited) and flip the thinking switch in the
+ * options area, then close the popover (toggling keeps it open).
+ */
+async function toggleThinking(triggerName: RegExp = /Haiku 4\.5/) {
+  fireEvent.click(screen.getByRole("button", { name: triggerName }));
+  const toggle = await screen.findByRole("switch", { name: "Thinking" });
+  fireEvent.click(toggle);
+  fireEvent.keyDown(document.activeElement ?? document.body, { key: "Escape" });
+}
+
+afterEach(cleanup);
+
+describe("SessionComposer — thinking mode submit contract", () => {
+  it("renders the thinking switch through the toolbar for a capable model", async () => {
+    renderComposer();
+
+    fireEvent.click(screen.getByRole("button", { name: /Haiku 4\.5/ }));
+    expect(await screen.findByRole("switch", { name: "Thinking" })).toBeTruthy();
+  });
+
+  it("renders no thinking switch for a model without the capability", async () => {
+    renderComposer("composer-2.5");
+
+    fireEvent.click(screen.getByRole("button", { name: /Composer 2\.5/ }));
+    // The fast switch proves the options area itself rendered — only the
+    // thinking row must be absent (no dead controls).
+    await screen.findByRole("switch", { name: "Fast tier" });
+    expect(screen.queryByRole("switch", { name: "Thinking" })).toBeNull();
+  });
+
+  it("carries thinkingMode 'enabled' on the submit context after toggling", async () => {
+    const { onSubmit } = renderComposer();
+
+    await toggleThinking();
+    submitMessage("Think hard about this");
+
+    await waitFor(() => expect(onSubmit).toHaveBeenCalledOnce());
+    const context = onSubmit.mock.calls[0][2];
+    expect(context?.thinkingMode).toBe("enabled");
+  });
+
+  it("leaves thinkingMode undefined when the switch is untouched", async () => {
+    const { onSubmit } = renderComposer();
+
+    submitMessage("Just answer");
+
+    await waitFor(() => expect(onSubmit).toHaveBeenCalledOnce());
+    const context = onSubmit.mock.calls[0][2];
+    expect(context?.thinkingMode).toBeUndefined();
+  });
+
+  it("leaves thinkingMode undefined after toggling on and back off", async () => {
+    const { onSubmit } = renderComposer();
+
+    await toggleThinking();
+    await toggleThinking();
+    submitMessage("Changed my mind");
+
+    await waitFor(() => expect(onSubmit).toHaveBeenCalledOnce());
+    const context = onSubmit.mock.calls[0][2];
+    expect(context?.thinkingMode).toBeUndefined();
+  });
+});

package/src/cursor-accounts/CursorAccountsConsole.tsx

@@ -10,7 +10,7 @@ import { Button } from "../button/index.js";
 import { StateBadge } from "./badges.js";
 import { CursorAccountEditor } from "./CursorAccountEditor.js";
 import { CursorAccountsAccessNotice } from "./CursorAccountsAccessNotice.js";
-import { deriveCoverage } from "./cursor-account-coverage.js";
+import { deriveCoverage, derivePoolHealth } from "./cursor-account-coverage.js";
 import { formatSyncTime } from "./cursor-account-format.js";
 import { MemberKeysPanel } from "./MemberKeysPanel.js";
 import { useCursorAccounts } from "./useCursorAccounts.js";
@@ -119,11 +119,38 @@ export function CursorAccountsConsole({ className }: CursorAccountsConsoleProps)
   }
 
   const accounts = list.accounts?.accounts ?? [];
+  const health = derivePoolHealth(accounts);
 
   return (
     <div className={cn("stg:space-y-3", className)}>
       <div className="stg:flex stg:items-center stg:justify-between stg:gap-3">
-        <h3 className="stg:text-sm stg:font-semibold stg:text-foreground">Cursor accounts</h3>
+        <div>
+          <h3 className="stg:text-sm stg:font-semibold stg:text-foreground">Cursor accounts</h3>
+          {/* Fleet health in one line (server-computed routability): the
+              2026-08-15 drain hid behind per-account enabled counts — this
+              is the fact the operator needed on THIS screen. */}
+          {accounts.length > 0 && (
+            <p
+              className={cn(
+                "stg:text-[11px]",
+                health.totalRoutableKeys === 0
+                  ? "stg:text-destructive"
+                  : "stg:text-muted-foreground",
+              )}
+              role={health.totalRoutableKeys === 0 ? "alert" : undefined}
+            >
+              {health.totalRoutableKeys === 0
+                ? "No routable execution key anywhere - executions on API-pool models are failing"
+                : `${health.totalRoutableKeys} routable ${health.totalRoutableKeys === 1 ? "key" : "keys"} across ${health.totalAccounts} ${health.totalAccounts === 1 ? "account" : "accounts"}`}
+              {health.drainedAccounts > 0
+                ? ` · ${health.drainedAccounts} ${health.drainedAccounts === 1 ? "account" : "accounts"} drained`
+                : ""}
+              {health.guardTrippedKeys > 0
+                ? ` · ${health.guardTrippedKeys} ${health.guardTrippedKeys === 1 ? "key" : "keys"} usage-drained`
+                : ""}
+            </p>
+          )}
+        </div>
         <Button size="sm" onClick={() => setFlow({ phase: "create" })}>
           Add account
         </Button>
@@ -137,7 +164,7 @@ export function CursorAccountsConsole({ className }: CursorAccountsConsoleProps)
           <span>Account</span>
           <span>Orgs</span>
           <span>Status</span>
-          <span>Execution keys</span>
+          <span>Routable keys</span>
           <span className="stg:text-right">Last synced</span>
         </div>
         {accounts.length === 0 ? (
@@ -214,8 +241,16 @@ function AccountRow({
           />
         </span>
         <span>
-          {summary.enabledKeyCount > 0 ? (
-            <span className="stg:text-muted-foreground">{summary.enabledKeyCount}</span>
+          {/* Routability, not enabled-ness: what key selection would DO.
+              "Drained" (usage guard) is recoverable at the cycle reset;
+              "Not routable" (no enabled key, or owners removed) needs
+              operator action. */}
+          {summary.routableKeyCount > 0 ? (
+            <span className="stg:text-muted-foreground">
+              {summary.routableKeyCount} of {summary.enabledKeyCount}
+            </span>
+          ) : summary.guardTrippedKeyCount > 0 ? (
+            <StateBadge tone="warn" label="Drained" />
           ) : (
             <StateBadge tone="warn" label="Not routable" />
           )}

package/src/cursor-accounts/__tests__/CursorAccountsConsole.test.tsx

@@ -86,6 +86,7 @@ function scenarSummary() {
   return create(CursorAccountSummarySchema, {
     account: scenarAccount(),
     enabledKeyCount: 1,
+    routableKeyCount: 1,
     lastSyncedAt: timestampFromDate(new Date("2026-07-22T12:00:00Z")),
   });
 }
@@ -194,6 +195,37 @@ describe("CursorAccountsConsole", () => {
     expect(screen.getByText("empty team")).toBeTruthy();
     expect(screen.getByText("Not routable")).toBeTruthy();
     expect(screen.getByText("shared pool")).toBeTruthy();
+    // Routable count renders as "N of M" (server-computed routability),
+    // and the fleet-health line aggregates it.
+    expect(screen.getByText("1 of 1")).toBeTruthy();
+    expect(screen.getByText(/1 routable key across 2 accounts/)).toBeTruthy();
+  });
+
+  it("surfaces a fully guard-drained account and the fleet drain alert", async () => {
+    // The 2026-08-15 shape: enabled keys exist, none routable — the one
+    // key left is usage-guard-tripped. The row must read "Drained" (a
+    // cycle-reset condition), not the misleading enabled count, and with
+    // zero routable keys fleet-wide the health line must alarm.
+    const drained = create(CursorAccountSummarySchema, {
+      account: scenarAccount({
+        accountId: "acc-3",
+        displayName: "drained team",
+        orgIds: [],
+      }),
+      enabledKeyCount: 1,
+      routableKeyCount: 0,
+      guardTrippedKeyCount: 1,
+    });
+    const client = createMockStigmer({
+      listAccounts: vi.fn().mockResolvedValue({ accounts: [drained] }),
+    });
+    render(<CursorAccountsConsole />, { wrapper: wrapper(client) });
+
+    await waitFor(() => expect(screen.getByText("drained team")).toBeTruthy());
+    expect(screen.getByText("Drained")).toBeTruthy();
+    expect(
+      screen.getByText(/No routable execution key anywhere/),
+    ).toBeTruthy();
   });
 
   it("shows the designed access notice on PERMISSION_DENIED", async () => {

package/src/cursor-accounts/__tests__/cursor-account-coverage.test.ts

@@ -7,12 +7,14 @@ import {
   CursorTeamMemberSchema,
 } from "@stigmer/protos/ai/stigmer/platform/cursoraccount/v1/cursor_account_pb";
 import {
+  CursorAccountSummarySchema,
   CursorAccountViewSchema,
   CursorMemberKeyState,
   CursorMemberKeyViewSchema,
   CursorTeamMemberViewSchema,
 } from "@stigmer/protos/ai/stigmer/platform/cursoraccount/v1/io_pb";
-import { deriveCoverage } from "../cursor-account-coverage";
+import { CursorAccountSchema } from "@stigmer/protos/ai/stigmer/platform/cursoraccount/v1/cursor_account_pb";
+import { deriveCoverage, derivePoolHealth } from "../cursor-account-coverage";
 
 function keyView(keyId: string, state: CursorMemberKeyState) {
   return create(CursorMemberKeyViewSchema, {
@@ -71,3 +73,58 @@ describe("deriveCoverage", () => {
     expect(coverage.onTeamWithKey).toEqual([]);
   });
 });
+
+describe("derivePoolHealth", () => {
+  function summary(opts: {
+    enabled?: boolean;
+    enabledKeyCount: number;
+    routableKeyCount: number;
+    guardTrippedKeyCount?: number;
+  }) {
+    return create(CursorAccountSummarySchema, {
+      account: create(CursorAccountSchema, {
+        accountId: "acc",
+        enabled: opts.enabled ?? true,
+      }),
+      enabledKeyCount: opts.enabledKeyCount,
+      routableKeyCount: opts.routableKeyCount,
+      guardTrippedKeyCount: opts.guardTrippedKeyCount ?? 0,
+    });
+  }
+
+  it("reproduces the 2026-08-15 drain as a one-line fact", () => {
+    // Four accounts with enabled keys but zero routable (guard-tripped or
+    // owner-removed), one fresh account with a single routable key — the
+    // fleet state the per-account enabled counts hid.
+    const health = derivePoolHealth([
+      summary({ enabledKeyCount: 1, routableKeyCount: 0, guardTrippedKeyCount: 1 }),
+      summary({ enabledKeyCount: 10, routableKeyCount: 0 }),
+      summary({ enabledKeyCount: 1, routableKeyCount: 0 }),
+      summary({ enabledKeyCount: 0, routableKeyCount: 0 }),
+      summary({ enabledKeyCount: 2, routableKeyCount: 1, guardTrippedKeyCount: 0 }),
+    ]);
+
+    expect(health.totalAccounts).toBe(5);
+    expect(health.totalRoutableKeys).toBe(1);
+    // The zero-key account is not "drained" — it never had capacity.
+    expect(health.drainedAccounts).toBe(3);
+    expect(health.guardTrippedKeys).toBe(1);
+  });
+
+  it("does not count disabled accounts as drained (disable means drain-by-choice)", () => {
+    const health = derivePoolHealth([
+      summary({ enabled: false, enabledKeyCount: 3, routableKeyCount: 0 }),
+    ]);
+
+    expect(health.drainedAccounts).toBe(0);
+  });
+
+  it("is all zeros for an empty list", () => {
+    const health = derivePoolHealth([]);
+
+    expect(health.totalAccounts).toBe(0);
+    expect(health.totalRoutableKeys).toBe(0);
+    expect(health.drainedAccounts).toBe(0);
+    expect(health.guardTrippedKeys).toBe(0);
+  });
+});

package/src/cursor-accounts/cursor-account-coverage.ts

@@ -1,5 +1,6 @@
 import {
   CursorMemberKeyState,
+  type CursorAccountSummary,
   type CursorAccountView,
   type CursorMemberKeyView,
   type CursorTeamMemberView,
@@ -69,3 +70,57 @@ export function deriveCoverage(view: CursorAccountView): CursorAccountCoverage {
     unclassified: [],
   };
 }
+
+/**
+ * Fleet-wide health rolled up from the list summaries — the console's
+ * answer to "can the platform serve right now, and from where?". Pure
+ * aggregation of the server-computed routable/guard counts (the same
+ * routability rule key selection uses); this module must never
+ * re-derive routability client-side.
+ *
+ * <p>Why this exists: in the 2026-08-15 pool drain, the list showed
+ * five accounts with healthy-looking enabled-key counts while exactly
+ * one guard-tripped key could serve — the operator had to open every
+ * account detail to see it. The rollup makes fleet exhaustion a
+ * one-line fact.
+ */
+export interface CursorPoolHealth {
+  /** Total accounts in the list. */
+  readonly totalAccounts: number;
+  /** Keys the routability rule would select for a new session, fleet-wide. */
+  readonly totalRoutableKeys: number;
+  /**
+   * Enabled accounts with enabled keys but zero routable ones — every
+   * key is dead (owner removed) or usage-drained. These are the rows
+   * that look healthy at a glance and are not.
+   */
+  readonly drainedAccounts: number;
+  /** Enabled keys excluded only by the usage guard, fleet-wide. */
+  readonly guardTrippedKeys: number;
+}
+
+/** Aggregate the server-computed summary counts across the account list. */
+export function derivePoolHealth(
+  summaries: readonly CursorAccountSummary[],
+): CursorPoolHealth {
+  let totalRoutableKeys = 0;
+  let drainedAccounts = 0;
+  let guardTrippedKeys = 0;
+  for (const summary of summaries) {
+    totalRoutableKeys += summary.routableKeyCount;
+    guardTrippedKeys += summary.guardTrippedKeyCount;
+    if (
+      summary.account?.enabled === true
+      && summary.enabledKeyCount > 0
+      && summary.routableKeyCount === 0
+    ) {
+      drainedAccounts += 1;
+    }
+  }
+  return {
+    totalAccounts: summaries.length,
+    totalRoutableKeys,
+    drainedAccounts,
+    guardTrippedKeys,
+  };
+}

package/src/execution/useCreateAgentExecution.ts

@@ -14,6 +14,7 @@ import { useStigmer } from "../hooks.js";
 import { toError } from "../internal/toError.js";
 import { toProtoInteractionMode } from "../composer/interaction-mode.js";
 import { toProtoServiceTier, type ServiceTierOption } from "../models/service-tier.js";
+import { toProtoThinkingMode, type ThinkingModeOption } from "../models/thinking-mode.js";
 import { toProtoHarness, type HarnessOption } from "../models/harness.js";
 import {
   toProtoExecutionTarget,
@@ -138,6 +139,20 @@ export interface SharedAgentExecutionFields {
    * Maps to `ExecutionConfig.service_tier` in the proto.
    */
   readonly serviceTier?: ServiceTierOption;
+  /**
+   * Thinking mode for this execution's model calls (stigmer/stigmer#772).
+   *
+   * - `"disabled"` (default): the model's base variant, pinned explicitly —
+   *   never the provider account default.
+   * - `"enabled"`: the model's extended-reasoning variant, billed at base
+   *   per-token rates (reasoning tokens bill as output). Valid only for
+   *   cursor-harness models whose registry entry declares the thinking
+   *   capability — the backend refuses the create otherwise, so gate the
+   *   option on `ModelInfo.thinkingCapable`.
+   *
+   * Maps to `ExecutionConfig.thinking_mode` in the proto.
+   */
+  readonly thinkingMode?: ThinkingModeOption;
   /**
    * Marks this execution as a Build-from-plan turn: the user approved a
    * plan from a prior Plan-mode execution and asked the agent to implement
@@ -318,6 +333,7 @@ export function useCreateAgentExecution(): UseCreateAgentExecutionReturn {
           input.modelName ||
           input.interactionMode ||
           input.serviceTier ||
+          input.thinkingMode ||
           input.structuredOutputSchema ||
           input.buildFromPlan;
         const executionConfig = hasConfig
@@ -329,6 +345,9 @@ export function useCreateAgentExecution(): UseCreateAgentExecutionReturn {
               ...(input.serviceTier
                 ? { serviceTier: toProtoServiceTier(input.serviceTier) }
                 : {}),
+              ...(input.thinkingMode
+                ? { thinkingMode: toProtoThinkingMode(input.thinkingMode) }
+                : {}),
               ...(input.structuredOutputSchema
                 ? { structuredOutputSchema: input.structuredOutputSchema }
                 : {}),