@stigmer/react 3.5.3 → 3.7.0

package/src/schedule/useUpdateScheduleSpec.ts

@@ -0,0 +1,108 @@
+"use client";
+
+import { useCallback, useMemo, useState } from "react";
+import { clone } from "@bufbuild/protobuf";
+import {
+  ScheduleSchema,
+  type Schedule,
+} from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/api_pb";
+import type { ScheduleSpec } from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/spec_pb";
+import { getUserMessage, manifestDocumentForResource } from "@stigmer/sdk";
+import { useStigmer } from "../hooks.js";
+import { toast } from "../feedback/toast.js";
+
+/** Return value of {@link useUpdateScheduleSpec}. */
+export interface UseUpdateScheduleSpecReturn {
+  /**
+   * Apply one spec mutation to the schedule. Takes the full fetched
+   * schedule (not just an id) because the write re-applies the whole
+   * resource. Resolves with the post-apply schedule; the caller
+   * refetches or replaces its local copy from it.
+   */
+  readonly updateSpec: (
+    schedule: Schedule,
+    mutate: (spec: ScheduleSpec) => void,
+  ) => Promise<Schedule>;
+  /** `true` while the apply is in flight. */
+  readonly isUpdating: boolean;
+  /** Error from the last failed apply, or `null` when healthy. */
+  readonly error: Error | null;
+}
+
+/**
+ * Behavior hook behind the schedule detail view's inline editing: apply
+ * a single spec mutation losslessly.
+ *
+ * The write path is deliberate, and it is NOT the agent detail view's
+ * input-based one: clone the fetched proto, let the caller mutate the
+ * spec in place, and re-apply the WHOLE resource through the manifest
+ * engine (`stigmer.manifest.apply`) — never down-convert to the curated
+ * `ScheduleInput` shape. The server replaces spec and mutable metadata
+ * wholesale on update, and `ScheduleInput` cannot express every
+ * metadata field (tags, description), so the input route would silently
+ * wipe them. The full-proto route is lossless by construction; the
+ * server ignores client-provided status, and re-applying never clears a
+ * platform pause (Resume is the one clearing path — see
+ * `useResumeSchedule`). Same mechanics as {@link useSetScheduleEnabled},
+ * generalized from one hardcoded field to any spec edit.
+ *
+ * Errors are NOT toasted here: inline editors surface the server's
+ * message next to the field that was edited (DD-006), and a toast on
+ * top would say the same thing twice.
+ *
+ * @example
+ * ```tsx
+ * const { updateSpec, isUpdating } = useUpdateScheduleSpec();
+ *
+ * await updateSpec(schedule, (spec) => {
+ *   spec.cron = "0 9 * * 1-5";
+ *   spec.timeZone = "Asia/Kolkata";
+ * });
+ * ```
+ */
+export function useUpdateScheduleSpec(): UseUpdateScheduleSpecReturn {
+  const stigmer = useStigmer();
+  const [isUpdating, setIsUpdating] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const updateSpec = useCallback(
+    async (
+      schedule: Schedule,
+      mutate: (spec: ScheduleSpec) => void,
+    ): Promise<Schedule> => {
+      if (!schedule.spec) {
+        throw new Error(
+          "Cannot edit this schedule: it has no spec. Pass a schedule " +
+            "as returned by the server (get/getByReference).",
+        );
+      }
+
+      setIsUpdating(true);
+      setError(null);
+      try {
+        const updated = clone(ScheduleSchema, schedule);
+        mutate(updated.spec!);
+
+        const applied = await stigmer.manifest.apply(
+          manifestDocumentForResource(updated),
+        );
+        toast.success("Schedule updated");
+        return applied.message as Schedule;
+      } catch (err) {
+        // Rethrow with the user-facing message: the inline editors render
+        // `message` verbatim next to the edited field.
+        const wrapped = new Error(getUserMessage(err));
+        setError(wrapped);
+        throw wrapped;
+      } finally {
+        setIsUpdating(false);
+      }
+    },
+    [stigmer],
+  );
+
+  return useMemo(
+    () => ({ updateSpec, isUpdating, error }),
+    [updateSpec, isUpdating, error],
+  );
+}

package/src/search/__tests__/useResourceCount.test.tsx

@@ -0,0 +1,89 @@
+import { describe, it, expect, vi } from "vitest";
+import { renderHook, waitFor } from "@testing-library/react";
+import type { ListParams, ListResult } from "@stigmer/sdk";
+import { useResourceCount } from "../useResourceCount";
+
+function mockListFn(totalCount = 0) {
+  return vi.fn<(params: ListParams) => Promise<ListResult>>().mockResolvedValue({
+    entries: [],
+    totalCount,
+    totalPages: totalCount > 0 ? 1 : 0,
+  } as never);
+}
+
+describe("useResourceCount", () => {
+  it("counts in org scope by default: org sent, crossOrgPublic false", async () => {
+    const listFn = mockListFn(7);
+
+    const { result } = renderHook(() => useResourceCount(listFn, "acme"));
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    expect(result.current.count).toBe(7);
+    const params = listFn.mock.calls[0][0];
+    expect(params.org).toBe("acme");
+    expect(params.crossOrgPublic).toBe(false);
+    expect(params.page).toEqual({ num: 1, size: 1 });
+  });
+
+  it('always sends org in "all" scope (empty org means a cross-org FGA dump to the backend)', async () => {
+    const listFn = mockListFn(3);
+
+    const { result } = renderHook(() =>
+      useResourceCount(listFn, "acme", { scope: "all" }),
+    );
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    const params = listFn.mock.calls[0][0];
+    // Regression guard: the pre-fix hook blanked org for "all", which the
+    // search backend defines as "every org the caller can access" — the
+    // Library cards then counted platform-wide instead of org + public.
+    expect(params.org).toBe("acme");
+    expect(params.crossOrgPublic).toBe(true);
+  });
+
+  it("does not fetch when org is null", async () => {
+    const listFn = mockListFn();
+
+    const { result } = renderHook(() => useResourceCount(listFn, null));
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    expect(listFn).not.toHaveBeenCalled();
+    expect(result.current.count).toBeUndefined();
+  });
+
+  it("recounts when refetchToken changes", async () => {
+    const listFn = mockListFn(1);
+
+    const { result, rerender } = renderHook(
+      ({ token }: { token: number }) =>
+        useResourceCount(listFn, "acme", { refetchToken: token }),
+      { initialProps: { token: 0 } },
+    );
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(listFn).toHaveBeenCalledTimes(1);
+
+    rerender({ token: 1 });
+
+    await waitFor(() => expect(listFn).toHaveBeenCalledTimes(2));
+  });
+
+  it("refetches with the new org when the org changes", async () => {
+    const listFn = mockListFn(2);
+
+    const { result, rerender } = renderHook(
+      ({ org }: { org: string }) => useResourceCount(listFn, org),
+      { initialProps: { org: "acme" } },
+    );
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    rerender({ org: "globex" });
+
+    await waitFor(() => expect(listFn).toHaveBeenCalledTimes(2));
+    expect(listFn.mock.calls[1][0].org).toBe("globex");
+  });
+});

package/src/search/useResourceCount.ts

@@ -11,7 +11,8 @@ export interface UseResourceCountOptions {
    * Controls resource visibility scope.
    *
    * - `"org"` — all resources owned by the given organization, regardless of visibility.
-   * - `"all"` — all resources the caller is authorized to access, across all organizations.
+   * - `"all"` — all resources owned by the given organization plus public resources
+   *   from other organizations.
    *
    * @default "org"
    */
@@ -64,10 +65,15 @@ export function useResourceCount(
   const { data: count, isLoading, isRefetching, error, refetch } = useFetch<number | undefined>(
     org
       ? async () => {
+          // Identical params to useResourceList so a card's count always matches
+          // the list page it links to. `org` is ALWAYS sent: an empty org means
+          // "every org the caller can access" to the search backend (a global FGA
+          // dump), and `crossOrgPublic` with an empty org matches zero rows.
           const params: ListParams = {
-            org: scope === "all" ? "" : org,
+            org,
             query: query || undefined,
             excludePublic: false,
+            crossOrgPublic: scope === "all",
             page: { num: 1, size: 1 },
           };
           const result = await listFn(params);

package/src/session/useNewSessionFlow.ts

@@ -389,6 +389,7 @@ export function useNewSessionFlow(
           runtimeEnv,
           attachments: context?.attachments,
           interactionMode: context?.interactionMode,
+          serviceTier: context?.serviceTier,
           workspaceFileRefs: context?.workspaceFileRefs,
         };
 

package/src/session/useSessionConversation.ts

@@ -17,6 +17,7 @@ import type {
   WorkspaceEntryInput,
 } from "@stigmer/sdk";
 import { isTerminalPhase } from "../execution/execution-phases.js";
+import type { ServiceTierOption } from "../models/service-tier.js";
 import { useStigmer } from "../hooks.js";
 import { toError } from "../internal/toError.js";
 import { useConversationStoreRef } from "../internal/store/index.js";
@@ -96,6 +97,16 @@ export interface SendFollowUpOptions {
    * - `"plan"`: read-only analysis, no file mutations.
    */
   readonly interactionMode?: "agent" | "plan";
+  /**
+   * Service tier for this execution's model calls (stigmer/stigmer#357).
+   *
+   * Only set when the user actively selected `"fast"`; `undefined` preserves
+   * the unspecified-vs-explicit distinction (unset resolves to standard on
+   * the platform side — never the provider account default).
+   *
+   * @see {@link CreateAgentExecutionInput.serviceTier}
+   */
+  readonly serviceTier?: ServiceTierOption;
   /**
    * Marks this execution as a Build-from-plan turn.
    *
@@ -642,6 +653,7 @@ export function useSessionConversation(
           runtimeEnv: options?.runtimeEnv,
           attachments: options?.attachments,
           interactionMode: options?.interactionMode,
+          serviceTier: options?.serviceTier,
           buildFromPlan: options?.buildFromPlan,
           autoApproveAll: options?.autoApproveAll,
           workspaceFileRefs: options?.workspaceFileRefs,

package/src/session/useSessionPageFlow.ts

@@ -438,6 +438,7 @@ export function useSessionPageFlow(
         runtimeEnv,
         attachments: context?.attachments,
         interactionMode: context?.interactionMode,
+        serviceTier: context?.serviceTier,
         buildFromPlan: context?.buildFromPlan,
         // Sourced from the session-scoped preference set at the approval gate,
         // not from the composer (the pre-arm toggle was removed).

package/src/workflow/WorkflowDashboard.tsx

@@ -82,6 +82,7 @@ export const WorkflowDashboard = memo(function WorkflowDashboard({
               create(ListWorkflowExecutionsRequestSchema, {
                 pageSize: 5,
                 phase: ExecutionPhase.EXECUTION_FAILED,
+                org,
               }),
             );
             return [...resp.entries] as readonly WorkflowExecution[];

package/src/workflow/__tests__/inspector-forms.test.tsx

@@ -34,15 +34,132 @@ describe("AgentCallForm", () => {
     expect(textarea.value).toBe("Hello world");
   });
 
-  it("renders model input from nested config", () => {
+  it("renders model input from the run_config block", () => {
     const node = makeNode(WorkflowTaskKind.agent_call, {
       agent: "x",
       message: "y",
-      config: { model: "claude-sonnet-4", timeout: 120 },
+      run_config: { model_name: "claude-sonnet-4", max_cost_usd: 0.5 },
     });
     render(<AgentCallForm node={node} onFieldChange={vi.fn()} />);
     const input = screen.getByTestId("agent-call-model-input") as HTMLInputElement;
     expect(input.value).toBe("claude-sonnet-4");
+    const budget = screen.getByTestId("agent-call-budget-input") as HTMLInputElement;
+    expect(budget.value).toBe("0.5");
+  });
+
+  it("emits an undefined run_config when the last field is cleared", () => {
+    const onFieldChange = vi.fn();
+    const node = makeNode(WorkflowTaskKind.agent_call, {
+      agent: "x",
+      message: "y",
+      run_config: { max_cost_usd: 0.5 },
+    });
+    render(<AgentCallForm node={node} onFieldChange={onFieldChange} />);
+
+    const budget = screen.getByTestId("agent-call-budget-input") as HTMLInputElement;
+    fireEvent.change(budget, { target: { value: "" } });
+
+    // Empty means omit: a blank field must not persist a zero override.
+    expect(onFieldChange).toHaveBeenCalledWith("run_config", undefined);
+  });
+
+  it("writes budget changes into run_config.max_cost_usd", () => {
+    const onFieldChange = vi.fn();
+    const node = makeNode(WorkflowTaskKind.agent_call, {
+      agent: "x",
+      message: "y",
+      run_config: { model_name: "claude-sonnet-4" },
+    });
+    render(<AgentCallForm node={node} onFieldChange={onFieldChange} />);
+
+    const budget = screen.getByTestId("agent-call-budget-input") as HTMLInputElement;
+    fireEvent.change(budget, { target: { value: "1.25" } });
+
+    expect(onFieldChange).toHaveBeenCalledWith("run_config", {
+      model_name: "claude-sonnet-4",
+      max_cost_usd: 1.25,
+    });
+  });
+
+  it("renders workspace entries and edits the git url in place", () => {
+    const onFieldChange = vi.fn();
+    const node = makeNode(WorkflowTaskKind.agent_call, {
+      agent: "x",
+      message: "y",
+      workspace_entries: [
+        { name: "app", source: { git_repo: { url: "https://github.com/acme/app", branch: "main" } } },
+      ],
+    });
+    render(<AgentCallForm node={node} onFieldChange={onFieldChange} />);
+
+    const url = screen.getByTestId("agent-call-workspace-url-0") as HTMLInputElement;
+    expect(url.value).toBe("https://github.com/acme/app");
+
+    fireEvent.change(url, { target: { value: "https://github.com/acme/other" } });
+    expect(onFieldChange).toHaveBeenCalledWith("workspace_entries", [
+      { name: "app", source: { git_repo: { url: "https://github.com/acme/other", branch: "main" } } },
+    ]);
+  });
+
+  it("adds a workspace entry row", () => {
+    const onFieldChange = vi.fn();
+    const node = makeNode(WorkflowTaskKind.agent_call, { agent: "x", message: "y" });
+    render(<AgentCallForm node={node} onFieldChange={onFieldChange} />);
+
+    fireEvent.click(screen.getByTestId("agent-call-workspace-add"));
+    expect(onFieldChange).toHaveBeenCalledWith("workspace_entries", [
+      { source: { git_repo: { url: "" } } },
+    ]);
+  });
+
+  it("emits undefined when the last workspace entry is removed", () => {
+    const onFieldChange = vi.fn();
+    const node = makeNode(WorkflowTaskKind.agent_call, {
+      agent: "x",
+      message: "y",
+      workspace_entries: [
+        { source: { git_repo: { url: "https://github.com/acme/app" } } },
+      ],
+    });
+    render(<AgentCallForm node={node} onFieldChange={onFieldChange} />);
+
+    fireEvent.click(screen.getByLabelText("Remove workspace entry 1"));
+    expect(onFieldChange).toHaveBeenCalledWith("workspace_entries", undefined);
+  });
+
+  it("edits environment references as org/slug rows with empty-org omitted", () => {
+    const onFieldChange = vi.fn();
+    const node = makeNode(WorkflowTaskKind.agent_call, {
+      agent: "x",
+      message: "y",
+      environment_refs: [{ slug: "shared-secrets" }],
+    });
+    render(<AgentCallForm node={node} onFieldChange={onFieldChange} />);
+
+    const slug = screen.getByTestId("agent-call-envref-slug-0") as HTMLInputElement;
+    expect(slug.value).toBe("shared-secrets");
+
+    fireEvent.change(slug, { target: { value: "other-secrets" } });
+    // Empty org stays omitted — an empty string must not become a stored
+    // org override (relative refs resolve to the workflow's own org).
+    expect(onFieldChange).toHaveBeenCalledWith("environment_refs", [
+      { slug: "other-secrets" },
+    ]);
+  });
+
+  it("adds and removes environment reference rows", () => {
+    const onFieldChange = vi.fn();
+    const node = makeNode(WorkflowTaskKind.agent_call, {
+      agent: "x",
+      message: "y",
+      environment_refs: [{ slug: "a" }, { org: "acme", slug: "b" }],
+    });
+    render(<AgentCallForm node={node} onFieldChange={onFieldChange} />);
+
+    fireEvent.click(screen.getByLabelText("Remove environment reference 1"));
+    expect(onFieldChange).toHaveBeenCalledWith("environment_refs", [
+      { org: "acme", slug: "b" },
+    ]);
   });
 
   it("shows structured output section when output is present", () => {