@jini-ai/ui 0.5.4 → 0.5.6

package/dist/features/execution/react/hooks/useLocalCliAgentCard.js

@@ -22,42 +22,8 @@ export function useLocalCliAgentCard({ agent, config, agentTest, cliEnvFields, o
         explicitCustomMode,
         onReasoningChange: (next) => onReasoningChange(agent.id, next),
     });
-    // `modelsSource` is optional in the contract, so an absent value means the
-    // host did not say where the list came from — NOT that it came from a
-    // built-in fallback. Defaulting to 'fallback' rendered "Built-in list" over
-    // a list that may well be live, and told the operator to Rescan to fix a
-    // problem they do not have. Unknown provenance shows no badge and no claim.
-    const source = agent.modelsSource;
-    const sourceLabel = source === 'live' ? t('Live from CLI') : source === 'fallback' ? t('Built-in list') : '';
-    const sourceHint = source === 'live'
-        ? t("Model list comes from this CLI. Default uses the CLI's own config.")
-        : source === 'fallback'
-            ? t('Showing built-in defaults. Click Rescan to pull live models from the CLI.')
-            : '';
-    // The test result belongs to whichever agent was probed, so a stale verdict
-    // from a previously-tested CLI never renders under this one.
-    const testing = agentTest.status === 'testing' && agentTest.agentId === agent.id;
-    const result = (agentTest.status === 'ok' || agentTest.status === 'error') && agentTest.agentId === agent.id
-        ? agentTest
-        : null;
-    // The "use the binary that actually ran" / "clear the override" repair
-    // affordance — only meaningful when a successful test silently fell back
-    // off a configured override, AND this agent's catalog names which field
-    // that override lives in. See `agentExecutableRepairState`'s doc.
-    //
-    // `AgentTestState`'s 'ok' variant spells success as `status: 'ok'`, not an
-    // `ok: true` field — `agentExecutableRepairState` takes the latter (it
-    // mirrors `ExecutionPort.testAgent`'s raw resolved shape, one layer below
-    // this state union), so the two must be translated explicitly here rather
-    // than passing `result` straight through.
-    const repair = result?.status === 'ok'
-        ? agentExecutableRepairState({
-            ok: true,
-            usedExecutableSource: result.usedExecutableSource,
-            detectedExecutablePath: result.detectedExecutablePath,
-        })
-        : null;
-    const repairField = repair ? binPathEnvField(cliEnvFields, agent.id) : null;
+    const { source, sourceLabel, sourceHint } = modelSourcePresentation({ source: agent.modelsSource, t });
+    const { testing, result, repair, repairField } = agentTestPresentation({ agent, agentTest, cliEnvFields });
     const openUrl = (url) => {
         if (!url)
             return;
@@ -107,4 +73,56 @@ export function useLocalCliAgentCard({ agent, config, agentTest, cliEnvFields, o
         selectReasoning,
     };
 }
+/** Model-list provenance claims, translated only when the host supplied a source. */
+function modelSourcePresentation({ source, t }, _options = {}) {
+    // `modelsSource` is optional in the contract, so an absent value means the
+    // host did not say where the list came from — NOT that it came from a
+    // built-in fallback. Defaulting to 'fallback' rendered "Built-in list" over
+    // a list that may well be live, and told the operator to Rescan to fix a
+    // problem they do not have. Unknown provenance shows no badge and no claim.
+    switch (source) {
+        case 'live':
+            return {
+                source,
+                sourceLabel: t('Live from CLI'),
+                sourceHint: t("Model list comes from this CLI. Default uses the CLI's own config."),
+            };
+        case 'fallback':
+            return {
+                source,
+                sourceLabel: t('Built-in list'),
+                sourceHint: t('Showing built-in defaults. Click Rescan to pull live models from the CLI.'),
+            };
+        default:
+            return { source, sourceLabel: '', sourceHint: '' };
+    }
+}
+/** Scope probe evidence and its executable repair affordance to the card being rendered. */
+function agentTestPresentation({ agent, agentTest, cliEnvFields }, _options = {}) {
+    // The test result belongs to whichever agent was probed, so a stale verdict
+    // from a previously-tested CLI never renders under this one.
+    const testing = agentTest.status === 'testing' && agentTest.agentId === agent.id;
+    const result = (agentTest.status === 'ok' || agentTest.status === 'error') && agentTest.agentId === agent.id
+        ? agentTest
+        : null;
+    // The "use the binary that actually ran" / "clear the override" repair
+    // affordance — only meaningful when a successful test silently fell back
+    // off a configured override, AND this agent's catalog names which field
+    // that override lives in. See `agentExecutableRepairState`'s doc.
+    //
+    // `AgentTestState`'s 'ok' variant spells success as `status: 'ok'`, not an
+    // `ok: true` field — `agentExecutableRepairState` takes the latter (it
+    // mirrors `ExecutionPort.testAgent`'s raw resolved shape, one layer below
+    // this state union), so the two must be translated explicitly here rather
+    // than passing `result` straight through.
+    const repair = result?.status === 'ok'
+        ? agentExecutableRepairState({
+            ok: true,
+            usedExecutableSource: result.usedExecutableSource,
+            detectedExecutablePath: result.detectedExecutablePath,
+        })
+        : null;
+    const repairField = repair ? binPathEnvField(cliEnvFields, agent.id) : null;
+    return { testing, result, repair, repairField };
+}
 //# sourceMappingURL=useLocalCliAgentCard.js.map

package/dist/features/execution/react/hooks/useReasoningControl.d.ts

@@ -54,7 +54,7 @@ export interface UseReasoningControlResult {
     knownModelIds: readonly string[];
     /** Whether the custom model input is currently active. */
     customActive: boolean;
-    /** Options for the model select: base models for suffix agents, or raw models list. */
+    /** Options for the model select: base models for suffix agents, or deduped catalog rows. */
     modelChoices: readonly AgentModelOption[];
     /** Selected value for the model select element. */
     selectValue: string;

package/dist/features/execution/react/hooks/useReasoningControl.js

@@ -1,102 +1,37 @@
 import { useCallback, useEffect } from 'react';
 import { CUSTOM_MODEL_SENTINEL } from '../../constants.js';
-import { modelIdForReasoningLevel, reasoningModelGroupFor, reasoningModelGroups, selectedAgentModel, selectedAgentReasoning, shouldShowCustomModelInput, splitReasoningModelId, } from '../../rules.js';
+import { modelIdForReasoningLevel, pickerModelOptions, reasoningModelGroupFor, reasoningModelGroups, selectedAgentModel, selectedAgentReasoning, shouldShowCustomModelInput, splitReasoningModelId, } from '../../rules.js';
 export function useReasoningControl(optionsOrAgent, maybeConfig, maybeExplicitCustomMode) {
-    const { agent, config, explicitCustomMode = false, onReasoningChange } = 'agent' in optionsOrAgent && 'config' in optionsOrAgent
-        ? optionsOrAgent
-        : {
-            agent: optionsOrAgent,
-            config: maybeConfig,
-            explicitCustomMode: maybeExplicitCustomMode ?? false,
-        };
+    const { agent, config, explicitCustomMode = false, onReasoningChange } = reasoningControlOptions(optionsOrAgent, maybeConfig, maybeExplicitCustomMode);
     const models = agent.models ?? [];
     const hasModels = models.length > 0;
     const resolvedModel = selectedAgentModel(config, agent);
     const rawModel = config.modelByAgentId?.[agent.id] ?? '';
-    // Two ways an agent can expose a reasoning-effort axis, and the card branches on the DECLARATION
-    // rather than on the agent's id — adding a third runtime with either shape is a def change, not
-    // an edit here.
-    //
-    //   `reasoningOptions`     — one flat vocabulary that travels to the CLI as its own flag
-    //                            (`claude --effort high`, codex's `-c model_reasoning_effort=...`).
-    //                            The choice is its own persisted value; `onReasoningChange` owns it.
-    //   `reasoningInModelId`   — no effort flag exists; the level is a suffix on the model id itself
-    //                            (antigravity's `gemini-3.1-pro-high`). The choice IS the model, so
-    //                            it goes through `onModelChange`, and the available levels are
-    //                            derived PER BASE MODEL from the agent's own catalog — they are not
-    //                            uniform (`gemini-3.1-pro` has no `-medium`, and `agy --model`
-    //                            rejects one), so a fixed dropdown would offer ids the CLI refuses.
-    const suffixLevels = agent.reasoningInModelId?.levels ?? [];
-    const suffixLevelIds = suffixLevels.map((level) => level.id);
-    const modelGroups = suffixLevels.length > 0 ? reasoningModelGroups(models, suffixLevels) : null;
-    const activeGroup = modelGroups ? reasoningModelGroupFor(modelGroups, resolvedModel, suffixLevelIds) : null;
-    const activeLevel = modelGroups ? splitReasoningModelId(resolvedModel, suffixLevelIds).level : null;
+    const { suffixLevels, suffixLevelIds, modelGroups, activeGroup, activeLevel } = suffixReasoning({ agent, models, resolvedModel });
     const flatReasoningOptions = agent.reasoningOptions ?? [];
-    // Per-model narrowing: a runtime whose catalog reports reasoning levels PER MODEL rather than
-    // uniformly across the agent (Codex — see `AgentModelOption.reasoning`'s doc) declares them on the
-    // resolved model's own catalog row. `undefined` there means "this model's entry has nothing
-    // model-specific to say", so it falls back to the agent-wide union below — the same list every
-    // model rendered before this field existed. An explicit `[]` is honored AS-IS, even though a model
-    // with genuinely zero levels then hides the control: falling back to the union for `[]` too would
-    // just move today's "every model sees every level" bug one layer down instead of fixing it.
-    const selectedModelReasoning = models.find((model) => model.id === resolvedModel)?.reasoning;
-    // Exactly one effort control, whichever shape declared it. `reasoningOptions` wins if a def ever
-    // declares both, rather than rendering two controls that disagree about where the choice lands.
-    const reasoningOptions = flatReasoningOptions.length === 0
-        ? (activeGroup?.levels ?? [])
-        : selectedModelReasoning === undefined
-            ? flatReasoningOptions
-            : selectedModelReasoning;
+    const reasoningOptions = effortOptions({ flatReasoningOptions, activeGroup, models, resolvedModel });
     const hasReasoning = reasoningOptions.length > 0;
-    const rawReasoningValue = flatReasoningOptions.length > 0
-        ? selectedAgentReasoning(config, agent)
-        : (activeLevel ?? reasoningOptions[0]?.id ?? '');
-    // The persisted (or agent-wide-default) pick can name a level the narrowed list above does not
-    // actually offer for the CURRENT model — that is the whole point of narrowing. Rendering it anyway
-    // would just relocate today's bug: the `<select>` below has no matching `<option>`, so it would
-    // silently show whatever the browser highlights first while the underlying value stays wrong. This
-    // guards what actually renders; the effect further down clears the persisted copy so every other
-    // reader of `config.reasoningByAgentId` (not just this hook) sees the correction too.
-    const reasoningSupported = reasoningOptions.some((option) => option.id === rawReasoningValue);
-    const reasoningValue = reasoningSupported ? rawReasoningValue : (reasoningOptions[0]?.id ?? '');
+    const reasoningValue = effortValue({ agent, config, flatReasoningOptions, activeLevel, reasoningOptions });
     // A base model with exactly one variant has a real, fixed level worth showing — but nothing to
     // choose between, so the control is shown disabled rather than offering an illusion of choice.
     const reasoningDisabled = flatReasoningOptions.length === 0 && reasoningOptions.length < 2;
     const reasoningOptionIdsKey = reasoningOptions.map((option) => option.id).join('|');
     useEffect(() => {
-        // The reasoningInModelId path has no reasoning value of its own to clear — the level lives
-        // inside the model id itself, and picking a new base model already replaces it.
-        if (flatReasoningOptions.length === 0)
-            return;
         if (!onReasoningChange)
             return;
-        const persisted = config.reasoningByAgentId?.[agent.id]?.trim();
-        if (!persisted)
-            return;
-        if (reasoningOptions.some((option) => option.id === persisted))
-            return;
-        onReasoningChange('');
+        if (isStaleReasoningPick({ agent, config, flatReasoningOptions, reasoningOptions }))
+            onReasoningChange('');
         // `reasoningOptionIdsKey` stands in for `reasoningOptions` (a fresh array every render) so this
         // only re-runs when the narrowed vocabulary actually changes, not on every unrelated re-render.
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [flatReasoningOptions.length, onReasoningChange, config.reasoningByAgentId, agent.id, reasoningOptionIdsKey]);
-    // Adapters opt out via `supportsCustomModel: false` when their CLI has no
-    // free-text model flag, or validates the id against a live catalog and
-    // rejects unknown ones. `undefined` allows it, matching every adapter's
-    // default before this field existed.
-    const allowCustomModel = agent.supportsCustomModel !== false && modelGroups === null;
-    const knownModelIds = models.map((model) => model.id);
-    const customActive = allowCustomModel && hasModels && shouldShowCustomModelInput(resolvedModel, knownModelIds, explicitCustomMode);
+    const { allowCustomModel, knownModelIds, customActive } = customModelState({ agent, modelGroups, models, resolvedModel, explicitCustomMode });
     // A model-suffix agent picks a BASE model here; the effort control below supplies the rest of the
     // id. Everything else about the field — search, labels, provenance badge — is unchanged.
     const modelChoices = modelGroups
         ? modelGroups.map((group) => ({ id: group.baseId, label: group.label }))
-        : models;
-    const selectValue = customActive
-        ? CUSTOM_MODEL_SENTINEL
-        : modelGroups
-            ? (activeGroup?.baseId ?? '')
-            : resolvedModel;
+        : pickerModelOptions({ models });
+    const selectValue = modelSelectValue({ customActive, modelGroups, activeGroup, models, resolvedModel });
     // While the custom box is open, the text field must show the operator's raw
     // typed text (which may not resolve to anything yet) rather than the
     // resolved-with-fallback value — otherwise every keystroke would show a
@@ -146,4 +81,110 @@ export function useReasoningControl(optionsOrAgent, maybeConfig, maybeExplicitCu
         resolveReasoningModelId,
     };
 }
+/** The two call shapes (options object, or the older positional `agent, config, explicitCustomMode`)
+ *  as one options object. */
+function reasoningControlOptions(optionsOrAgent, maybeConfig, maybeExplicitCustomMode) {
+    if ('agent' in optionsOrAgent && 'config' in optionsOrAgent)
+        return optionsOrAgent;
+    return {
+        agent: optionsOrAgent,
+        config: maybeConfig,
+        explicitCustomMode: maybeExplicitCustomMode ?? false,
+    };
+}
+/**
+ * The model-suffix reasoning shape: the agent's declared suffix levels, its catalog grouped by base
+ * model, and where the resolved model sits in those groups. All `null` (and empty) for an agent
+ * without `reasoningInModelId`.
+ *
+ * Two ways an agent can expose a reasoning-effort axis, and the card branches on the DECLARATION
+ * rather than on the agent's id — adding a third runtime with either shape is a def change, not
+ * an edit here.
+ *
+ *   `reasoningOptions`     — one flat vocabulary that travels to the CLI as its own flag
+ *                            (`claude --effort high`, codex's `-c model_reasoning_effort=...`).
+ *                            The choice is its own persisted value; `onReasoningChange` owns it.
+ *   `reasoningInModelId`   — no effort flag exists; the level is a suffix on the model id itself
+ *                            (antigravity's `gemini-3.1-pro-high`). The choice IS the model, so
+ *                            it goes through `onModelChange`, and the available levels are
+ *                            derived PER BASE MODEL from the agent's own catalog — they are not
+ *                            uniform (`gemini-3.1-pro` has no `-medium`, and `agy --model`
+ *                            rejects one), so a fixed dropdown would offer ids the CLI refuses.
+ */
+function suffixReasoning({ agent, models, resolvedModel }) {
+    const suffixLevels = agent.reasoningInModelId?.levels ?? [];
+    const suffixLevelIds = suffixLevels.map((level) => level.id);
+    if (suffixLevels.length === 0) {
+        return { suffixLevels, suffixLevelIds, modelGroups: null, activeGroup: null, activeLevel: null };
+    }
+    const modelGroups = reasoningModelGroups(models, suffixLevels);
+    const activeGroup = reasoningModelGroupFor(modelGroups, resolvedModel, suffixLevelIds);
+    const activeLevel = splitReasoningModelId(resolvedModel, suffixLevelIds).level;
+    return { suffixLevels, suffixLevelIds, modelGroups, activeGroup, activeLevel };
+}
+/** The effort options the reasoning dropdown offers for the resolved model. */
+function effortOptions({ flatReasoningOptions, activeGroup, models, resolvedModel }) {
+    // Exactly one effort control, whichever shape declared it. `reasoningOptions` wins if a def ever
+    // declares both, rather than rendering two controls that disagree about where the choice lands.
+    if (flatReasoningOptions.length === 0)
+        return activeGroup?.levels ?? [];
+    // Per-model narrowing: a runtime whose catalog reports reasoning levels PER MODEL rather than
+    // uniformly across the agent (Codex — see `AgentModelOption.reasoning`'s doc) declares them on the
+    // resolved model's own catalog row. `undefined` there means "this model's entry has nothing
+    // model-specific to say", so it falls back to the agent-wide union below — the same list every
+    // model rendered before this field existed. An explicit `[]` is honored AS-IS, even though a model
+    // with genuinely zero levels then hides the control: falling back to the union for `[]` too would
+    // just move today's "every model sees every level" bug one layer down instead of fixing it.
+    const selectedModelReasoning = models.find((model) => model.id === resolvedModel)?.reasoning;
+    return selectedModelReasoning === undefined ? flatReasoningOptions : selectedModelReasoning;
+}
+/** The value the reasoning select renders: the persisted / derived pick, or the first offered level
+ *  when that pick is not among the options. */
+function effortValue({ agent, config, flatReasoningOptions, activeLevel, reasoningOptions }) {
+    const rawReasoningValue = flatReasoningOptions.length > 0
+        ? selectedAgentReasoning(config, agent)
+        : (activeLevel ?? reasoningOptions[0]?.id ?? '');
+    // The persisted (or agent-wide-default) pick can name a level the narrowed list above does not
+    // actually offer for the CURRENT model — that is the whole point of narrowing. Rendering it anyway
+    // would just relocate today's bug: the `<select>` below has no matching `<option>`, so it would
+    // silently show whatever the browser highlights first while the underlying value stays wrong. This
+    // guards what actually renders; the effect further down clears the persisted copy so every other
+    // reader of `config.reasoningByAgentId` (not just this hook) sees the correction too.
+    const reasoningSupported = reasoningOptions.some((option) => option.id === rawReasoningValue);
+    return reasoningSupported ? rawReasoningValue : (reasoningOptions[0]?.id ?? '');
+}
+/** Whether the agent's persisted flat-reasoning pick names a level the current options no longer
+ *  offer, so the hook should ask the host to clear it. */
+function isStaleReasoningPick({ agent, config, flatReasoningOptions, reasoningOptions }) {
+    // The reasoningInModelId path has no reasoning value of its own to clear — the level lives
+    // inside the model id itself, and picking a new base model already replaces it.
+    if (flatReasoningOptions.length === 0)
+        return false;
+    const persisted = config.reasoningByAgentId?.[agent.id]?.trim();
+    if (!persisted)
+        return false;
+    return !reasoningOptions.some((option) => option.id === persisted);
+}
+/** The model select's value: the Custom sentinel, a suffix agent's base id, or the resolved model. */
+function modelSelectValue({ customActive, modelGroups, activeGroup, models, resolvedModel }) {
+    if (customActive)
+        return CUSTOM_MODEL_SENTINEL;
+    if (modelGroups)
+        return activeGroup?.baseId ?? '';
+    // Persisted aliases stay known in the full catalog above, but the picker selects their concrete
+    // row. This is display-only: the saved model and dispatch resolution keep the operator's pick.
+    const selectedModel = models.find((model) => model.id === resolvedModel);
+    return selectedModel?.identityKind === 'alias' ? (selectedModel.resolvedId || resolvedModel) : resolvedModel;
+}
+/** Whether this agent takes a free-text model id at all, and whether the free-text box is open now. */
+function customModelState({ agent, modelGroups, models, resolvedModel, explicitCustomMode }) {
+    // Adapters opt out via `supportsCustomModel: false` when their CLI has no
+    // free-text model flag, or validates the id against a live catalog and
+    // rejects unknown ones. `undefined` allows it, matching every adapter's
+    // default before this field existed.
+    const allowCustomModel = agent.supportsCustomModel !== false && modelGroups === null;
+    const knownModelIds = models.map((model) => model.id);
+    const customActive = allowCustomModel && models.length > 0 && shouldShowCustomModelInput(resolvedModel, knownModelIds, explicitCustomMode);
+    return { allowCustomModel, knownModelIds, customActive };
+}
 //# sourceMappingURL=useReasoningControl.js.map

package/dist/features/execution/rules.d.ts

@@ -109,8 +109,8 @@ export declare function isBaseUrlInvalid(config: ByokConfig): boolean;
  */
 export declare function nextConfigForPresetSelect(config: ByokConfig, preset: ProviderPreset): ByokConfig;
 /** Switching protocol by hand drops the preset selection (the old preset no
- *  longer speaks this protocol) and adopts the protocol's default endpoint
- *  only when the operator hasn't typed their own. */
+ *  longer speaks this protocol) and keeps operator-entered endpoints. Hosts
+ *  seed endpoints through presets; protocol selection never chooses a vendor. */
 export declare function nextConfigForProtocolSelect(config: ByokConfig, protocol: ByokConfig['protocol']): ByokConfig;
 /** Mode changes never discard BYOK credentials — flipping to Local CLI and
  *  back must not make the operator retype their key. */
@@ -243,6 +243,17 @@ export declare function agentExecutableRepairState(result: {
     usedExecutableSource?: AgentExecutableSource | undefined;
     detectedExecutablePath?: string | undefined;
 }): AgentExecutableRepair | null;
+/**
+ * Builds picker rows from catalog evidence without changing the source catalog. Resolved aliases
+ * share a concrete row; unresolved aliases and routing modes remain selectable as reported.
+ * Keeps the first position and prefers a human label over a raw ID, including the CLI default's
+ * raw-label row. No names or context variants are inferred from model IDs.
+ * @returns Distinct picker rows in catalog order. No side effects or errors.
+ * @complexity O(n) time and space in catalog rows, using insertion-ordered Map keys.
+ */
+export declare function pickerModelOptions({ models }: {
+    models: readonly AgentModelOption[];
+}, _optional?: Record<string, never>): AgentModelOption[];
 /**
  * Filters a searchable model list down to what matches the operator's typed
  * query. The currently-selected value's own option is always kept even when

package/dist/features/execution/rules.js

@@ -1,5 +1,5 @@
 import { isAllowedEndpointUrl } from '../../utils/endpoint-policy.js';
-import { API_KEY_CROSS_VENDOR_WARNING, API_KEY_TOO_SHORT_WARNING, CUSTOM_PRESET_ID, DEFAULT_BASE_URL_BY_PROTOCOL, MIN_PLAUSIBLE_API_KEY_LENGTH, } from './constants.js';
+import { API_KEY_CROSS_VENDOR_WARNING, API_KEY_TOO_SHORT_WARNING, CUSTOM_PRESET_ID, MIN_PLAUSIBLE_API_KEY_LENGTH, } from './constants.js';
 /**
  * Pure decision logic for the execution tab. Everything here is total and
  * side-effect free so the React layer stays a thin renderer — same split the
@@ -231,21 +231,26 @@ export function nextConfigForPresetSelect(config, preset) {
     if (preset.custom) {
         return { ...config, providerId: null, savedByProviderId };
     }
-    const saved = savedByProviderId[preset.id];
     return {
         ...config,
         providerId: preset.id,
         protocol: preset.protocol,
+        ...presetCredentials(savedByProviderId[preset.id], preset),
+        savedByProviderId,
+    };
+}
+/** A preset's saved draft, or blank credentials seeded with its base URL and top preferred model. */
+function presetCredentials(saved, preset) {
+    return {
         apiKey: saved?.apiKey ?? '',
-        baseUrl: saved?.baseUrl ?? (preset.baseUrl || DEFAULT_BASE_URL_BY_PROTOCOL[preset.protocol]),
+        baseUrl: saved?.baseUrl ?? preset.baseUrl,
         model: saved?.model ?? preset.preferredModels[0] ?? '',
         maxTokens: saved?.maxTokens,
-        savedByProviderId,
     };
 }
 /** Switching protocol by hand drops the preset selection (the old preset no
- *  longer speaks this protocol) and adopts the protocol's default endpoint
- *  only when the operator hasn't typed their own. */
+ *  longer speaks this protocol) and keeps operator-entered endpoints. Hosts
+ *  seed endpoints through presets; protocol selection never chooses a vendor. */
 export function nextConfigForProtocolSelect(config, protocol) {
     if (config.protocol === protocol)
         return config;
@@ -253,7 +258,7 @@ export function nextConfigForProtocolSelect(config, protocol) {
         ...config,
         protocol,
         providerId: null,
-        baseUrl: config.baseUrl.trim() ? config.baseUrl : DEFAULT_BASE_URL_BY_PROTOCOL[protocol],
+        baseUrl: config.baseUrl.trim() ? config.baseUrl : '',
     };
 }
 /** Mode changes never discard BYOK credentials — flipping to Local CLI and
@@ -476,6 +481,37 @@ export function agentExecutableRepairState(result) {
         return null;
     return { detectedPath, canUseDetected: true };
 }
+/** Resolves alias evidence to a concrete picker row; other rows retain their identity. */
+function resolvedPickerModelOption({ model }, _optional = {}) {
+    const resolvedId = model.identityKind === 'alias' ? model.resolvedId : undefined;
+    if (!resolvedId)
+        return model;
+    const label = model.label === model.id ? resolvedId : model.label;
+    return { ...model, id: resolvedId, label, identityKind: 'concrete' };
+}
+/**
+ * Builds picker rows from catalog evidence without changing the source catalog. Resolved aliases
+ * share a concrete row; unresolved aliases and routing modes remain selectable as reported.
+ * Keeps the first position and prefers a human label over a raw ID, including the CLI default's
+ * raw-label row. No names or context variants are inferred from model IDs.
+ * @returns Distinct picker rows in catalog order. No side effects or errors.
+ * @complexity O(n) time and space in catalog rows, using insertion-ordered Map keys.
+ */
+export function pickerModelOptions({ models }, _optional = {}) {
+    const choices = new Map();
+    for (const model of models) {
+        const option = resolvedPickerModelOption({ model });
+        const { id, label } = option;
+        const existing = choices.get(id);
+        if (!existing) {
+            choices.set(id, option);
+        }
+        else if (existing.label === id && label !== id) {
+            choices.set(id, { ...existing, label });
+        }
+    }
+    return [...choices.values()];
+}
 /** Case-insensitive substring match against a model's id or label, mirroring
  *  the origin's search box. Matches on both fields (not just the visible
  *  label) so an operator can search by the raw model id too. */
@@ -542,16 +578,20 @@ export function splitReasoningModelId(modelId, levelIds) {
  * has no level, so nothing is stripped, and a vendor label that happens to end in an unrelated
  * parenthetical keeps it.
  */
+/** `Head (Inner)` with optional surrounding whitespace; group 1 is the head, group 2 the qualifier. */
+const TRAILING_PARENTHETICAL = /^(.*?)\s*\(([^()]*)\)\s*$/;
 function baseLabelForLevel(label, level) {
     if (!level)
         return label;
-    const match = /^(.*?)\s*\(([^()]*)\)\s*$/.exec(label);
-    if (!match)
+    if (!TRAILING_PARENTHETICAL.test(label))
         return label;
-    const inner = (match[2] ?? '').trim().toLowerCase();
+    // Both capture groups always participate once the pattern matches, so reading them through
+    // `replace` (which yields a plain string) replaces the old `match[n] ?? ''` fallbacks, which no
+    // matching label could ever reach.
+    const inner = label.replace(TRAILING_PARENTHETICAL, '$2').trim().toLowerCase();
     if (inner !== level.id.toLowerCase() && inner !== level.label.toLowerCase())
         return label;
-    const stripped = (match[1] ?? '').trim();
+    const stripped = label.replace(TRAILING_PARENTHETICAL, '$1').trim();
     return stripped || label;
 }
 /**

package/dist/features/execution/types.d.ts

@@ -1,3 +1,4 @@
+import type { ProviderPreset as SharedProviderPreset } from '@jini-ai/core';
 /**
  * Origin: the inline `execution` tab body in `SettingsDialog.tsx`
  * (lines 4080-5336), classified MIXED by
@@ -26,48 +27,9 @@ export type ApiProtocol = 'anthropic' | 'openai' | 'azure' | 'google';
 /** Where a preset renders in the chip strip. The origin drew one row of
  *  protocol presets and one of gateway presets; hosts that don't care can
  *  leave this unset and get a single row. */
-export type ProviderPresetKind = 'protocol' | 'gateway';
-/** One selectable endpoint preset. A host supplies its own catalog — this
- *  package ships `DEFAULT_PROVIDER_PRESETS` as a starting point, not as a
- *  fixed list (same convention as `LanguageTab`'s host-supplied locales). */
-export interface ProviderPreset {
-    id: string;
-    title: string;
-    protocol: ApiProtocol;
-    baseUrl: string;
-    /** Ranked suggestions shown in the model field. Never authoritative — a
-     *  host with live model discovery should pass `ExecutionPort.listModels`. */
-    preferredModels: readonly string[];
-    kind?: ProviderPresetKind;
-    /** Fixed-origin gateways resolve their base URL themselves, so the Base URL
-     *  field is hidden rather than shown-and-ignored (origin: `isFixedOriginGateway`). */
-    fixedOrigin?: boolean;
-    /** Some local/self-hosted endpoints need no bearer credential. Defaults to
-     *  `true` — i.e. an API key is required unless a preset opts out. */
-    requiresApiKey?: boolean;
-    /** Optional "Get key" deep link rendered beside the API-key field. */
-    apiKeyConsoleUrl?: string;
-    /**
-     * The literal prefix that positively identifies a pasted key as belonging to THIS provider —
-     * `'AIza'` for Google, `'sk-ant-'` for Anthropic. Omit it for a vendor whose keys carry no
-     * distinguishing prefix (Azure OpenAI's are bare hex) rather than inventing one.
-     *
-     * Read in exactly one direction: to recognise a key as SOMEONE ELSE'S. It is deliberately NOT an
-     * allowlist, and no code may ask "does the selected preset's key match this?" as a validity test.
-     * That is the shape this field replaced, and it shipped a false positive within hours of landing:
-     * a real Google Gemini key in a newer shape than `/^AIza/` was reported to its owner as not
-     * looking like a Google key. Vendors add key formats without telling anyone, so a catalog can
-     * prove a string belongs to vendor X, but never that it belongs to nobody. See
-     * `apiKeyFormatWarning`.
-     *
-     * Data rather than an `if (providerId === …)` chain in the rule, so adding a provider stays a row
-     * in the preset catalog — including for a host that supplies its own `presets` and never touches
-     * this package.
-     */
-    apiKeyPrefix?: string;
-    /** The synthetic "Custom" preset. Exactly one may carry this flag; it is
-     *  never treated as configured-by-preset and never hides the Base URL. */
-    custom?: boolean;
+export type { ProviderPresetKind } from '@jini-ai/core';
+/** One selectable endpoint preset supplied by the host. */
+export interface ProviderPreset extends SharedProviderPreset<ApiProtocol> {
 }
 /**
  * One advisory remark about the API key currently typed into the form, ready to translate.
@@ -138,6 +100,8 @@ export interface ExecutionConfig {
 export interface AgentModelOption {
     id: string;
     label: string;
+    identityKind?: 'concrete' | 'alias' | 'routing-mode';
+    resolvedId?: string;
     /**
      * The reasoning-effort levels THIS model supports, when the runtime's own catalog reports them
      * per model rather than uniformly across the agent. Mirrors `@jini-ai/agent-runtime`'s

package/dist/features/execution/types.js

@@ -1,19 +1,2 @@
-/**
- * Origin: the inline `execution` tab body in `SettingsDialog.tsx`
- * (lines 4080-5336), classified MIXED by
- * `ADS-memory/reports/jini-port/recon/r6-god-component-internals.md` §1.3 — a generic
- * "Local CLI vs. bring-your-own-key" execution switch wrapped in
- * origin-specific managed-runtime/wallet chrome.
- *
- * What is ported: the mode switch, the provider/gateway chip groups, and the
- * BYOK credential form (the origin had already factored these fields into
- * `components/byok/*`, which is why this slice is assembly rather than
- * surgery).
- *
- * What is deliberately left behind: the origin's managed-runtime wallet
- * (balance polling, top-up, sign-in coachmarks, the `SettingsHighlight`
- * one-shot focus hint) and its analytics tracking calls — all product-bound,
- * none of it generic.
- */
 export {};
 //# sourceMappingURL=types.js.map

package/dist/features/external-mcp/react/components/ExternalMcpTab.d.ts

@@ -1,5 +1,5 @@
 import type { SourceConfigDependencies } from '../../../source-config-list/ports.js';
-import type { SourceConfigItem, SourceFieldSpec } from '../../../source-config-list/types.js';
+import type { SourceConfigItem, SourceFieldSpec, SourceTrustOption } from '../../../source-config-list/types.js';
 export interface ExternalMcpTabProps {
     /** Host-supplied transport adapter — required, same as the generic primitive (no zero-config default is possible for an arbitrary `addSource`). */
     dependencies: SourceConfigDependencies<SourceConfigItem>;
@@ -11,6 +11,10 @@ export interface ExternalMcpTabProps {
     saveStatusLabel?: string;
     /** Footer "Stored at <path>" text. Shown only when `saveStatusLabel` is also given, matching the footer being one unit in the OD reference. */
     configPath?: string;
+    /** The trust levels each server card offers. The card renders its trust picker only when this is
+     *  non-empty AND the port implements `setTrust`; without it the tab's `setTrust` wiring had no
+     *  control that could ever reach it. Omit for no trust picker (the previous, and still default, look). */
+    trustOptions?: readonly SourceTrustOption[];
 }
 /**
  * OD as an MCP *client* — distinct from the "MCP server" tab, where the host
@@ -19,5 +23,5 @@ export interface ExternalMcpTabProps {
  * composition only: every list/add mutation is the two source-config-list
  * hooks' own, already-tested logic.
  */
-export declare function ExternalMcpTab({ dependencies, fieldSpecs, connectionError, saveStatusLabel, configPath, }: ExternalMcpTabProps): import("react").JSX.Element;
+export declare function ExternalMcpTab({ dependencies, fieldSpecs, connectionError, saveStatusLabel, configPath, trustOptions, }: ExternalMcpTabProps): import("react").JSX.Element;
 //# sourceMappingURL=ExternalMcpTab.d.ts.map

package/dist/features/external-mcp/react/components/ExternalMcpTab.js

@@ -33,7 +33,7 @@ import { MCP_SOURCE_FIELD_SPECS } from '../../constants.js';
  * composition only: every list/add mutation is the two source-config-list
  * hooks' own, already-tested logic.
  */
-export function ExternalMcpTab({ dependencies, fieldSpecs = MCP_SOURCE_FIELD_SPECS, connectionError = null, saveStatusLabel, configPath, }) {
+export function ExternalMcpTab({ dependencies, fieldSpecs = MCP_SOURCE_FIELD_SPECS, connectionError = null, saveStatusLabel, configPath, trustOptions, }) {
     const t = useT();
     const [formOpen, setFormOpen] = useState(false);
     const list = useWiredSourceConfigList({ dependencies });
@@ -48,6 +48,13 @@ export function ExternalMcpTab({ dependencies, fieldSpecs = MCP_SOURCE_FIELD_SPE
     // A real load failure always wins over the host's static/decorative banner
     // text — showing both would just be two banners saying overlapping things.
     const banner = list.error ?? connectionError;
-    return (_jsxs("section", { className: "external-mcp-tab", children: [_jsxs("div", { className: "external-mcp-head", children: [_jsxs("div", { children: [_jsx("h3", { children: t('External MCP servers') }), _jsx("p", { className: "external-mcp-subtitle", children: t('Third-party tools for your coding agent.') })] }), _jsxs("button", { type: "button", className: "external-mcp-add-button", onClick: () => setFormOpen((open) => !open), "aria-expanded": formOpen, children: [_jsx(Icon, { name: "plus", size: 14 }), _jsx("span", { children: t('Add server') })] })] }), banner ? (_jsx("div", { className: "external-mcp-banner", role: "alert", children: t(banner) })) : null, formOpen ? (_jsx(SourceConfigAddForm, { fieldSpecs: fieldSpecs, values: addForm.values, validation: addForm.validation, submitAttempted: addForm.submitAttempted, submitting: addForm.submitting, ...(addForm.submitError ? { submitError: addForm.submitError } : {}), onFieldChange: addForm.setField, onTrustChange: addForm.setTrust, onSubmit: () => void addForm.submit(), canTest: list.capabilities.canTest, testing: list.isPending(DRAFT_TEST_SCOPE, 'test'), ...(list.testResults[DRAFT_TEST_SCOPE] ? { testResult: list.testResults[DRAFT_TEST_SCOPE] } : {}), onTest: () => void list.test(undefined, addForm.values), addLabel: "Add server" })) : null, list.loading ? (_jsx("div", { className: "source-config-list-loading", role: "status", children: t('Loading…') })) : list.sources.length === 0 ? (_jsxs("div", { className: "external-mcp-empty", children: [_jsx("p", { className: "external-mcp-empty-title", children: t('No MCP servers configured.') }), _jsx("p", { className: "external-mcp-empty-hint", children: t('Click "Add server" to get started — pick a template or set up a custom stdio / HTTP server.') })] })) : (_jsx("div", { className: "source-config-list-items", children: list.sources.map((source) => (_jsx(SourceConfigItemCard, { source: source, fieldSpecs: fieldSpecs, capabilities: list.capabilities, removing: list.isPending(source.id, 'remove'), refreshing: list.isPending(source.id, 'refresh'), settingTrust: list.isPending(source.id, 'trust'), testing: list.isPending(source.id, 'test'), updating: list.isPending(source.id, 'update'), onRefresh: () => void list.refresh(source.id), onRemove: () => void list.remove(source.id), onTrustChange: (trust) => void list.setTrust(source.id, trust), onTest: () => void list.test(source.id), onUpdate: (patch) => void list.update(source.id, patch), ...(list.testResults[source.id] ? { testResult: list.testResults[source.id] } : {}) }, source.id))) })), saveStatusLabel ? (_jsxs("div", { className: "external-mcp-footer", children: [_jsx("span", { className: "external-mcp-save-pill", children: t(saveStatusLabel) }), configPath ? (_jsxs("span", { className: "external-mcp-stored-at", children: [t('Stored at'), " ", _jsx("code", { children: configPath })] })) : null] })) : null] }));
+    return (_jsxs("section", { className: "external-mcp-tab", children: [_jsxs("div", { className: "external-mcp-head", children: [_jsxs("div", { children: [_jsx("h3", { children: t('External MCP servers') }), _jsx("p", { className: "external-mcp-subtitle", children: t('Third-party tools for your coding agent.') })] }), _jsxs("button", { type: "button", className: "external-mcp-add-button", onClick: () => setFormOpen((open) => !open), "aria-expanded": formOpen, children: [_jsx(Icon, { name: "plus", size: 14 }), _jsx("span", { children: t('Add server') })] })] }), banner ? (_jsx("div", { className: "external-mcp-banner", role: "alert", children: t(banner) })) : null, formOpen ? (_jsx(SourceConfigAddForm, { fieldSpecs: fieldSpecs, values: addForm.values, validation: addForm.validation, submitAttempted: addForm.submitAttempted, submitting: addForm.submitting, submitError: addForm.submitError, onFieldChange: addForm.setField, onTrustChange: addForm.setTrust, onSubmit: () => void addForm.submit(), canTest: list.capabilities.canTest, testing: list.isPending(DRAFT_TEST_SCOPE, 'test'), ...(list.testResults[DRAFT_TEST_SCOPE] ? { testResult: list.testResults[DRAFT_TEST_SCOPE] } : {}), onTest: () => void list.test(undefined, addForm.values), addLabel: "Add server" })) : null, list.loading ? (_jsx("div", { className: "source-config-list-loading", role: "status", children: t('Loading…') })) : list.sources.length === 0 ? (_jsxs("div", { className: "external-mcp-empty", children: [_jsx("p", { className: "external-mcp-empty-title", children: t('No MCP servers configured.') }), _jsx("p", { className: "external-mcp-empty-hint", children: t('Click "Add server" to get started — pick a template or set up a custom stdio / HTTP server.') })] })) : (_jsx("div", { className: "source-config-list-items", children: list.sources.map((source) => (_jsx(SourceConfigItemCard, { source: source, fieldSpecs: fieldSpecs, ...(trustOptions ? { trustOptions } : {}), capabilities: list.capabilities, removing: list.isPending(source.id, 'remove'), refreshing: list.isPending(source.id, 'refresh'), settingTrust: list.isPending(source.id, 'trust'), testing: list.isPending(source.id, 'test'), updating: list.isPending(source.id, 'update'), onRefresh: () => void list.refresh(source.id), onRemove: () => void list.remove(source.id), onTrustChange: (trust) => void list.setTrust(source.id, trust), onTest: () => void list.test(source.id), onUpdate: (patch) => void list.update(source.id, patch), ...(list.testResults[source.id] ? { testResult: list.testResults[source.id] } : {}) }, source.id))) })), _jsx(ExternalMcpFooter, { saveStatusLabel: saveStatusLabel, configPath: configPath })] }));
+}
+/** Renders the save-status footer as one unit; a path alone does not show it. */
+function ExternalMcpFooter({ saveStatusLabel, configPath }) {
+    const t = useT();
+    if (!saveStatusLabel)
+        return null;
+    return (_jsxs("div", { className: "external-mcp-footer", children: [_jsx("span", { className: "external-mcp-save-pill", children: t(saveStatusLabel) }), configPath ? (_jsxs("span", { className: "external-mcp-stored-at", children: [t('Stored at'), " ", _jsx("code", { children: configPath })] })) : null] }));
 }
 //# sourceMappingURL=ExternalMcpTab.js.map