@stigmer/react 3.12.5 → 3.12.6

package/src/channel/__tests__/ChannelRunConfigDialog.test.tsx

@@ -0,0 +1,210 @@
+import { describe, it, expect, vi, beforeAll, afterEach } from "vitest";
+import { render, screen, fireEvent, waitFor, cleanup } from "@testing-library/react";
+import type { ReactNode } from "react";
+import { ServiceTier, ThinkingMode } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import type { AgentChannelInput } from "@stigmer/sdk";
+import { StigmerContext } from "../../context";
+import { ModelRegistryContext } from "../../models/ModelRegistryContext";
+import type { ModelInfo } from "../../models/registry";
+import { ChannelRunConfigDialog } from "../ChannelRunConfigDialog";
+
+// happy-dom does not implement the native dialog show/close methods.
+beforeAll(() => {
+  HTMLDialogElement.prototype.showModal = function showModal() {
+    this.open = true;
+  };
+  HTMLDialogElement.prototype.close = function close() {
+    this.open = false;
+  };
+  if (!("ResizeObserver" in globalThis)) {
+    (globalThis as unknown as { ResizeObserver: unknown }).ResizeObserver =
+      class {
+        observe() {}
+        unobserve() {}
+        disconnect() {}
+      };
+  }
+});
+
+afterEach(cleanup);
+
+/**
+ * The console's first run_config editor (stigmer/stigmer#792). The pinned
+ * behaviors are the edit-surface contracts the rest of the platform relies
+ * on: `max_tool_rounds` (the operator knob this editor never renders)
+ * survives every save verbatim, an all-empty draft clears the block
+ * ("empty = inherit"), and untouched variant switches stay off the wire
+ * (the #357/#772 unspecified-vs-explicit ledger distinction).
+ */
+
+const MODELS: 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,
+  },
+];
+
+function makeChannel(runConfig?: {
+  modelName?: string;
+  maxCostUsd?: number;
+  maxToolRounds?: number;
+  serviceTier?: ServiceTier;
+  thinkingMode?: ThinkingMode;
+}) {
+  return {
+    metadata: {
+      id: "ach_1",
+      name: "Support Slack",
+      slug: "support-slack",
+      org: "acme",
+      labels: {},
+    },
+    spec: {
+      agentRef: { org: "acme", slug: "support-agent" },
+      enabled: true,
+      providerConfig: { case: "slack", value: {} },
+      environmentRefs: [],
+      ...(runConfig
+        ? {
+            runConfig: {
+              modelName: runConfig.modelName ?? "",
+              maxCostUsd: runConfig.maxCostUsd ?? 0,
+              maxToolRounds: runConfig.maxToolRounds ?? 0,
+              serviceTier: runConfig.serviceTier ?? ServiceTier.UNSPECIFIED,
+              thinkingMode: runConfig.thinkingMode ?? ThinkingMode.UNSPECIFIED,
+            },
+          }
+        : {}),
+    },
+    status: { installState: 2 },
+  } as never;
+}
+
+function createMockStigmer() {
+  const apply = vi.fn().mockResolvedValue({});
+  const client = { agentChannel: { apply } } as never;
+  return { client, apply };
+}
+
+function Providers({
+  client,
+  children,
+}: {
+  client: unknown;
+  children: ReactNode;
+}) {
+  return (
+    <StigmerContext.Provider value={client as never}>
+      <ModelRegistryContext.Provider
+        value={{ models: MODELS, isLoading: false, error: null, refetch: vi.fn() }}
+      >
+        {children}
+      </ModelRegistryContext.Provider>
+    </StigmerContext.Provider>
+  );
+}
+
+function renderDialog(channel: unknown) {
+  const { client, apply } = createMockStigmer();
+  const onSaved = vi.fn();
+  render(
+    <Providers client={client}>
+      <ChannelRunConfigDialog
+        open
+        onOpenChange={vi.fn()}
+        channel={channel as never}
+        onSaved={onSaved}
+      />
+    </Providers>,
+  );
+  return { apply, onSaved };
+}
+
+async function save() {
+  fireEvent.click(screen.getByRole("button", { name: "Save" }));
+}
+
+describe("ChannelRunConfigDialog", () => {
+  it("preserves max_tool_rounds verbatim even though it never renders", async () => {
+    const { apply } = renderDialog(
+      makeChannel({ modelName: "claude-haiku-4-5", maxToolRounds: 25 }),
+    );
+
+    expect(screen.queryByText(/tool round/i)).toBeNull();
+    await save();
+
+    await waitFor(() => expect(apply).toHaveBeenCalledOnce());
+    const input = apply.mock.calls[0][0] as AgentChannelInput;
+    expect(input.runConfig?.maxToolRounds).toBe(25);
+    expect(input.runConfig?.modelName).toBe("claude-haiku-4-5");
+  });
+
+  it("clears run_config entirely when the draft is emptied (empty = inherit)", async () => {
+    const { apply } = renderDialog(
+      makeChannel({ modelName: "claude-haiku-4-5", maxCostUsd: 2 }),
+    );
+
+    fireEvent.click(
+      screen.getByRole("button", { name: "Reset to platform default" }),
+    );
+    fireEvent.change(screen.getByLabelText(/Budget per run/), {
+      target: { value: "" },
+    });
+    await save();
+
+    await waitFor(() => expect(apply).toHaveBeenCalledOnce());
+    const input = apply.mock.calls[0][0] as AgentChannelInput;
+    expect(input.runConfig).toBeUndefined();
+  });
+
+  it("carries an actively enabled thinking mode, and only then", async () => {
+    const { apply } = renderDialog(makeChannel({ modelName: "claude-haiku-4-5" }));
+
+    fireEvent.click(screen.getByRole("button", { name: /Haiku 4\.5/ }));
+    fireEvent.click(await screen.findByRole("switch", { name: "Thinking" }));
+    fireEvent.keyDown(document.activeElement ?? document.body, { key: "Escape" });
+    await save();
+
+    await waitFor(() => expect(apply).toHaveBeenCalledOnce());
+    const input = apply.mock.calls[0][0] as AgentChannelInput;
+    expect(input.runConfig?.thinkingMode).toBe(ThinkingMode.ENABLED);
+    // The untouched tier stays absent — never stamped as an explicit
+    // STANDARD by a save (#357 ledger distinction).
+    expect(input.runConfig?.serviceTier).toBeUndefined();
+  });
+
+  it("round-trips a stored thinking pin into the switch state", async () => {
+    renderDialog(
+      makeChannel({
+        modelName: "claude-haiku-4-5",
+        thinkingMode: ThinkingMode.ENABLED,
+      }),
+    );
+
+    fireEvent.click(screen.getByRole("button", { name: /Haiku 4\.5/ }));
+    const toggle = await screen.findByRole("switch", { name: "Thinking" });
+    expect(toggle.getAttribute("aria-checked")).toBe("true");
+  });
+
+  it("collects a budget without requiring a model pin", async () => {
+    const { apply } = renderDialog(makeChannel());
+
+    fireEvent.change(screen.getByLabelText(/Budget per run/), {
+      target: { value: "1.5" },
+    });
+    await save();
+
+    await waitFor(() => expect(apply).toHaveBeenCalledOnce());
+    const input = apply.mock.calls[0][0] as AgentChannelInput;
+    expect(input.runConfig?.maxCostUsd).toBe(1.5);
+    expect(input.runConfig?.modelName).toBeUndefined();
+  });
+});

package/src/channel/index.ts

@@ -69,6 +69,8 @@ export type { ConnectWhatsAppDialogProps } from "./ConnectWhatsAppDialog.js";
 
 export { ChannelCredentialsDialog } from "./ChannelCredentialsDialog.js";
 export type { ChannelCredentialsDialogProps } from "./ChannelCredentialsDialog.js";
+export { ChannelRunConfigDialog } from "./ChannelRunConfigDialog.js";
+export type { ChannelRunConfigDialogProps } from "./ChannelRunConfigDialog.js";
 
 export { ChannelToolCredentials } from "./ChannelToolCredentials.js";
 export type { ChannelToolCredentialsProps } from "./ChannelToolCredentials.js";

package/src/channel/useSaveAgentChannel.ts

@@ -66,9 +66,11 @@ export function agentChannelToInput(channel: AgentChannel): AgentChannelInput {
           })),
         }
       : {}),
-    // The console does not edit run_config (yet) — it rides through
-    // opaquely so a settings save or pause/resume toggle never wipes an
-    // override set via the CLI or API.
+    // run_config rides through verbatim so a settings save or
+    // pause/resume toggle never wipes an override set elsewhere (the
+    // ChannelRunConfigDialog — the one surface that edits it, #792 —
+    // overrides this copy with its own draft; CLI/API overrides survive
+    // every other save).
     ...(spec?.runConfig
       ? {
           runConfig: {
@@ -76,6 +78,7 @@ export function agentChannelToInput(channel: AgentChannel): AgentChannelInput {
             maxCostUsd: spec.runConfig.maxCostUsd,
             maxToolRounds: spec.runConfig.maxToolRounds,
             serviceTier: spec.runConfig.serviceTier,
+            thinkingMode: spec.runConfig.thinkingMode,
           },
         }
       : {}),

package/src/channel-app/ChannelAppDetailPanel.tsx

@@ -2,7 +2,7 @@
 
 import { type FormEvent, useCallback, useId, useMemo, useState } from "react";
 import { cn } from "@stigmer/theme";
-import { getUserMessage } from "@stigmer/sdk";
+import { getUserMessage, toChannelAppUpdateInput } from "@stigmer/sdk";
 import type { ChannelApp } from "@stigmer/protos/ai/stigmer/agentic/channelapp/v1/api_pb";
 import { useStigmer } from "../hooks.js";
 import { useUpdateChannelApp } from "./useUpdateChannelApp.js";
@@ -229,10 +229,10 @@ function SlackAppDetail({
 
       clearError();
       try {
+        // Full-spec-replace safety: spread the complete mapped input and
+        // override only the slack arm this form owns.
         const updated = await update({
-          name,
-          org: channelApp.metadata?.org ?? "",
-          ...(channelApp.metadata?.slug ? { slug: channelApp.metadata.slug } : {}),
+          ...toChannelAppUpdateInput(channelApp),
           slack: {
             clientId: clientId.trim(),
             // The redaction marker means "keep the stored value" — the
@@ -246,7 +246,7 @@ function SlackAppDetail({
         // error state is managed by useUpdateChannelApp
       }
     },
-    [canSave, clearError, update, name, channelApp.metadata, clientId, clientSecret, signingSecret, onUpdated],
+    [canSave, clearError, update, channelApp, clientId, clientSecret, signingSecret, onUpdated],
   );
 
   return (
@@ -379,10 +379,10 @@ function WhatsAppAppDetail({
 
       clearError();
       try {
+        // Full-spec-replace safety: spread the complete mapped input and
+        // override only the whatsapp arm this form owns.
         const updated = await update({
-          name,
-          org: channelApp.metadata?.org ?? "",
-          ...(channelApp.metadata?.slug ? { slug: channelApp.metadata.slug } : {}),
+          ...toChannelAppUpdateInput(channelApp),
           whatsapp: {
             appId: metaAppId.trim(),
             // The redaction marker means "keep the stored value" — the
@@ -397,7 +397,7 @@ function WhatsAppAppDetail({
         // error state is managed by useUpdateChannelApp
       }
     },
-    [canSave, clearError, update, name, channelApp.metadata, metaAppId, appSecret, accessToken, verifyToken, onUpdated],
+    [canSave, clearError, update, channelApp, metaAppId, appSecret, accessToken, verifyToken, onUpdated],
   );
 
   return (

package/src/channel-app/__tests__/channelAppWhatsApp.test.tsx

@@ -228,6 +228,8 @@ describe("ChannelAppDetailPanel — WhatsApp branch", () => {
 
     await waitFor(() => expect(update).toHaveBeenCalled());
     expect(update).toHaveBeenCalledWith({
+      // The generated mapper carries metadata.id for exact update addressing.
+      id: "chapp_1",
       name: "Acme WhatsApp",
       org: "acme",
       slug: "acme-whatsapp",

package/src/channel-app/__tests__/channelAppWipeSafety.test.tsx

@@ -0,0 +1,87 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { render, screen, fireEvent, waitFor, cleanup } from "@testing-library/react";
+import { create } from "@bufbuild/protobuf";
+import {
+  ChannelAppSchema,
+  type ChannelApp,
+} from "@stigmer/protos/ai/stigmer/agentic/channelapp/v1/api_pb";
+import type { ChannelAppInput } from "@stigmer/sdk";
+import { StigmerContext } from "../../context";
+import { ChannelAppDetailPanel } from "../ChannelAppDetailPanel";
+
+/**
+ * Regression suite for the full-spec-replace wipe bug: both detail forms
+ * must spread `toChannelAppUpdateInput` and override only their provider
+ * arm, so identity fields and any future spec field survive the save.
+ * Secrets follow the redaction contract: the form is seeded with the
+ * server's redaction marker, and sending the marker back means "keep the
+ * stored value" (per-field, verified by the backend's
+ * TestRedactAndEncryptCoverEveryProviderArm).
+ */
+
+const REDACTED = "***REDACTED***";
+
+const SLACK_APP: ChannelApp = create(ChannelAppSchema, {
+  metadata: {
+    id: "chapp_1",
+    name: "Acme Slack",
+    slug: "acme-slack",
+    org: "acme",
+    labels: { team: "support" },
+  },
+  spec: {
+    providerConfig: {
+      case: "slack",
+      value: {
+        clientId: "1234.5678",
+        clientSecret: REDACTED,
+        signingSecret: REDACTED,
+      },
+    },
+  },
+});
+
+function renderPanel(update: ReturnType<typeof vi.fn>) {
+  const client = {
+    baseUrl: "https://api.stigmer.ai",
+    channelapp: { update, delete: vi.fn(async () => ({})) },
+  } as never;
+  return render(
+    <StigmerContext.Provider value={client}>
+      <ChannelAppDetailPanel
+        channelApp={SLACK_APP}
+        consoleOrigin="https://console.acme.example"
+      />
+    </StigmerContext.Provider>,
+  );
+}
+
+afterEach(cleanup);
+
+describe("ChannelAppDetailPanel save payload (slack arm)", () => {
+  it("spreads the complete mapped input and overrides only the slack config", async () => {
+    const update = vi.fn(async (_input: ChannelAppInput) => SLACK_APP);
+    renderPanel(update);
+
+    const clientId = await screen.findByLabelText(/client id/i);
+    fireEvent.change(clientId, { target: { value: "9999.0000" } });
+    fireEvent.click(screen.getByRole("button", { name: /save credentials/i }));
+
+    await waitFor(() => expect(update).toHaveBeenCalledTimes(1));
+    const input = update.mock.calls[0]![0];
+
+    // The edited field, plus per-field keep-markers for untouched secrets.
+    expect(input.slack).toEqual({
+      clientId: "9999.0000",
+      clientSecret: REDACTED,
+      signingSecret: REDACTED,
+    });
+    // Identity and unrendered metadata survive via the mapper spread.
+    expect(input.name).toBe("Acme Slack");
+    expect(input.org).toBe("acme");
+    expect(input.slug).toBe("acme-slack");
+    expect(input.labels).toEqual({ team: "support" });
+    // The other provider arm stays absent — the oneof is preserved.
+    expect(input.whatsapp).toBeUndefined();
+  });
+});

package/src/composer/ComposerToolbar.tsx

@@ -13,6 +13,7 @@ import { ModelSelector } from "../models/ModelSelector.js";
 import { HarnessSelector } from "../models/HarnessSelector.js";
 import type { HarnessOption } from "../models/harness.js";
 import type { ServiceTierOption } from "../models/service-tier.js";
+import type { ThinkingModeOption } from "../models/thinking-mode.js";
 import { InteractionModePicker, type InteractionModeOption } from "./InteractionModePicker.js";
 import {
   PaperclipIcon,
@@ -53,6 +54,10 @@ export interface ComposerToolbarProps {
   readonly serviceTier?: ServiceTierOption;
   /** Enables the fast-tier switch inside the model selector's options area. */
   readonly onServiceTierChange?: (tier: ServiceTierOption) => void;
+  /** Current thinking mode for the selected model (#772). */
+  readonly thinkingMode?: ThinkingModeOption;
+  /** Enables the thinking switch inside the model selector's options area. */
+  readonly onThinkingModeChange?: (mode: ThinkingModeOption) => void;
 
   // -- Right group: Secondary actions (icon-only) ---------------------------
 
@@ -128,6 +133,8 @@ export function ComposerToolbar({
   onModelChange,
   serviceTier,
   onServiceTierChange,
+  thinkingMode,
+  onThinkingModeChange,
 }: ComposerToolbarProps) {
   const showHarnessSeparate = showHarnessSelector && !showModelSelector;
 
@@ -161,6 +168,8 @@ export function ComposerToolbar({
             onHarnessChange={showHarnessSelector ? onHarnessChange : undefined}
             serviceTier={serviceTier}
             onServiceTierChange={onServiceTierChange}
+            thinkingMode={thinkingMode}
+            onThinkingModeChange={onThinkingModeChange}
             disabled={disabled}
           />
         )}

package/src/composer/SessionComposer.tsx

@@ -8,6 +8,7 @@ import { ComposerToolbar } from "./ComposerToolbar.js";
 import { type ConfigureMenuItem } from "./ConfigureMenu.js";
 import type { HarnessOption } from "../models/harness.js";
 import { FAST_SERVICE_TIER, type ServiceTierOption } from "../models/service-tier.js";
+import type { ThinkingModeOption } from "../models/thinking-mode.js";
 import type { InteractionModeOption } from "./InteractionModePicker.js";
 import { parseModelKey } from "../models/registry.js";
 import { useModelRegistry } from "../models/useModelRegistry.js";
@@ -164,6 +165,14 @@ export interface SessionComposerSubmitContext {
    * Pass to execution creation as `execution_config.service_tier`.
    */
   readonly serviceTier?: ServiceTierOption;
+  /**
+   * Thinking mode the user actively selected for this execution
+   * (stigmer/stigmer#772). Only ever `"enabled"` — an untouched mode means
+   * "platform default" and is carried as `undefined`, the same
+   * unspecified-vs-explicit contract as {@link serviceTier}.
+   * Pass to execution creation as `execution_config.thinking_mode`.
+   */
+  readonly thinkingMode?: ThinkingModeOption;
   /**
    * Workspace-relative file paths the user referenced via drag-to-reference.
    *
@@ -663,6 +672,9 @@ const SessionComposerInner = forwardRef<SessionComposerHandle, SessionComposerPr
   // selection below (#663) — state here records the user's intent only.
   const [serviceTier, setServiceTier] = useState<ServiceTierOption>("standard");
 
+  // Thinking mode (#772): the tier's twin, same intent-vs-effective split.
+  const [thinkingMode, setThinkingMode] = useState<ThinkingModeOption>("disabled");
+
   // Active harness mirror: controlled hosts (both viewers) keep the
   // `harness` prop current, but with `showHarnessSelector` the dropdown
   // lives inside ModelSelector and an uncontrolled host would leave the
@@ -837,10 +849,26 @@ const SessionComposerInner = forwardRef<SessionComposerHandle, SessionComposerPr
         ? "fast"
         : "standard";
 
-    return { modelId: effectiveModelId, model: effectiveModel, serviceTier: effectiveServiceTier };
+    // "enabled" rides under the identical rule, keyed on the capability
+    // (cursor-harness models only — v1 has no native thinking mapping, #772).
+    const effectiveThinkingMode: ThinkingModeOption =
+      thinkingMode === "enabled"
+        && effectiveModel !== undefined
+        && effectiveModel.harness === "cursor"
+        && effectiveModel.thinkingCapable === true
+        ? "enabled"
+        : "disabled";
+
+    return {
+      modelId: effectiveModelId,
+      model: effectiveModel,
+      serviceTier: effectiveServiceTier,
+      thinkingMode: effectiveThinkingMode,
+    };
   }, [
     modelId,
     serviceTier,
+    thinkingMode,
     showModelSelector,
     isRegistryLoading,
     registryGetByKey,
@@ -1054,15 +1082,19 @@ const SessionComposerInner = forwardRef<SessionComposerHandle, SessionComposerPr
       // explicit distinction is load-bearing telemetry (#357).
       const submitServiceTier =
         effective.serviceTier === "fast" ? effective.serviceTier : undefined;
+      // The tier's #772 twin: only an in-effect "enabled" is carried.
+      const submitThinkingMode =
+        effective.thinkingMode === "enabled" ? effective.thinkingMode : undefined;
 
       const context: SessionComposerSubmitContext | undefined =
         hasEnv || hasAttachments || effectiveMode || hasFileRefs || buildFromPlan
-        || submitServiceTier
+        || submitServiceTier || submitThinkingMode
           ? {
               runtimeEnv: hasEnv ? env : undefined,
               attachments: hasAttachments ? attachmentInputs : undefined,
               interactionMode: effectiveMode,
               serviceTier: submitServiceTier,
+              thinkingMode: submitThinkingMode,
               workspaceFileRefs: hasFileRefs ? [...fileRefs.refs] : undefined,
               buildFromPlan,
             }
@@ -1894,6 +1926,8 @@ const SessionComposerInner = forwardRef<SessionComposerHandle, SessionComposerPr
           onModelChange={handleModelChange}
           serviceTier={serviceTier}
           onServiceTierChange={setServiceTier}
+          thinkingMode={thinkingMode}
+          onThinkingModeChange={setThinkingMode}
         />
       </div>
     </div>