@stigmer/react 3.12.5 → 3.12.6

package/src/identity-account/AccountPreferencesPanel.tsx

@@ -1,6 +1,14 @@
 "use client";
 
-import { type FormEvent, useCallback, useEffect, useId, useMemo, useState } from "react";
+import {
+  type FormEvent,
+  type ReactNode,
+  useCallback,
+  useEffect,
+  useId,
+  useMemo,
+  useState,
+} from "react";
 import { cn } from "@stigmer/theme";
 import { getUserMessage, toIdentityAccountUpdateInput } from "@stigmer/sdk";
 import type { IdentityAccount } from "@stigmer/protos/ai/stigmer/iam/identityaccount/v1/api_pb";
@@ -23,7 +31,8 @@ export interface AccountPreferencesPanelProps {
 
 /**
  * Self-contained editor for the current user's declared preferences
- * (`IdentityAccountSpec.preferences.standing_context`).
+ * (`IdentityAccountSpec.preferences`): standing context plus the
+ * execution defaults (default harness and per-harness default models).
  *
  * The declared text is snapshotted into the user's own eligible agent
  * executions and delivered to the agent as background context.
@@ -267,31 +276,60 @@ function AccountPreferencesForm({
           </p>
         </div>
 
-        <DefaultHarnessRadioGroup
-          baseId={baseId}
-          value={defaultHarness}
-          onChange={setDefaultHarness}
-          disabled={isUpdating}
-        />
-
-        <div className="stg:grid stg:gap-3 stg:sm:grid-cols-2">
-          <DefaultModelSelect
-            id={`${baseId}-default-native-model`}
-            harness="native"
-            label={`Default model — ${HARNESS_META.native.label}`}
-            value={defaultNativeModel}
-            onChange={setDefaultNativeModel}
+        <fieldset className="stg:space-y-2" disabled={isUpdating}>
+          <legend className="stg:text-xs stg:font-medium stg:text-foreground stg:mb-1">
+            Default harness
+          </legend>
+          <HarnessOptionRow
+            radioName={`${baseId}-default-harness`}
+            value=""
+            label="Platform default"
+            description="Stigmer picks the harness for new sessions."
+            checked={defaultHarness === ""}
+            onSelect={setDefaultHarness}
             disabled={isUpdating}
           />
-          <DefaultModelSelect
-            id={`${baseId}-default-cursor-model`}
-            harness="cursor"
-            label={`Default model — ${HARNESS_META.cursor.label}`}
-            value={defaultCursorModel}
-            onChange={setDefaultCursorModel}
+          <HarnessOptionRow
+            radioName={`${baseId}-default-harness`}
+            value="native"
+            label={HARNESS_META.native.label}
+            description={HARNESS_META.native.description}
+            checked={defaultHarness === "native"}
+            onSelect={setDefaultHarness}
             disabled={isUpdating}
-          />
-        </div>
+          >
+            <DefaultModelSelect
+              id={`${baseId}-default-native-model`}
+              harness="native"
+              label="Default model"
+              value={defaultNativeModel}
+              onChange={setDefaultNativeModel}
+              disabled={isUpdating}
+            />
+          </HarnessOptionRow>
+          <HarnessOptionRow
+            radioName={`${baseId}-default-harness`}
+            value="cursor"
+            label={HARNESS_META.cursor.label}
+            description={HARNESS_META.cursor.description}
+            checked={defaultHarness === "cursor"}
+            onSelect={setDefaultHarness}
+            disabled={isUpdating}
+          >
+            <DefaultModelSelect
+              id={`${baseId}-default-cursor-model`}
+              harness="cursor"
+              label="Default model"
+              value={defaultCursorModel}
+              onChange={setDefaultCursorModel}
+              disabled={isUpdating}
+            />
+          </HarnessOptionRow>
+          <p className="stg:text-[0.65rem] stg:text-muted-foreground">
+            Each harness&apos;s default model applies whenever a session runs
+            on that harness — even when it isn&apos;t your default.
+          </p>
+        </fieldset>
       </div>
 
       {updateError && (
@@ -332,60 +370,104 @@ function AccountPreferencesForm({
 }
 
 /**
- * Only harnesses with a shipped runtime are offerable as a default — must
- * stay in lockstep with the proto's `default_harness` in-list validation.
- */
-const OFFERABLE_HARNESSES: readonly HarnessOption[] = ["native", "cursor"];
-
-/**
- * Default-harness choice: Platform default plus each shipped harness.
- * A mutually exclusive, always-visible set — radio group, not a select.
+ * One selectable default-harness choice, presented as a bordered row
+ * (the `VisibilityOptionRow` presentation shape): radio + label +
+ * one-line description, with the harness's own controls nested below.
+ *
+ * The rows for shipped harnesses embed that harness's default-model
+ * select as `children` — the pairing IS the information architecture:
+ * a harness and its model default belong to each other, and each model
+ * default applies whenever a session runs on that harness, independent
+ * of which harness is the default. The non-selected harness's select
+ * therefore stays interactive (visually secondary, never disabled).
+ *
+ * The nested controls live OUTSIDE the radio's `<label>` on purpose:
+ * a `<select>` inside the label would toggle the radio on every
+ * interaction with it.
+ *
+ * The shipped-harness rows must stay in lockstep with the proto's
+ * `default_harness` in-list validation (`["native", "cursor"]`) — each
+ * shipped harness binds to its own proto model field, so a new harness
+ * adds a field, a row, and a validation entry together.
  */
-function DefaultHarnessRadioGroup({
-  baseId,
+function HarnessOptionRow({
+  radioName,
   value,
-  onChange,
+  label,
+  description,
+  checked,
+  onSelect,
   disabled,
+  children,
 }: {
-  readonly baseId: string;
+  readonly radioName: string;
   readonly value: string;
-  readonly onChange: (value: string) => void;
+  readonly label: string;
+  readonly description: string;
+  readonly checked: boolean;
+  readonly onSelect: (value: string) => void;
   readonly disabled: boolean;
+  readonly children?: ReactNode;
 }) {
-  const name = `${baseId}-default-harness`;
-  const options: readonly { value: string; label: string }[] = [
-    { value: "", label: "Platform default" },
-    ...OFFERABLE_HARNESSES.map((h) => ({ value: h, label: HARNESS_META[h].label })),
-  ];
+  // The radio's accessible name is the title alone (aria-labelledby), with
+  // the description attached as aria-describedby — the wrapping label keeps
+  // the whole text block clickable without bloating the announced name.
+  const titleId = `${radioName}-${value || "platform"}-title`;
+  const descriptionId = `${radioName}-${value || "platform"}-description`;
 
   return (
-    <fieldset className="stg:space-y-1" disabled={disabled}>
-      <legend className="stg:text-xs stg:font-medium stg:text-foreground">
-        Default harness
-      </legend>
-      <div className="stg:flex stg:flex-wrap stg:gap-x-4 stg:gap-y-1">
-        {options.map((option) => (
-          <label
-            key={option.value}
-            className={cn(
-              "stg:inline-flex stg:cursor-pointer stg:items-center stg:gap-1.5 stg:text-xs stg:text-foreground",
-              disabled && "stg:cursor-default stg:opacity-50",
-            )}
+    <div
+      className={cn(
+        "stg:rounded-md stg:border stg:px-3 stg:py-2.5 stg:transition-colors",
+        checked
+          ? "stg:border-primary stg:bg-accent"
+          : "stg:border-input stg:hover:bg-accent-hover",
+        disabled && "stg:opacity-50",
+      )}
+    >
+      <label
+        className={cn(
+          "stg:flex stg:cursor-pointer stg:items-start stg:gap-2",
+          disabled && "stg:cursor-default",
+        )}
+      >
+        <input
+          type="radio"
+          name={radioName}
+          value={value}
+          checked={checked}
+          onChange={() => onSelect(value)}
+          disabled={disabled}
+          aria-labelledby={titleId}
+          aria-describedby={descriptionId}
+          className="stg:mt-0.5 stg:accent-primary stg:focus-visible:outline-none stg:focus-visible:ring-1 stg:focus-visible:ring-ring"
+        />
+        <span className="stg:min-w-0 stg:flex-1">
+          <span
+            id={titleId}
+            className="stg:block stg:text-xs stg:font-medium stg:text-foreground"
           >
-            <input
-              type="radio"
-              name={name}
-              value={option.value}
-              checked={value === option.value}
-              onChange={() => onChange(option.value)}
-              disabled={disabled}
-              className="stg:accent-primary stg:focus-visible:outline-none stg:focus-visible:ring-1 stg:focus-visible:ring-ring"
-            />
-            {option.label}
-          </label>
-        ))}
-      </div>
-    </fieldset>
+            {label}
+          </span>
+          <span
+            id={descriptionId}
+            className="stg:block stg:text-[0.65rem] stg:leading-snug stg:text-muted-foreground"
+          >
+            {description}
+          </span>
+        </span>
+      </label>
+      {children && (
+        <div
+          className={cn(
+            "stg:mt-2 stg:pl-6 stg:transition-opacity",
+            !checked && "stg:opacity-70",
+          )}
+        >
+          {children}
+        </div>
+      )}
+    </div>
   );
 }
 
@@ -426,6 +508,10 @@ function DefaultModelSelect({
         id={id}
         value={value}
         onChange={(e) => onChange(e.target.value)}
+        // Both harness rows show the same visible label; the accessible
+        // name stays unique per control by qualifying it with the harness
+        // (WCAG label-in-name: the visible text remains a prefix).
+        aria-label={`${label} — ${HARNESS_META[harness].label}`}
         disabled={disabled || isLoading}
         className={cn(
           "stg:w-full stg:rounded-md stg:border stg:border-input stg:bg-background stg:px-2.5 stg:py-1.5 stg:text-xs stg:text-foreground",

package/src/identity-account/__tests__/AccountPreferencesPanel.test.tsx

@@ -107,7 +107,10 @@ describe("AccountPreferencesPanel", () => {
     // Fields this form never renders must round-trip untouched.
     expect(input.idpId).toBe("auth0|abc");
     expect(input.email).toBe("ada@acme.example");
-    // The update pipeline addresses the resource by org + slug.
+    // The update pipeline addresses id-first — the id is REQUIRED here:
+    // identity accounts are org-less, so the org+slug fallback can never
+    // match one (the save-path bug this pin guards against).
+    expect(input.id).toBe("ia-1");
     expect(input.org).toBe("acme");
     expect(input.slug).toBe("ada");
   });
@@ -149,7 +152,7 @@ describe("AccountPreferencesPanel", () => {
       },
     });
 
-    it("renders the harness radio group and registry-fed model selects", async () => {
+    it("renders the harness option rows and registry-fed model selects", async () => {
       renderPanel(createMockStigmer());
       await findSyncedField("Keep answers terse.");
 
@@ -160,6 +163,37 @@ describe("AccountPreferencesPanel", () => {
       expect(screen.getByLabelText("Default model — Cursor")).toBeTruthy();
     });
 
+    it("pairs each harness row with its description (the row IS the context)", async () => {
+      renderPanel(createMockStigmer());
+      await findSyncedField("Keep answers terse.");
+
+      // Row subtitles come from HARNESS_META — the single source of harness
+      // display copy — plus the platform-default explainer.
+      expect(screen.getByText("Stigmer picks the harness for new sessions.")).toBeTruthy();
+      expect(screen.getByText("Stigmer's native agent runtime")).toBeTruthy();
+      expect(screen.getByText("Cursor IDE agent with codebase indexing")).toBeTruthy();
+      // The radios' accessible descriptions are wired via aria-describedby.
+      expect(
+        screen.getByRole("radio", { name: "Stigmer" }).getAttribute("aria-describedby"),
+      ).toBeTruthy();
+    });
+
+    it("keeps the non-selected harness's model select editable (per-harness models are independent of the default harness)", async () => {
+      renderPanel(createMockStigmer({ whoAmI: vi.fn(async () => ACCOUNT_WITH_DEFAULTS) }));
+      await findSyncedField("Keep answers terse.");
+
+      // Default harness is cursor, yet the Stigmer model stays settable:
+      // the launcher applies the model of the session's ACTIVE harness, so
+      // hiding or disabling it would remove a real capability.
+      await waitFor(() => {
+        expect(screen.getByRole("radio", { name: "Cursor" })).toHaveProperty("checked", true);
+      });
+      const nativeSelect = screen.getByLabelText("Default model — Stigmer") as HTMLSelectElement;
+      expect(nativeSelect.disabled).toBe(false);
+      fireEvent.change(nativeSelect, { target: { value: "claude-sonnet-4.6" } });
+      expect(nativeSelect.value).toBe("claude-sonnet-4.6");
+    });
+
     it("reflects the saved defaults in the form", async () => {
       renderPanel(createMockStigmer({ whoAmI: vi.fn(async () => ACCOUNT_WITH_DEFAULTS) }));
       await findSyncedField("Keep answers terse.");

package/src/identity-provider/IdentityProviderDetailPanel.tsx

@@ -3,7 +3,7 @@
 import { type FormEvent, useCallback, useId, useRef, useState } from "react";
 import { cn } from "@stigmer/theme";
 import { UNSTYLED_FIELDSET } from "../internal/element-resets.js";
-import { getUserMessage } from "@stigmer/sdk";
+import { getUserMessage, toIdentityProviderUpdateInput } from "@stigmer/sdk";
 import type { IdentityProvider } from "@stigmer/protos/ai/stigmer/iam/identityprovider/v1/api_pb";
 import { IamRole } from "@stigmer/protos/ai/stigmer/iam/v1/enum_pb";
 import { timestampDate, type Timestamp } from "@bufbuild/protobuf/wkt";
@@ -132,10 +132,13 @@ export function IdentityProviderDetailPanel({
       e.preventDefault();
       clearError();
       try {
+        // Full-spec-replace safety: spread the complete mapped input and
+        // override only the edited fields, so unlisted spec fields (e.g.
+        // rate_limit_budget) survive the save. Fields the form clears
+        // (SSO providers have no JIT settings) are set to undefined
+        // explicitly — omitting them would carry the stale mapped value.
         const updated = await update({
-          name: meta?.name ?? "",
-          slug: meta?.slug,
-          org: meta?.org ?? "",
+          ...toIdentityProviderUpdateInput(identityProvider),
           displayName: displayName.trim(),
           jwksUri: jwksUri.trim(),
           allowedIssuers: issuers
@@ -146,16 +149,16 @@ export function IdentityProviderDetailPanel({
           userinfoEndpoint: userinfoEndpoint.trim() || undefined,
           isSsoProvider: isSso,
           oidcClientId: isSso ? oidcClientId.trim() : undefined,
-          ...(!isSso && {
-            autoProvisionAccounts: autoProvision,
-            autoGrantOnOrg: autoGrant,
-            ...(autoGrant && autoGrantRole !== IamRole.iam_role_unspecified && {
-              autoGrantRole,
-            }),
-            ...(autoGrant && tenantOrgClaim.trim() && {
-              tenantOrgClaim: tenantOrgClaim.trim(),
-            }),
-          }),
+          autoProvisionAccounts: !isSso && autoProvision ? true : undefined,
+          autoGrantOnOrg: !isSso && autoGrant ? true : undefined,
+          autoGrantRole:
+            !isSso && autoGrant && autoGrantRole !== IamRole.iam_role_unspecified
+              ? autoGrantRole
+              : undefined,
+          tenantOrgClaim:
+            !isSso && autoGrant && tenantOrgClaim.trim()
+              ? tenantOrgClaim.trim()
+              : undefined,
         });
         setMode("view");
         onUpdated?.(updated);
@@ -164,7 +167,7 @@ export function IdentityProviderDetailPanel({
       }
     },
     [
-      meta, displayName, jwksUri, issuers, audience,
+      identityProvider, displayName, jwksUri, issuers, audience,
       userinfoEndpoint, isSso, oidcClientId, autoProvision, autoGrant,
       autoGrantRole, tenantOrgClaim, update, clearError, onUpdated,
     ],

package/src/identity-provider/__tests__/IdentityProviderDetailPanel.test.tsx

@@ -0,0 +1,80 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { create } from "@bufbuild/protobuf";
+import {
+  IdentityProviderSchema,
+  type IdentityProvider,
+} from "@stigmer/protos/ai/stigmer/iam/identityprovider/v1/api_pb";
+import { IamRole } from "@stigmer/protos/ai/stigmer/iam/v1/enum_pb";
+import type { IdentityProviderInput } from "@stigmer/sdk";
+import { StigmerContext } from "../../context";
+import { IdentityProviderDetailPanel } from "../IdentityProviderDetailPanel";
+
+/**
+ * Regression suite for the full-spec-replace wipe bug: before the
+ * generated-mapper migration, this panel hand-built its update input and
+ * NEVER sent `rate_limit_budget` — editing any IdP field zeroed the
+ * provider's rate limit. The panel must spread
+ * `toIdentityProviderUpdateInput` and override only what it edits.
+ */
+
+const IDP: IdentityProvider = create(IdentityProviderSchema, {
+  metadata: {
+    id: "idp-1",
+    name: "Acme Okta",
+    slug: "acme-okta",
+    org: "acme",
+  },
+  spec: {
+    displayName: "Acme Okta",
+    jwksUri: "https://acme.okta.example/jwks",
+    allowedIssuers: ["https://acme.okta.example"],
+    expectedAudience: "stigmer",
+    rateLimitBudget: 120,
+    isSsoProvider: false,
+    autoProvisionAccounts: true,
+    autoGrantOnOrg: true,
+    autoGrantRole: IamRole.admin,
+    tenantOrgClaim: "org_slug",
+  },
+});
+
+function renderPanel(update: ReturnType<typeof vi.fn>) {
+  const client = {
+    identityProvider: { update },
+  } as never;
+  return render(
+    <StigmerContext.Provider value={client}>
+      <IdentityProviderDetailPanel identityProvider={IDP} />
+    </StigmerContext.Provider>,
+  );
+}
+
+afterEach(cleanup);
+
+describe("IdentityProviderDetailPanel save payload", () => {
+  it("round-trips rate_limit_budget on a display-name edit (the wipe bug)", async () => {
+    const update = vi.fn(async (_input: IdentityProviderInput) => IDP);
+    renderPanel(update);
+
+    fireEvent.click(screen.getByRole("button", { name: "Edit" }));
+    const displayName = await screen.findByLabelText("Display name");
+    fireEvent.change(displayName, { target: { value: "Acme Okta (renamed)" } });
+    fireEvent.click(screen.getByRole("button", { name: "Save changes" }));
+
+    await waitFor(() => expect(update).toHaveBeenCalledTimes(1));
+    const input = update.mock.calls[0]![0];
+
+    // The wipe-bug guard: the form does not render the rate limit, yet it
+    // must survive the save.
+    expect(input.rateLimitBudget).toBe(120);
+    // The edited field.
+    expect(input.displayName).toBe("Acme Okta (renamed)");
+    // JIT settings round-trip from the edit state.
+    expect(input.autoGrantRole).toBe(IamRole.admin);
+    expect(input.tenantOrgClaim).toBe("org_slug");
+    // Addressing fields.
+    expect(input.org).toBe("acme");
+    expect(input.slug).toBe("acme-okta");
+  });
+});

package/src/index.ts

@@ -567,7 +567,6 @@ export {
   McpToolSelector,
   useCreateMcpServer,
   useUpdateMcpServer,
-  mcpServerToInput,
   toServerKey,
   IdentityTransportStep,
   EnvironmentAuthStep,
@@ -696,7 +695,6 @@ export {
   useDefaultAgent,
   useCreateAgent,
   useUpdateAgent,
-  agentToInput,
   AgentCreationWizard,
 } from "./agent/index.js";
 export type {
@@ -1311,6 +1309,7 @@ export {
   ConnectSlackDialog,
   ConnectWhatsAppDialog,
   ChannelCredentialsDialog,
+  ChannelRunConfigDialog,
   ChannelToolCredentials,
   ChannelConversationsDialog,
   ChannelTemplatesDialog,
@@ -1334,6 +1333,7 @@ export type {
   ConnectSlackDialogProps,
   ConnectWhatsAppDialogProps,
   ChannelCredentialsDialogProps,
+  ChannelRunConfigDialogProps,
   ChannelToolCredentialsProps,
   ChannelConversationsDialogProps,
   ChannelTemplatesDialogProps,

package/src/mcp-server/McpServerDetailView.tsx

@@ -16,7 +16,7 @@ import type { EnvVarDeclaration } from "@stigmer/protos/ai/stigmer/agentic/envir
 import { useMcpServer } from "./useMcpServer.js";
 import type { UseMcpServerReturn } from "./useMcpServer.js";
 import { useUpdateMcpServer } from "./useUpdateMcpServer.js";
-import { mcpServerToInput } from "./internal/mcpServerToInput.js";
+import { toMcpServerUpdateInput } from "@stigmer/sdk";
 import { useMcpServerConnect } from "./useMcpServerConnect.js";
 import { useMcpServerCredentials } from "./useMcpServerCredentials.js";
 import {
@@ -214,7 +214,7 @@ export function McpServerDetailView({
       value: import("@stigmer/sdk").McpServerInput[K],
     ): Promise<boolean> => {
       if (!mcpServer) return false;
-      const input = mcpServerToInput(mcpServer);
+      const input = toMcpServerUpdateInput(mcpServer);
       (input as unknown as Record<string, unknown>)[field] = value;
       try {
         const updated = await updateMcpServer(input);

package/src/mcp-server/index.ts

@@ -95,8 +95,6 @@ export type { UseCreateMcpServerReturn } from "./useCreateMcpServer.js";
 export { useUpdateMcpServer } from "./useUpdateMcpServer.js";
 export type { UseUpdateMcpServerReturn } from "./useUpdateMcpServer.js";
 
-export { mcpServerToInput } from "./internal/mcpServerToInput.js";
-
 export { McpServerCreationWizard } from "./McpServerCreationWizard.js";
 export type {
   McpServerCreationWizardProps,

package/src/mcp-server/internal/definitionDrift.ts

@@ -1,6 +1,5 @@
 import type { McpServer } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/api_pb";
-import type { McpServerInput } from "@stigmer/sdk";
-import { mcpServerToInput } from "./mcpServerToInput.js";
+import { toMcpServerUpdateInput, type McpServerInput } from "@stigmer/sdk";
 
 /**
  * Connection-defining field groups a marketplace definition can drift on.
@@ -24,9 +23,9 @@ export type DriftFieldId =
 
 /**
  * Deep equality over the plain-object projections produced by
- * `mcpServerToInput`. Key order is irrelevant (proto map iteration order
- * is not canonical); `undefined` values and absent keys are equivalent
- * (the conversion uses `undefined` for proto defaults).
+ * `toMcpServerUpdateInput`. Key order is irrelevant (proto map iteration
+ * order is not canonical); `undefined` values and absent keys are
+ * equivalent (the conversion uses `undefined` for proto defaults).
  */
 function deepEqual(a: unknown, b: unknown): boolean {
   if (Object.is(a, b)) return true;
@@ -72,17 +71,18 @@ function functionalEnvShape(env: McpServerInput["env"]) {
  * mirrors and reports which connection-defining field groups differ, or
  * `null` when the connection-defining configuration matches.
  *
- * The comparison runs on `mcpServerToInput` projections rather than raw
- * protos: that conversion is the SDK's canonical read-modify-write lens,
- * and its exhaustiveness is fence-tested — so a new spec field cannot
- * silently bypass this comparison either.
+ * The comparison runs on `toMcpServerUpdateInput` projections rather than
+ * raw protos: that generated mapper is the SDK's canonical
+ * read-modify-write lens, and its completeness is guaranteed by codegen
+ * plus the SDK's schema-tripwire fixture suite — so a new spec field
+ * cannot silently bypass this comparison either.
  */
 export function computeDefinitionDrift(
   current: McpServer,
   template: McpServer,
 ): readonly DriftFieldId[] | null {
-  const cur = mcpServerToInput(current);
-  const tpl = mcpServerToInput(template);
+  const cur = toMcpServerUpdateInput(current);
+  const tpl = toMcpServerUpdateInput(template);
 
   const changed: DriftFieldId[] = [];
 
@@ -128,21 +128,22 @@ export function computeDefinitionDrift(
  *
  * Definition fields — transport, env declarations, auth, and the cosmetic
  * description/icon/tags/repository metadata — come from the template.
- * The user's own choices survive: identity (name/org/slug/labels), tool
- * enablement, and pinned approval policies. Visibility is not part of the
- * input contract at all (the backend preserves it on update;
- * `updateVisibility` is its dedicated write path).
+ * The user's own choices survive: identity (name/org/slug/labels/
+ * visibility — the backend ignores visibility on update anyway;
+ * `updateVisibility` is its dedicated write path), tool enablement, and
+ * pinned approval policies.
  *
- * Built by merging two `mcpServerToInput` projections, so the preserved
- * set is the explicit override list below and nothing can be lost in
- * translation (the conversion is fence-tested exhaustive).
+ * Built by merging two `toMcpServerUpdateInput` projections, so the
+ * preserved set is the explicit override list below and nothing can be
+ * lost in translation (the mapper is generated complete and guarded by
+ * the SDK's schema-tripwire fixture suite).
  */
 export function buildRefreshInput(
   current: McpServer,
   template: McpServer,
 ): McpServerInput {
-  const cur = mcpServerToInput(current);
-  const tpl = mcpServerToInput(template);
+  const cur = toMcpServerUpdateInput(current);
+  const tpl = toMcpServerUpdateInput(template);
 
   return {
     ...tpl,
@@ -151,6 +152,7 @@ export function buildRefreshInput(
     org: cur.org,
     slug: cur.slug,
     labels: cur.labels,
+    visibility: cur.visibility,
     // User policy: never reset by a definition refresh.
     defaultEnabledTools: cur.defaultEnabledTools,
     pinnedToolApprovals: cur.pinnedToolApprovals,

package/src/mcp-server/useUpdateMcpServer.ts

@@ -23,9 +23,9 @@ export interface UseUpdateMcpServerReturn {
  *
  * Wraps `stigmer.mcpServer.update(input)` with loading and error state.
  * The caller must provide a **complete** `McpServerInput` — the backend
- * performs full spec replacement. Use `mcpServerToInput()` to reconstruct
- * the input from a fetched server, modify the desired field, and pass
- * the result here.
+ * performs full spec replacement. Use `toMcpServerUpdateInput()` (from
+ * `@stigmer/sdk`) to reconstruct the input from a fetched server, modify
+ * the desired field, and pass the result here.
  */
 export function useUpdateMcpServer(): UseUpdateMcpServerReturn {
   const stigmer = useStigmer();