@cat-factory/app 0.222.0 → 0.223.0

package/app/components/settings/CapabilityCredentialsPanel.vue

@@ -16,6 +16,7 @@
 import { computed, onMounted, reactive, ref } from 'vue'
 import type { CapabilityCredentialStatus } from '~/types/capabilityCredentials'
 import SecretInput from '~/components/common/SecretInput.vue'
+import ToolServerChecklist from '~/components/settings/ToolServerChecklist.vue'
 
 const { t, d } = useI18n()
 const store = useCapabilityCredentialsStore()
@@ -63,6 +64,19 @@ onMounted(async () => {
   }
 })
 
+// The tool-server inventory that renders above the checklist. Its own read (and its own failure
+// report, for the same reason): the two surfaces answer different questions off different endpoints,
+// so one failing must not blank the other. Both resolve the same 403, so this is only reached by a
+// caller the backend has already admitted.
+const toolServers = useToolServersStore()
+onMounted(async () => {
+  try {
+    await toolServers.load()
+  } catch (e) {
+    present(e, 'settings.toolServers.toast.loadFailed')
+  }
+})
+
 async function saveKey(key: string) {
   const value = (drafts[key] ?? '').trim()
   if (!value) return
@@ -99,6 +113,11 @@ async function removeKey(key: string) {
 
 <template>
   <div class="space-y-4" data-testid="capability-credentials-panel">
+    <!-- The servers FIRST, because they are what the keys below authenticate: a bare list of
+         variable names does not tell an operator which of them matters, and the Test button is the
+         only thing on either surface that can say whether the value they typed works. -->
+    <ToolServerChecklist />
+
     <p class="text-sm text-slate-400">
       {{ t('settings.capabilityCredentials.intro') }}
     </p>

package/app/components/settings/InfrastructureWindow.vue

@@ -15,10 +15,11 @@
 //   - "Package registries" — the private npm registries a checkout installs from (formerly an
 //     Integrations-hub row). What a container can resolve its dependencies from is part of the
 //     execution environment, not an optional external system a workspace links in.
-//   - "Capability credentials" — the sealed per-workspace values behind the secrets a registered
-//     tool server (MCP) or generative binary integration declares. What an agent's tools
-//     authenticate as belongs beside where those agents run, and it is `secrets.manage`-only, so
-//     the tab is HIDDEN rather than disabled for anyone without that permission.
+//   - "Capability credentials" — the deployment's tool servers (MCP) with a Test button each, above
+//     the sealed per-workspace values behind the secrets a registered tool server or generative
+//     binary integration declares. What an agent's tools authenticate as belongs beside where those
+//     agents run, and it is `secrets.manage`-only (the READ included, since both halves name the
+//     deployment's credential keys), so the tab is HIDDEN rather than disabled for anyone else.
 // Local-specific affordances render inline, gated on `auth.localMode?.enabled`. A tab whose
 // backend integration is disabled (503) simply doesn't render.
 import { computed, ref, watch } from 'vue'
@@ -43,6 +44,7 @@ const store = useProviderConnectionsStore()
 const auth = useAuthStore()
 const packageRegistries = usePackageRegistriesStore()
 const capabilityCredentials = useCapabilityCredentialsStore()
+const toolServers = useToolServersStore()
 const { canManageSecrets } = useWorkspaceAccess()
 
 const open = computed({
@@ -93,7 +95,14 @@ const tabs = computed(() =>
     // the backend gates the read too), and `hasSurface` hides a tab with nothing in it — the
     // panel is a checklist projected from the deployment's registered capabilities, so a build
     // that registers none has no credential to type.
-    capabilityCredentials: canManageSecrets.value && capabilityCredentials.hasSurface,
+    //
+    // EITHER surface earns the tab. A tool server that declares no credential has nothing on the
+    // checklist, and gating the tab on the checklist alone would leave the one server an operator
+    // most wants to test unreachable — while a credential whose capability is a generative
+    // integration has no tool-server row. Two questions, one tab, and neither is a subset of the
+    // other.
+    capabilityCredentials:
+      canManageSecrets.value && (capabilityCredentials.hasSurface || toolServers.hasSurface),
   }).map((value) => ({
     value,
     label: TAB_LABELS.value[value],
@@ -121,7 +130,10 @@ watch(
     // window must still open), reported by the panel, which can only do that once its tab exists.
     // Not probed at all without the permission — the backend would refuse it, and asking would
     // put a 403 in every member's console on every open.
-    if (canManageSecrets.value) void capabilityCredentials.ensureLoaded().catch(() => {})
+    if (canManageSecrets.value) {
+      void capabilityCredentials.ensureLoaded().catch(() => {})
+      void toolServers.ensureLoaded().catch(() => {})
+    }
     activeTab.value = openInfrastructureTab(tabValues.value, ui.infrastructureTab)
   },
   { immediate: true },

package/app/components/settings/ToolServerChecklist.vue

@@ -0,0 +1,264 @@
+<script setup lang="ts">
+// Tool servers (MCP) — the deployment's registered servers, and a Test button that speaks the
+// protocol to one.
+//
+// It sits ABOVE the credential checklist in the same tab, because it is what the credentials on that
+// list are FOR: the checklist answers "which keys does this deployment want", and this answers "and
+// does the server they authenticate actually work". Both are `secrets.manage`-only, which is why the
+// tab is hidden rather than disabled for anyone else.
+//
+// A row states four independent reasons a declared server may never reach a run — no kind declares
+// it, no harness can serve its transport, its credentials do not resolve, the endpoint is dead — and
+// each is rendered rather than implied. Before this panel the first two lived in a boot log and the
+// deployment's own source, and the last two were only visible by starting a run and reading the
+// agent's prompt.
+import { computed, ref } from 'vue'
+import type {
+  ToolServerNotProbeableReason,
+  ToolServerProbeStatus,
+  ToolServerTransport,
+  ToolServerView,
+} from '~/types/toolServers'
+
+const { t } = useI18n()
+const store = useToolServersStore()
+const { present } = usePipelineErrorToast()
+
+// Which failure DETAILS are expanded, by server id. Collapsed by default: the translated status line
+// is what an operator acts on, and the raw backend prose is a disclosure behind it (never the
+// primary description) per the i18n rule.
+const expanded = ref<Record<string, boolean>>({})
+
+// Exhaustive Records over the wire vocabularies, so a member added in `@cat-factory/contracts` fails
+// to compile here until it has translated copy. The sanctioned guard for an enum-keyed lookup the
+// typed-message-key check cannot see.
+const TRANSPORT_LABELS = computed<Record<ToolServerTransport, string>>(() => ({
+  stdio: t('settings.toolServers.transport.stdio'),
+  http: t('settings.toolServers.transport.http'),
+}))
+const STATUS_LABELS = computed<Record<ToolServerProbeStatus, string>>(() => ({
+  ok: t('settings.toolServers.status.ok'),
+  credentials_missing: t('settings.toolServers.status.credentialsMissing'),
+  credential_refused: t('settings.toolServers.status.credentialRefused'),
+  unreachable: t('settings.toolServers.status.unreachable'),
+  http_error: t('settings.toolServers.status.httpError'),
+  protocol_error: t('settings.toolServers.status.protocolError'),
+  not_probeable: t('settings.toolServers.status.notProbeable'),
+}))
+const NOT_PROBEABLE_LABELS = computed<Record<ToolServerNotProbeableReason, string>>(() => ({
+  stdio_transport: t('settings.toolServers.notProbeable.stdio'),
+  container_local_url: t('settings.toolServers.notProbeable.containerLocal'),
+  url_not_allowed: t('settings.toolServers.notProbeable.urlNotAllowed'),
+}))
+
+const servers = computed<ToolServerView[]>(() => store.view?.servers ?? [])
+
+function resultFor(id: string) {
+  return store.results[id]
+}
+
+/** Success is the only green; every other verdict names something for the operator to fix. */
+function statusColor(status: ToolServerProbeStatus): 'success' | 'warning' | 'error' {
+  if (status === 'ok') return 'success'
+  return status === 'not_probeable' ? 'warning' : 'error'
+}
+
+async function runProbe(id: string) {
+  try {
+    await store.probe(id)
+  } catch (e) {
+    // A THROWN failure is not a verdict — a 404 for a server the deployment has since dropped, or a
+    // transient 5xx. Presented through the shared status-class funnel rather than stored as a
+    // result, so the row does not claim the probe answered.
+    present(e, 'settings.toolServers.toast.probeFailed')
+  }
+}
+</script>
+
+<template>
+  <section v-if="servers.length" class="space-y-3" data-testid="tool-servers-section">
+    <div>
+      <h3 class="text-sm font-semibold text-slate-200">
+        {{ t('settings.toolServers.heading') }}
+      </h3>
+      <p class="text-xs text-slate-400">{{ t('settings.toolServers.intro') }}</p>
+    </div>
+
+    <article
+      v-for="server in servers"
+      :key="server.id"
+      class="space-y-2 rounded-lg border border-slate-700 p-3"
+      :data-testid="`tool-server-${server.id}`"
+    >
+      <div class="flex flex-wrap items-center gap-2">
+        <span class="text-sm font-medium text-slate-200">{{ server.label }}</span>
+        <UBadge color="neutral" variant="soft" size="sm">
+          {{ TRANSPORT_LABELS[server.transport] }}
+        </UBadge>
+        <code class="font-mono text-[11px] text-slate-500">{{ server.id }}</code>
+      </div>
+
+      <p class="truncate font-mono text-[11px] text-slate-500" :title="server.target">
+        {{ server.target }}
+      </p>
+      <p v-if="server.guidance" class="text-xs text-slate-400">{{ server.guidance }}</p>
+
+      <!-- Which agents get it. An EMPTY list is a registration attached to nothing: it never reaches
+           a dispatch, so the credentials it asks for are keys an operator fills in for no run. Said
+           out loud, because no other surface in the platform can see that state. -->
+      <p v-if="server.declaredBy.length" class="text-[11px] text-slate-400">
+        {{ t('settings.toolServers.declaredBy', { kinds: server.declaredBy.join(', ') }) }}
+      </p>
+      <p v-else class="text-[11px] text-amber-400" :data-testid="`tool-server-orphan-${server.id}`">
+        {{ t('settings.toolServers.declaredByNone') }}
+      </p>
+
+      <!-- Which harnesses could serve it. EMPTY means the declaration can never run anywhere (an
+           `http` server narrowed to Codex, whose MCP client is stdio-only): it is never dropped FOR
+           A REASON on any run, so no prompt and no log line ever mentions it. -->
+      <p v-if="server.servableHarnesses.length" class="text-[11px] text-slate-400">
+        {{
+          t('settings.toolServers.servableHarnesses', {
+            harnesses: server.servableHarnesses.join(', '),
+          })
+        }}
+      </p>
+      <p v-else class="text-[11px] text-amber-400">
+        {{ t('settings.toolServers.servableHarnessesNone') }}
+      </p>
+
+      <p v-if="server.allowedTools?.length" class="text-[11px] text-slate-400">
+        {{ t('settings.toolServers.allowedTools', { tools: server.allowedTools.join(', ') }) }}
+      </p>
+      <p v-if="server.credentials.length" class="text-[11px] text-slate-400">
+        {{
+          t('settings.toolServers.credentials', {
+            keys: server.credentials.map((c) => c.key).join(', '),
+          })
+        }}
+      </p>
+
+      <div class="flex flex-wrap items-center gap-2 pt-1">
+        <UButton
+          v-if="server.probeable"
+          size="xs"
+          variant="subtle"
+          icon="i-lucide-plug"
+          :loading="store.probing === server.id"
+          :disabled="store.probing !== null"
+          :data-testid="`tool-server-test-${server.id}`"
+          @click="runProbe(server.id)"
+        >
+          {{ t('settings.toolServers.test') }}
+        </UButton>
+        <!-- Not a disabled button: nothing the operator can do here makes it clickable, so the row
+             states the reason instead. Each reason needs a different response — nothing to fix,
+             verify it from a run, or change the declaration. -->
+        <p
+          v-else-if="server.notProbeableReason"
+          class="text-[11px] text-slate-500"
+          :data-testid="`tool-server-unprobeable-${server.id}`"
+        >
+          {{ NOT_PROBEABLE_LABELS[server.notProbeableReason] }}
+        </p>
+      </div>
+
+      <div
+        v-if="resultFor(server.id)"
+        class="space-y-1 rounded-md border border-slate-800 bg-slate-900/40 p-2"
+        :data-testid="`tool-server-result-${server.id}`"
+      >
+        <div class="flex flex-wrap items-center gap-2">
+          <UBadge
+            :color="statusColor(resultFor(server.id)!.status)"
+            variant="soft"
+            size="sm"
+            :data-testid="`tool-server-status-${server.id}`"
+          >
+            {{ STATUS_LABELS[resultFor(server.id)!.status] }}
+          </UBadge>
+          <span v-if="resultFor(server.id)!.httpStatus" class="text-[11px] text-slate-400">
+            {{ t('settings.toolServers.httpStatus', { status: resultFor(server.id)!.httpStatus }) }}
+          </span>
+        </div>
+
+        <p v-if="resultFor(server.id)!.status === 'ok'" class="text-[11px] text-slate-300">
+          {{
+            t('settings.toolServers.okDetail', {
+              name: resultFor(server.id)!.serverName || server.id,
+              version: resultFor(server.id)!.serverVersion || '?',
+              protocol: resultFor(server.id)!.protocolVersion ?? '?',
+              count: resultFor(server.id)!.toolCount ?? 0,
+            })
+          }}
+        </p>
+        <!-- A count off a truncated read is a FLOOR, not a total, and the difference decides whether
+             the allowedTools verdict below means anything. -->
+        <p v-if="resultFor(server.id)!.toolsComplete === false" class="text-[11px] text-slate-500">
+          {{ t('settings.toolServers.toolsIncomplete') }}
+        </p>
+
+        <!-- The reconciliation nothing else in the platform can do: a well-formed tool name that
+             matches nothing narrows the CLI's allow-list to a dead pattern while the prompt keeps
+             advertising the tool. Withheld entirely when the tool list was a prefix. -->
+        <p
+          v-if="resultFor(server.id)!.allowedTools?.unmatched?.length"
+          class="text-[11px] text-amber-400"
+          :data-testid="`tool-server-unmatched-${server.id}`"
+        >
+          {{
+            t('settings.toolServers.unmatchedTools', {
+              tools: resultFor(server.id)!.allowedTools!.unmatched.join(', '),
+            })
+          }}
+        </p>
+        <p
+          v-else-if="resultFor(server.id)!.allowedTools?.checked === false"
+          class="text-[11px] text-slate-500"
+        >
+          {{ t('settings.toolServers.allowedToolsUnchecked') }}
+        </p>
+
+        <p
+          v-if="resultFor(server.id)!.unresolvedCredentials?.length"
+          class="text-[11px] text-amber-400"
+        >
+          {{
+            t('settings.toolServers.unresolvedCredentials', {
+              keys: resultFor(server.id)!.unresolvedCredentials!.join(', '),
+            })
+          }}
+        </p>
+        <p v-if="resultFor(server.id)!.refusedCredentials?.length" class="text-[11px] text-red-400">
+          {{
+            t('settings.toolServers.refusedCredentials', {
+              keys: resultFor(server.id)!.refusedCredentials!.join(', '),
+            })
+          }}
+        </p>
+
+        <!-- Raw backend prose is DETAIL behind a disclosure, never the primary description. It is
+             already scrubbed through `redactSecrets` at the emit site. -->
+        <template v-if="resultFor(server.id)!.error">
+          <UButton
+            size="xs"
+            variant="link"
+            class="px-0"
+            :data-testid="`tool-server-details-${server.id}`"
+            @click="expanded[server.id] = !expanded[server.id]"
+          >
+            {{
+              expanded[server.id]
+                ? t('settings.toolServers.hideDetails')
+                : t('settings.toolServers.showDetails')
+            }}
+          </UButton>
+          <pre
+            v-if="expanded[server.id]"
+            class="overflow-x-auto rounded bg-slate-950 p-2 font-mono text-[10px] text-slate-400"
+            >{{ resultFor(server.id)!.error }}</pre>
+        </template>
+      </div>
+    </article>
+  </section>
+</template>

package/app/composables/api/toolServers.ts

@@ -0,0 +1,21 @@
+import { listToolServersContract, probeToolServerContract } from '@cat-factory/contracts'
+import type { ApiContext } from './context'
+
+/**
+ * Per-workspace tool-server (MCP) operability: the inventory of what this deployment declared, and
+ * a probe that speaks the protocol to one of them.
+ *
+ * `secrets.manage`-gated end to end, the READ included — the inventory names the credential keys the
+ * deployment's capabilities want and the endpoints those credentials are sent to. The probe is a
+ * POST because it SPENDS an outbound request under the deployment's own credential, so it must not
+ * be safe to retry from a cache or a prefetch. See ToolServerController.
+ */
+export function toolServersApi({ send, ws }: ApiContext) {
+  return {
+    listToolServers: (workspaceId: string) =>
+      send(listToolServersContract, { pathPrefix: ws(workspaceId) }),
+
+    probeToolServer: (workspaceId: string, id: string) =>
+      send(probeToolServerContract, { pathPrefix: ws(workspaceId), pathParams: { id } }),
+  }
+}

package/app/composables/useApi.ts

@@ -33,6 +33,7 @@ import { modelsApi } from './api/models'
 import { notificationsApi } from './api/notifications'
 import { packageRegistriesApi } from './api/packageRegistries'
 import { capabilityCredentialsApi } from './api/capabilityCredentials'
+import { toolServersApi } from './api/toolServers'
 import { preflightsApi } from './api/preflights'
 import { presetsApi } from './api/presets'
 import { publicApiKeysApi } from './api/publicApiKeys'
@@ -156,6 +157,7 @@ export function useApi() {
     ...testSecretsApi(ctx),
     ...packageRegistriesApi(ctx),
     ...capabilityCredentialsApi(ctx),
+    ...toolServersApi(ctx),
     ...previewApi(ctx),
     ...environmentsApi(ctx),
     ...recurringApi(ctx),

package/app/stores/toolServers.spec.ts

@@ -0,0 +1,142 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import { useToolServersStore } from '~/stores/toolServers'
+import { useWorkspaceStore } from '~/stores/workspace'
+import type { ToolServerProbeResult, ToolServerView } from '~/types/toolServers'
+
+/**
+ * Three behaviours carry this store, each about not losing an answer:
+ *
+ *   - the availability probe. A 403 ("you may not manage secrets") is an ANSWER and resolves
+ *     normally, hiding the surface; anything else propagates, because the panel is what can tell a
+ *     reader the list could not be fetched. There is deliberately no 503 case, unlike the
+ *     credential store: projecting a registry needs no encryption key.
+ *   - a probe result is kept for every VERDICT, failures included. A failure is exactly the answer
+ *     the operator asked for, and a store that only kept successes would leave the row looking
+ *     untouched after a dead endpoint was reported.
+ *   - results survive a re-read of the inventory, because a result describes the SERVER rather than
+ *     the list it arrived in.
+ */
+function server(over: Partial<ToolServerView> = {}): ToolServerView {
+  return {
+    id: 'issues',
+    label: 'Issue tracker',
+    transport: 'http',
+    target: 'https://mcp.example/rpc',
+    declaredBy: ['coder'],
+    servableHarnesses: ['claude-code'],
+    credentials: [],
+    probeable: true,
+    ...over,
+  }
+}
+
+describe('toolServers store', () => {
+  beforeEach(() => {
+    useWorkspaceStore().workspaceId = 'ws1'
+  })
+
+  it('load stores the inventory and marks the surface available', async () => {
+    vi.stubGlobal('useApi', () => ({
+      listToolServers: () => Promise.resolve({ servers: [server()] }),
+    }))
+
+    const store = useToolServersStore()
+    await store.load()
+
+    expect(store.available).toBe(true)
+    expect(store.hasSurface).toBe(true)
+    expect(store.loading).toBe(false)
+  })
+
+  it('shares one read between concurrent callers', async () => {
+    let reads = 0
+    vi.stubGlobal('useApi', () => ({
+      listToolServers: () => {
+        reads++
+        return Promise.resolve({ servers: [server()] })
+      },
+    }))
+
+    const store = useToolServersStore()
+    // Both callers fire on the same interaction: the Infrastructure window asks `ensureLoaded` whether
+    // the tab exists at all, and the panel refreshes on mount so a redeploy shows up without a reload.
+    // A read that started microseconds ago IS that refresh, so it is shared rather than duplicated.
+    await Promise.all([store.ensureLoaded(), store.load()])
+
+    expect(reads).toBe(1)
+    expect(store.hasSurface).toBe(true)
+  })
+
+  it('a 403 latches the surface unavailable without throwing', async () => {
+    vi.stubGlobal('useApi', () => ({
+      listToolServers: () => Promise.reject({ statusCode: 403 }),
+    }))
+
+    const store = useToolServersStore()
+    await expect(store.load()).resolves.toBeUndefined()
+
+    expect(store.available).toBe(false)
+    expect(store.hasSurface).toBe(false)
+  })
+
+  it('a transient failure propagates and latches nothing', async () => {
+    vi.stubGlobal('useApi', () => ({
+      listToolServers: () => Promise.reject({ statusCode: 500 }),
+    }))
+
+    const store = useToolServersStore()
+    await expect(store.load()).rejects.toBeDefined()
+
+    // `available` stays null so `ensureLoaded` remains retryable, and an already-loaded surface is
+    // not hidden by one bad read.
+    expect(store.available).toBeNull()
+  })
+
+  it('reports no surface for a deployment that registers no tool server', async () => {
+    vi.stubGlobal('useApi', () => ({ listToolServers: () => Promise.resolve({ servers: [] }) }))
+
+    const store = useToolServersStore()
+    await store.load()
+
+    // An answer rather than possibly an outage: the inventory is read off this process's own
+    // registry, which is why there is no `declarationsIncomplete` counterpart here.
+    expect(store.available).toBe(true)
+    expect(store.hasSurface).toBe(false)
+  })
+
+  it('keeps a FAILING probe result, and keeps it across a re-read of the inventory', async () => {
+    const failure: ToolServerProbeResult = {
+      serverId: 'issues',
+      status: 'unreachable',
+      error: 'TypeError: fetch failed',
+    }
+    vi.stubGlobal('useApi', () => ({
+      listToolServers: () => Promise.resolve({ servers: [server()] }),
+      probeToolServer: () => Promise.resolve(failure),
+    }))
+
+    const store = useToolServersStore()
+    await store.load()
+    await store.probe('issues')
+
+    expect(store.results.issues).toEqual(failure)
+    expect(store.probing).toBeNull()
+
+    await store.load()
+    expect(store.results.issues).toEqual(failure)
+  })
+
+  it('propagates a THROWN probe failure without storing a verdict', async () => {
+    // A 404 for a server the deployment has since dropped, or a transient 5xx: not a verdict, so the
+    // row must not claim the probe answered.
+    vi.stubGlobal('useApi', () => ({
+      probeToolServer: () => Promise.reject({ statusCode: 404 }),
+    }))
+
+    const store = useToolServersStore()
+    await expect(store.probe('ghost')).rejects.toBeDefined()
+
+    expect(store.results.ghost).toBeUndefined()
+    expect(store.probing).toBeNull()
+  })
+})

package/app/stores/toolServers.ts

@@ -0,0 +1,112 @@
+import { defineStore } from 'pinia'
+import { computed, ref } from 'vue'
+import type { ToolServerProbeResult, ToolServersView } from '~/types/toolServers'
+import { useWorkspaceStore } from '~/stores/workspace'
+import { apiErrorStatus } from '~/composables/api/errors'
+
+/**
+ * The deployment's tool servers (MCP) and the results of probing them.
+ *
+ * Two halves with different lifetimes, which is why they are separate refs. The INVENTORY is
+ * deployment code: it changes when the deployment redeploys, so it is loaded on demand and re-read
+ * rather than patched. A PROBE RESULT is a moment in time and belongs to the operator who asked for
+ * it, so results are kept per server id and never fetched eagerly — a probe spends an outbound
+ * request under the deployment's own credential, so opening a panel must not fire one.
+ *
+ * Mirrors the capability-credential store's availability handling deliberately: the two surfaces sit
+ * in one tab, gate on the same permission, and a member without it must see neither.
+ */
+export const useToolServersStore = defineStore('toolServers', () => {
+  const api = useApi()
+
+  const view = ref<ToolServersView | null>(null)
+  // Probe results by server id. Kept after a re-read of the inventory: a result describes the server
+  // rather than the list it arrived in, and dropping it on refresh would erase the answer the
+  // operator just asked for.
+  const results = ref<Record<string, ToolServerProbeResult>>({})
+  const probing = ref<string | null>(null)
+  const loading = ref(false)
+  // The backend's two definitive refusals: no `secrets.manage` (403), and — unlike the credential
+  // store — never a 503, since the inventory needs no encryption key to project a registry. `null`
+  // until first probed. A 403 HIDES the surface rather than disabling it, because the inventory
+  // names the deployment's credential keys and its endpoints.
+  const available = ref<boolean | null>(null)
+  let inFlight: Promise<void> | null = null
+
+  /**
+   * Whether there is anything to show. A deployment that registers no tool server has no row to
+   * render, and the panel section is hidden rather than rendering an empty heading.
+   *
+   * No `declarationsIncomplete` counterpart here, unlike the credential checklist: the inventory is
+   * read straight off this process's own registry, so an empty answer is an answer rather than
+   * possibly an outage.
+   */
+  const hasSurface = computed(() => (view.value?.servers.length ?? 0) > 0)
+
+  /**
+   * Refresh the inventory, sharing a read that is already in flight.
+   *
+   * Coalescing belongs on `load` and not only on `ensureLoaded` because both callers fire on the
+   * same interaction: the Infrastructure window calls `ensureLoaded` to decide whether the tab
+   * exists at all, and the panel refreshes on mount so a redeploy shows up without a reload. Two
+   * identical GETs per open is what a plain "force" would have cost, and a read that started
+   * microseconds ago IS the refresh.
+   */
+  async function load() {
+    if (inFlight) return inFlight
+    inFlight = readInventory().finally(() => (inFlight = null))
+    return inFlight
+  }
+
+  async function readInventory() {
+    const ws = useWorkspaceStore()
+    loading.value = true
+    try {
+      view.value = await api.listToolServers(ws.requireId())
+      available.value = true
+    } catch (err) {
+      if (apiErrorStatus(err) === 403) {
+        // A definitive answer, not a failure: this caller may not manage secrets. Hide the surface
+        // and stop probing; resolve normally.
+        available.value = false
+        view.value = null
+        return
+      }
+      // Any other failure (transient 5xx / network) leaves the state untouched, so it neither hides
+      // an available panel nor caches a false "unavailable", and PROPAGATES: the panel is the one
+      // surface that can tell a reader it is looking at a list we could not fetch. Same split as the
+      // capability-credential store.
+      throw err
+    } finally {
+      loading.value = false
+    }
+  }
+
+  /** Load once and stay loaded; `load()` re-reads (both share whatever is in flight). */
+  async function ensureLoaded() {
+    if (available.value !== null) return
+    return load()
+  }
+
+  /**
+   * Probe ONE server and keep its result.
+   *
+   * The result is stored for every outcome, failures included: a failure IS the answer the operator
+   * asked for, and a store that only kept successes would leave the row looking untouched after the
+   * probe reported a dead endpoint. A thrown error (a 404 for a server the deployment has since
+   * dropped, a transient 5xx) propagates instead, because those are not probe verdicts.
+   */
+  async function probe(id: string) {
+    const ws = useWorkspaceStore()
+    probing.value = id
+    try {
+      const result = await api.probeToolServer(ws.requireId(), id)
+      results.value = { ...results.value, [id]: result }
+      return result
+    } finally {
+      probing.value = null
+    }
+  }
+
+  return { view, results, probing, loading, available, hasSurface, load, ensureLoaded, probe }
+})

package/app/types/toolServers.ts

@@ -0,0 +1,17 @@
+// Tool server (MCP) operability shapes: what this deployment declared, and what a probe answered.
+//
+// All wire shapes are sourced from @cat-factory/contracts (single source of truth). The probe
+// STATUS and the not-probeable REASON in particular are vocabularies both sides must agree about —
+// the backend decides them, this app maps each member to translated copy plus a remedy — so a
+// member added on one side only renders as a blank chip rather than failing to compile.
+
+export type {
+  ToolServerAllowedToolsCheck,
+  ToolServerCredential,
+  ToolServerNotProbeableReason,
+  ToolServerProbeResult,
+  ToolServerProbeStatus,
+  ToolServerTransport,
+  ToolServerView,
+  ToolServersView,
+} from '@cat-factory/contracts'

package/i18n/locales/de.json

@@ -606,6 +606,48 @@
         "removeFailed": "Der Registry-Eintrag konnte nicht entfernt werden"
       }
     },
+    "toolServers": {
+      "heading": "Werkzeugserver (MCP)",
+      "intro": "Die MCP-Server, die diese Installation für ihre Agenten registriert. Ein Test löst die Zugangsdaten dieses Boards auf und spricht das Protokoll mit dem Server, das Ergebnis entspricht also dem, was ein Lauf erhält.",
+      "transport": {
+        "stdio": "Im Container",
+        "http": "Extern"
+      },
+      "declaredBy": "Zugewiesen an: {kinds}",
+      "declaredByNone": "Kein Agent erhält diesen Server, daher startet ihn kein Lauf.",
+      "servableHarnesses": "Läuft mit: {harnesses}",
+      "servableHarnessesNone": "Keine Agenten-CLI kann diesen Transport bedienen, daher greift dieser Server in keinem Lauf.",
+      "allowedTools": "Eingeschränkt auf: {tools}",
+      "credentials": "Zugangsdaten: {keys}",
+      "test": "Testen",
+      "notProbeable": {
+        "stdio": "Läuft im Container des Agenten und kann von hier aus nicht getestet werden.",
+        "containerLocal": "Lauscht neben dem Agenten in dessen eigenem Container, der von hier aus nicht erreichbar ist.",
+        "urlNotAllowed": "Unter dieser Adresse darf ein Werkzeugserver nicht erreicht werden (https oder einfaches http nur auf localhost)."
+      },
+      "status": {
+        "ok": "Hat geantwortet",
+        "credentialsMissing": "Keine Zugangsdaten",
+        "credentialRefused": "Zugangsdaten abgelehnt",
+        "unreachable": "Keine Antwort",
+        "httpError": "Anfrage abgewiesen",
+        "protocolError": "Kein MCP-Server",
+        "notProbeable": "Von hier nicht testbar"
+      },
+      "okDetail": "{name} {version}, Protokoll {protocol}, {count} Werkzeuge.",
+      "toolsIncomplete": "Der Server hat mehr Werkzeuge, als ein Test liest, diese Zahl ist also ein Mindestwert.",
+      "unmatchedTools": "Dieser Server bietet kein Werkzeug namens {tools}, dem Agenten wird also ein Werkzeug angekündigt, das er nicht aufrufen kann.",
+      "allowedToolsUnchecked": "Die Werkzeugliste war zu lang, um sie vollständig zu lesen, daher konnten die eingeschränkten Namen nicht geprüft werden.",
+      "unresolvedCredentials": "Für {keys} wurde nichts aufgelöst. Trage den Wert unten ein oder setze ihn in der Umgebung der Installation.",
+      "refusedCredentials": "{keys} benennt eine Variable, die zur Konfiguration der Plattform selbst gehört, und wird daher nie aufgelöst. Ändere die Deklaration im Code der Installation.",
+      "httpStatus": "HTTP {status}",
+      "showDetails": "Details anzeigen",
+      "hideDetails": "Details verbergen",
+      "toast": {
+        "loadFailed": "Die Werkzeugserver konnten nicht geladen werden",
+        "probeFailed": "Der Werkzeugserver konnte nicht getestet werden"
+      }
+    },
     "capabilityCredentials": {
       "tab": "Zugangsdaten für Fähigkeiten",
       "intro": "Die Secrets, die die Tool-Server und generativen Integrationen dieser Installation namentlich anfordern. Werte gelten nur für dieses Board, werden verschlüsselt gespeichert und direkt an den Prozess des Agenten übergeben: Sie erscheinen weder in einem Prompt noch in einem Log. Werte lassen sich nur schreiben, nie auslesen, ein gespeicherter Wert wird also durch Eingabe eines neuen ersetzt.",

package/i18n/locales/en.json

@@ -3086,6 +3086,48 @@
         "removeFailed": "Could not remove the registry entry"
       }
     },
+    "toolServers": {
+      "heading": "Tool servers (MCP)",
+      "intro": "The MCP servers this deployment registers for its agents. Testing one resolves this board's credentials and speaks the protocol to the server, so the result is what a run would get.",
+      "transport": {
+        "stdio": "In the container",
+        "http": "Remote"
+      },
+      "declaredBy": "Given to: {kinds}",
+      "declaredByNone": "No agent gets this server, so no run will ever start it.",
+      "servableHarnesses": "Works on: {harnesses}",
+      "servableHarnessesNone": "No agent CLI can serve this transport, so this server never applies to any run.",
+      "allowedTools": "Narrowed to: {tools}",
+      "credentials": "Credentials: {keys}",
+      "test": "Test",
+      "notProbeable": {
+        "stdio": "Runs inside the agent's container, so it cannot be tested from here.",
+        "containerLocal": "Listens beside the agent in its own container, which is not reachable from here.",
+        "urlNotAllowed": "The address is not one a tool server may be reached at (https, or plain http on localhost)."
+      },
+      "status": {
+        "ok": "Answered",
+        "credentialsMissing": "No credential",
+        "credentialRefused": "Credential refused",
+        "unreachable": "No answer",
+        "httpError": "Rejected the request",
+        "protocolError": "Not an MCP server",
+        "notProbeable": "Cannot be tested from here"
+      },
+      "okDetail": "{name} {version}, protocol {protocol}, {count} tools.",
+      "toolsIncomplete": "The server has more tools than one test reads, so this count is a minimum.",
+      "unmatchedTools": "This server exposes no tool called {tools}, so the agent is told about a tool it cannot call.",
+      "allowedToolsUnchecked": "The tool list was too long to read in full, so the narrowed names could not be checked.",
+      "unresolvedCredentials": "Nothing resolved for {keys}. Fill it in below, or set it in the deployment's environment.",
+      "refusedCredentials": "{keys} names a variable the platform's own configuration owns, so it is never resolved. Change the declaration in the deployment's code.",
+      "httpStatus": "HTTP {status}",
+      "showDetails": "Show details",
+      "hideDetails": "Hide details",
+      "toast": {
+        "loadFailed": "Could not load the tool servers",
+        "probeFailed": "Could not test the tool server"
+      }
+    },
     "capabilityCredentials": {
       "tab": "Capability credentials",
       "intro": "The secrets this deployment's tool servers and generative integrations ask for by name. Values are stored for this board only, sealed at rest, and handed straight to the agent's process: they never reach a prompt or a log. Values are write-only, so a stored one is replaced by typing a new one and never read back.",

package/i18n/locales/es.json

@@ -2838,6 +2838,48 @@
         "removeFailed": "No se pudo eliminar la entrada del registro"
       }
     },
+    "toolServers": {
+      "heading": "Servidores de herramientas (MCP)",
+      "intro": "Los servidores MCP que esta instalación registra para sus agentes. Al probar uno se resuelven las credenciales de este tablero y se habla el protocolo con el servidor, así que el resultado es el que obtendría una ejecución.",
+      "transport": {
+        "stdio": "En el contenedor",
+        "http": "Remoto"
+      },
+      "declaredBy": "Asignado a: {kinds}",
+      "declaredByNone": "Ningún agente recibe este servidor, así que ninguna ejecución lo iniciará.",
+      "servableHarnesses": "Funciona con: {harnesses}",
+      "servableHarnessesNone": "Ninguna CLI de agente puede servir este transporte, así que este servidor nunca se aplica a una ejecución.",
+      "allowedTools": "Limitado a: {tools}",
+      "credentials": "Credenciales: {keys}",
+      "test": "Probar",
+      "notProbeable": {
+        "stdio": "Se ejecuta dentro del contenedor del agente, así que no puede probarse desde aquí.",
+        "containerLocal": "Escucha junto al agente en su propio contenedor, que no es accesible desde aquí.",
+        "urlNotAllowed": "Esta dirección no es válida para un servidor de herramientas (https, o http simple solo en localhost)."
+      },
+      "status": {
+        "ok": "Respondió",
+        "credentialsMissing": "Sin credencial",
+        "credentialRefused": "Credencial rechazada",
+        "unreachable": "Sin respuesta",
+        "httpError": "Rechazó la solicitud",
+        "protocolError": "No es un servidor MCP",
+        "notProbeable": "No se puede probar desde aquí"
+      },
+      "okDetail": "{name} {version}, protocolo {protocol}, {count} herramientas.",
+      "toolsIncomplete": "El servidor tiene más herramientas de las que lee una prueba, así que este número es un mínimo.",
+      "unmatchedTools": "Este servidor no expone ninguna herramienta llamada {tools}, así que al agente se le anuncia una herramienta que no puede invocar.",
+      "allowedToolsUnchecked": "La lista de herramientas era demasiado larga para leerla completa, así que no se pudieron comprobar los nombres limitados.",
+      "unresolvedCredentials": "No se resolvió nada para {keys}. Rellénalo abajo o defínelo en el entorno de la instalación.",
+      "refusedCredentials": "{keys} nombra una variable que pertenece a la configuración de la propia plataforma, así que nunca se resuelve. Cambia la declaración en el código de la instalación.",
+      "httpStatus": "HTTP {status}",
+      "showDetails": "Ver detalles",
+      "hideDetails": "Ocultar detalles",
+      "toast": {
+        "loadFailed": "No se pudieron cargar los servidores de herramientas",
+        "probeFailed": "No se pudo probar el servidor de herramientas"
+      }
+    },
     "capabilityCredentials": {
       "tab": "Credenciales de capacidades",
       "intro": "Los secretos que los servidores de herramientas y las integraciones generativas de esta instalación piden por nombre. Los valores se guardan solo para este tablero, cifrados en reposo, y se entregan directamente al proceso del agente: nunca llegan a un prompt ni a un registro. Los valores son de solo escritura, así que uno guardado se sustituye escribiendo otro y nunca se vuelve a leer.",

package/i18n/locales/fr.json

@@ -2838,6 +2838,48 @@
         "removeFailed": "Impossible de supprimer l'entrée du registre"
       }
     },
+    "toolServers": {
+      "heading": "Serveurs d’outils (MCP)",
+      "intro": "Les serveurs MCP que ce déploiement enregistre pour ses agents. Tester un serveur résout les identifiants de ce tableau et parle le protocole avec lui : le résultat est donc celui qu’obtiendrait une exécution.",
+      "transport": {
+        "stdio": "Dans le conteneur",
+        "http": "Distant"
+      },
+      "declaredBy": "Attribué à : {kinds}",
+      "declaredByNone": "Aucun agent ne reçoit ce serveur, donc aucune exécution ne le démarrera.",
+      "servableHarnesses": "Fonctionne avec : {harnesses}",
+      "servableHarnessesNone": "Aucune CLI d’agent ne peut servir ce transport, donc ce serveur ne s’applique à aucune exécution.",
+      "allowedTools": "Restreint à : {tools}",
+      "credentials": "Identifiants : {keys}",
+      "test": "Tester",
+      "notProbeable": {
+        "stdio": "Il s’exécute dans le conteneur de l’agent et ne peut donc pas être testé d’ici.",
+        "containerLocal": "Il écoute à côté de l’agent, dans son propre conteneur, qui n’est pas joignable d’ici.",
+        "urlNotAllowed": "Cette adresse n’est pas autorisée pour un serveur d’outils (https, ou http simple sur localhost uniquement)."
+      },
+      "status": {
+        "ok": "A répondu",
+        "credentialsMissing": "Aucun identifiant",
+        "credentialRefused": "Identifiant refusé",
+        "unreachable": "Aucune réponse",
+        "httpError": "Requête rejetée",
+        "protocolError": "Pas un serveur MCP",
+        "notProbeable": "Non testable d’ici"
+      },
+      "okDetail": "{name} {version}, protocole {protocol}, {count} outils.",
+      "toolsIncomplete": "Le serveur expose plus d’outils qu’un test n’en lit : ce nombre est donc un minimum.",
+      "unmatchedTools": "Ce serveur n’expose aucun outil nommé {tools} : l’agent se voit donc annoncer un outil qu’il ne peut pas appeler.",
+      "allowedToolsUnchecked": "La liste d’outils était trop longue pour être lue en entier, les noms restreints n’ont donc pas pu être vérifiés.",
+      "unresolvedCredentials": "Rien n’a été résolu pour {keys}. Renseignez la valeur ci-dessous, ou définissez-la dans l’environnement du déploiement.",
+      "refusedCredentials": "{keys} désigne une variable qui appartient à la configuration de la plateforme elle-même : elle n’est jamais résolue. Modifiez la déclaration dans le code du déploiement.",
+      "httpStatus": "HTTP {status}",
+      "showDetails": "Afficher les détails",
+      "hideDetails": "Masquer les détails",
+      "toast": {
+        "loadFailed": "Impossible de charger les serveurs d’outils",
+        "probeFailed": "Impossible de tester le serveur d’outils"
+      }
+    },
     "capabilityCredentials": {
       "tab": "Identifiants des capacités",
       "intro": "Les secrets que les serveurs d'outils et les intégrations génératives de ce déploiement réclament par leur nom. Les valeurs ne sont enregistrées que pour ce tableau, chiffrées au repos, et remises directement au processus de l'agent : elles n'apparaissent ni dans un prompt ni dans un journal. Les valeurs sont en écriture seule, une valeur enregistrée se remplace donc en en saisissant une nouvelle et n'est jamais relue.",

package/i18n/locales/he.json

@@ -2979,6 +2979,48 @@
         "removeFailed": "הסרת רשומת המאגר נכשלה"
       }
     },
+    "toolServers": {
+      "heading": "שרתי כלים (MCP)",
+      "intro": "שרתי ה-MCP שהתקנה זו רושמת עבור הסוכנים שלה. בדיקה מאתרת את פרטי ההזדהות של לוח זה ומדברת עם השרת בפרוטוקול, כך שהתוצאה היא מה שהרצה תקבל.",
+      "transport": {
+        "stdio": "בתוך המכולה",
+        "http": "מרוחק"
+      },
+      "declaredBy": "משויך אל: {kinds}",
+      "declaredByNone": "אף סוכן אינו מקבל שרת זה, ולכן אף הרצה לא תפעיל אותו.",
+      "servableHarnesses": "עובד עם: {harnesses}",
+      "servableHarnessesNone": "אף CLI של סוכן אינו יכול לשרת תעבורה זו, ולכן שרת זה לא חל על שום הרצה.",
+      "allowedTools": "מוגבל אל: {tools}",
+      "credentials": "פרטי הזדהות: {keys}",
+      "test": "בדיקה",
+      "notProbeable": {
+        "stdio": "רץ בתוך המכולה של הסוכן, ולכן לא ניתן לבדוק אותו מכאן.",
+        "containerLocal": "מאזין לצד הסוכן במכולה שלו, שאינה נגישה מכאן.",
+        "urlNotAllowed": "אין זו כתובת שבה מותר להגיע לשרת כלים (https, או http פשוט רק ב-localhost)."
+      },
+      "status": {
+        "ok": "השיב",
+        "credentialsMissing": "אין פרטי הזדהות",
+        "credentialRefused": "פרטי ההזדהות נדחו",
+        "unreachable": "אין תשובה",
+        "httpError": "דחה את הבקשה",
+        "protocolError": "אינו שרת MCP",
+        "notProbeable": "לא ניתן לבדוק מכאן"
+      },
+      "okDetail": "{name} {version}, פרוטוקול {protocol}, {count} כלים.",
+      "toolsIncomplete": "לשרת יש יותר כלים ממה שבדיקה אחת קוראת, ולכן מספר זה הוא מינימום.",
+      "unmatchedTools": "שרת זה אינו חושף כלי בשם {tools}, ולכן מסופר לסוכן על כלי שאינו יכול לקרוא לו.",
+      "allowedToolsUnchecked": "רשימת הכלים הייתה ארוכה מכדי לקרוא אותה במלואה, ולכן לא ניתן היה לבדוק את השמות המוגבלים.",
+      "unresolvedCredentials": "לא אותר דבר עבור {keys}. מלאו את הערך למטה, או הגדירו אותו בסביבת ההתקנה.",
+      "refusedCredentials": "{keys} מציין משתנה שהוא חלק מהתצורה של הפלטפורמה עצמה, ולכן הוא לעולם אינו מאותר. שנו את ההצהרה בקוד ההתקנה.",
+      "httpStatus": "HTTP {status}",
+      "showDetails": "הצגת פרטים",
+      "hideDetails": "הסתרת פרטים",
+      "toast": {
+        "loadFailed": "לא ניתן לטעון את שרתי הכלים",
+        "probeFailed": "לא ניתן לבדוק את שרת הכלים"
+      }
+    },
     "capabilityCredentials": {
       "tab": "אישורי גישה ליכולות",
       "intro": "הסודות ששרתי הכלים והאינטגרציות הגנרטיביות של הפריסה הזו מבקשים לפי שם. הערכים נשמרים ללוח הזה בלבד, מוצפנים במנוחה ומועברים ישירות לתהליך של הסוכן: הם לעולם לא מגיעים להנחיה או ליומן. הערכים ניתנים לכתיבה בלבד, ולכן ערך שמור מוחלף בהקלדת ערך חדש ולעולם אינו נקרא בחזרה.",

package/i18n/locales/it.json

@@ -606,6 +606,48 @@
         "removeFailed": "Impossibile rimuovere la voce del registry"
       }
     },
+    "toolServers": {
+      "heading": "Server di strumenti (MCP)",
+      "intro": "I server MCP che questa installazione registra per i suoi agenti. Provarne uno risolve le credenziali di questa bacheca e parla il protocollo con il server, quindi il risultato è quello che otterrebbe un’esecuzione.",
+      "transport": {
+        "stdio": "Nel container",
+        "http": "Remoto"
+      },
+      "declaredBy": "Assegnato a: {kinds}",
+      "declaredByNone": "Nessun agente riceve questo server, quindi nessuna esecuzione lo avvierà.",
+      "servableHarnesses": "Funziona con: {harnesses}",
+      "servableHarnessesNone": "Nessuna CLI di agente può servire questo trasporto, quindi questo server non si applica a nessuna esecuzione.",
+      "allowedTools": "Limitato a: {tools}",
+      "credentials": "Credenziali: {keys}",
+      "test": "Prova",
+      "notProbeable": {
+        "stdio": "Gira dentro il container dell’agente, quindi non può essere provato da qui.",
+        "containerLocal": "Ascolta accanto all’agente nel suo container, che non è raggiungibile da qui.",
+        "urlNotAllowed": "Questo indirizzo non è consentito per un server di strumenti (https, oppure http semplice solo su localhost)."
+      },
+      "status": {
+        "ok": "Ha risposto",
+        "credentialsMissing": "Nessuna credenziale",
+        "credentialRefused": "Credenziale rifiutata",
+        "unreachable": "Nessuna risposta",
+        "httpError": "Richiesta respinta",
+        "protocolError": "Non è un server MCP",
+        "notProbeable": "Non provabile da qui"
+      },
+      "okDetail": "{name} {version}, protocollo {protocol}, {count} strumenti.",
+      "toolsIncomplete": "Il server ha più strumenti di quanti una prova ne legga, quindi questo numero è un minimo.",
+      "unmatchedTools": "Questo server non espone alcuno strumento chiamato {tools}, quindi all’agente viene annunciato uno strumento che non può invocare.",
+      "allowedToolsUnchecked": "L’elenco degli strumenti era troppo lungo per leggerlo tutto, quindi i nomi limitati non hanno potuto essere verificati.",
+      "unresolvedCredentials": "Nulla è stato risolto per {keys}. Inseriscilo qui sotto, oppure impostalo nell’ambiente dell’installazione.",
+      "refusedCredentials": "{keys} nomina una variabile che appartiene alla configurazione della piattaforma stessa, quindi non viene mai risolta. Modifica la dichiarazione nel codice dell’installazione.",
+      "httpStatus": "HTTP {status}",
+      "showDetails": "Mostra dettagli",
+      "hideDetails": "Nascondi dettagli",
+      "toast": {
+        "loadFailed": "Impossibile caricare i server di strumenti",
+        "probeFailed": "Impossibile provare il server di strumenti"
+      }
+    },
     "capabilityCredentials": {
       "tab": "Credenziali delle capacità",
       "intro": "I segreti che i server di strumenti e le integrazioni generative di questo deployment richiedono per nome. I valori vengono salvati solo per questa board, cifrati a riposo, e consegnati direttamente al processo dell'agente: non finiscono mai in un prompt né in un log. I valori sono di sola scrittura, quindi uno salvato si sostituisce digitandone uno nuovo e non viene mai riletto.",

package/i18n/locales/ja.json

@@ -2979,6 +2979,48 @@
         "removeFailed": "レジストリエントリを削除できませんでした"
       }
     },
+    "toolServers": {
+      "heading": "ツールサーバー (MCP)",
+      "intro": "このデプロイがエージェント向けに登録している MCP サーバーです。テストするとこのボードの認証情報を解決してサーバーとプロトコルで通信するため、結果は実行時に得られるものと同じです。",
+      "transport": {
+        "stdio": "コンテナ内",
+        "http": "リモート"
+      },
+      "declaredBy": "割り当て先: {kinds}",
+      "declaredByNone": "どのエージェントにも渡されていないため、どの実行でも起動されません。",
+      "servableHarnesses": "対応 CLI: {harnesses}",
+      "servableHarnessesNone": "このトランスポートを扱えるエージェント CLI がないため、このサーバーはどの実行にも適用されません。",
+      "allowedTools": "許可されたツール: {tools}",
+      "credentials": "認証情報: {keys}",
+      "test": "テスト",
+      "notProbeable": {
+        "stdio": "エージェントのコンテナ内で動作するため、ここからはテストできません。",
+        "containerLocal": "エージェントと同じコンテナ内で待ち受けているため、ここからは到達できません。",
+        "urlNotAllowed": "ツールサーバーの接続先として許可されていないアドレスです (https、または localhost の平文 http のみ)。"
+      },
+      "status": {
+        "ok": "応答あり",
+        "credentialsMissing": "認証情報なし",
+        "credentialRefused": "認証情報を拒否",
+        "unreachable": "応答なし",
+        "httpError": "リクエストを拒否",
+        "protocolError": "MCP サーバーではない",
+        "notProbeable": "ここからテストできない"
+      },
+      "okDetail": "{name} {version}、プロトコル {protocol}、ツール {count} 個。",
+      "toolsIncomplete": "サーバーは 1 回のテストで読み取れる数を超えるツールを持つため、この数は最小値です。",
+      "unmatchedTools": "このサーバーに {tools} というツールは存在しないため、エージェントは呼び出せないツールを知らされています。",
+      "allowedToolsUnchecked": "ツール一覧が長すぎて全部を読み取れなかったため、絞り込んだ名前は確認できませんでした。",
+      "unresolvedCredentials": "{keys} の値が解決できませんでした。下で入力するか、デプロイの環境変数に設定してください。",
+      "refusedCredentials": "{keys} はプラットフォーム自身の設定に属する変数名なので、決して解決されません。デプロイのコード側の宣言を変更してください。",
+      "httpStatus": "HTTP {status}",
+      "showDetails": "詳細を表示",
+      "hideDetails": "詳細を隠す",
+      "toast": {
+        "loadFailed": "ツールサーバーを読み込めませんでした",
+        "probeFailed": "ツールサーバーをテストできませんでした"
+      }
+    },
     "capabilityCredentials": {
       "tab": "機能の認証情報",
       "intro": "このデプロイのツールサーバーと生成系インテグレーションが名前で要求するシークレットです。値はこのボードにのみ保存され、保管時は暗号化され、エージェントのプロセスへ直接渡されます。プロンプトにもログにも現れません。値は書き込み専用なので、保存済みの値は新しい値を入力して置き換えるだけで、読み出すことはできません。",

package/i18n/locales/pl.json

@@ -2838,6 +2838,48 @@
         "removeFailed": "Nie udało się usunąć wpisu rejestru"
       }
     },
+    "toolServers": {
+      "heading": "Serwery narzędzi (MCP)",
+      "intro": "Serwery MCP, które ta instalacja rejestruje dla swoich agentów. Test rozwiązuje dane uwierzytelniające tej tablicy i rozmawia z serwerem protokołem, więc wynik jest taki, jaki otrzymałby przebieg.",
+      "transport": {
+        "stdio": "W kontenerze",
+        "http": "Zdalny"
+      },
+      "declaredBy": "Przypisany do: {kinds}",
+      "declaredByNone": "Żaden agent nie otrzymuje tego serwera, więc żaden przebieg go nie uruchomi.",
+      "servableHarnesses": "Działa z: {harnesses}",
+      "servableHarnessesNone": "Żadne CLI agenta nie obsługuje tego transportu, więc ten serwer nie dotyczy żadnego przebiegu.",
+      "allowedTools": "Zawężone do: {tools}",
+      "credentials": "Dane uwierzytelniające: {keys}",
+      "test": "Testuj",
+      "notProbeable": {
+        "stdio": "Działa w kontenerze agenta, więc nie można go przetestować z tego miejsca.",
+        "containerLocal": "Nasłuchuje obok agenta w jego własnym kontenerze, który jest tu nieosiągalny.",
+        "urlNotAllowed": "Pod tym adresem serwer narzędzi nie może być osiągany (https albo zwykłe http tylko na localhost)."
+      },
+      "status": {
+        "ok": "Odpowiedział",
+        "credentialsMissing": "Brak danych uwierzytelniających",
+        "credentialRefused": "Dane uwierzytelniające odrzucone",
+        "unreachable": "Brak odpowiedzi",
+        "httpError": "Odrzucił żądanie",
+        "protocolError": "To nie serwer MCP",
+        "notProbeable": "Nie można testować z tego miejsca"
+      },
+      "okDetail": "{name} {version}, protokół {protocol}, {count} narzędzi.",
+      "toolsIncomplete": "Serwer ma więcej narzędzi, niż jeden test odczytuje, więc ta liczba to minimum.",
+      "unmatchedTools": "Ten serwer nie udostępnia narzędzia o nazwie {tools}, więc agent dowiaduje się o narzędziu, którego nie może wywołać.",
+      "allowedToolsUnchecked": "Lista narzędzi była zbyt długa, by odczytać ją w całości, więc zawężonych nazw nie dało się sprawdzić.",
+      "unresolvedCredentials": "Nic nie rozwiązano dla {keys}. Wpisz wartość poniżej albo ustaw ją w środowisku instalacji.",
+      "refusedCredentials": "{keys} nazywa zmienną należącą do konfiguracji samej platformy, więc nigdy nie jest rozwiązywana. Zmień deklarację w kodzie instalacji.",
+      "httpStatus": "HTTP {status}",
+      "showDetails": "Pokaż szczegóły",
+      "hideDetails": "Ukryj szczegóły",
+      "toast": {
+        "loadFailed": "Nie udało się wczytać serwerów narzędzi",
+        "probeFailed": "Nie udało się przetestować serwera narzędzi"
+      }
+    },
     "capabilityCredentials": {
       "tab": "Poświadczenia funkcji",
       "intro": "Sekrety, o które serwery narzędzi i integracje generatywne tego wdrożenia proszą po nazwie. Wartości są zapisywane tylko dla tej tablicy, szyfrowane w spoczynku i przekazywane wprost do procesu agenta: nigdy nie trafiają do promptu ani do logu. Wartości można tylko zapisywać, więc zapisaną zastępuje się, wpisując nową, i nigdy nie jest odczytywana.",

package/i18n/locales/tr.json

@@ -2979,6 +2979,48 @@
         "removeFailed": "Kayıt defteri girdisi kaldırılamadı"
       }
     },
+    "toolServers": {
+      "heading": "Araç sunucuları (MCP)",
+      "intro": "Bu kurulumun ajanları için kaydettiği MCP sunucuları. Bir sunucuyu test etmek bu panonun kimlik bilgilerini çözer ve sunucuyla protokol konuşur; sonuç, bir çalıştırmanın alacağı sonuçtur.",
+      "transport": {
+        "stdio": "Konteyner içinde",
+        "http": "Uzak"
+      },
+      "declaredBy": "Şu ajanlara verili: {kinds}",
+      "declaredByNone": "Hiçbir ajan bu sunucuyu almıyor, dolayısıyla hiçbir çalıştırma onu başlatmaz.",
+      "servableHarnesses": "Şunlarla çalışır: {harnesses}",
+      "servableHarnessesNone": "Hiçbir ajan CLI’si bu taşımayı sunamaz, dolayısıyla bu sunucu hiçbir çalıştırmada geçerli olmaz.",
+      "allowedTools": "Şunlarla sınırlı: {tools}",
+      "credentials": "Kimlik bilgileri: {keys}",
+      "test": "Test et",
+      "notProbeable": {
+        "stdio": "Ajanın konteynerinin içinde çalışır, bu yüzden buradan test edilemez.",
+        "containerLocal": "Ajanın yanında, onun kendi konteynerinde dinliyor; buradan erişilemez.",
+        "urlNotAllowed": "Bu adres bir araç sunucusuna erişim için uygun değil (https ya da yalnızca localhost üzerinde düz http)."
+      },
+      "status": {
+        "ok": "Yanıt verdi",
+        "credentialsMissing": "Kimlik bilgisi yok",
+        "credentialRefused": "Kimlik bilgisi reddedildi",
+        "unreachable": "Yanıt yok",
+        "httpError": "İsteği reddetti",
+        "protocolError": "MCP sunucusu değil",
+        "notProbeable": "Buradan test edilemez"
+      },
+      "okDetail": "{name} {version}, protokol {protocol}, {count} araç.",
+      "toolsIncomplete": "Sunucunun araç sayısı tek bir testin okuduğundan fazla, bu yüzden bu sayı bir alt sınırdır.",
+      "unmatchedTools": "Bu sunucu {tools} adlı bir araç sunmuyor; dolayısıyla ajana çağıramayacağı bir araç bildiriliyor.",
+      "allowedToolsUnchecked": "Araç listesi tümüyle okunacak kadar kısa değildi, bu yüzden sınırlanan adlar denetlenemedi.",
+      "unresolvedCredentials": "{keys} için hiçbir değer çözülmedi. Aşağıda doldurun ya da kurulumun ortamında tanımlayın.",
+      "refusedCredentials": "{keys}, platformun kendi yapılandırmasına ait bir değişkeni adlandırıyor, bu yüzden asla çözülmez. Kurulumun kodundaki bildirimi değiştirin.",
+      "httpStatus": "HTTP {status}",
+      "showDetails": "Ayrıntıları göster",
+      "hideDetails": "Ayrıntıları gizle",
+      "toast": {
+        "loadFailed": "Araç sunucuları yüklenemedi",
+        "probeFailed": "Araç sunucusu test edilemedi"
+      }
+    },
     "capabilityCredentials": {
       "tab": "Yetenek kimlik bilgileri",
       "intro": "Bu kurulumdaki araç sunucularının ve üretken entegrasyonların adıyla istediği sırlar. Değerler yalnızca bu pano için saklanır, beklerken şifrelenir ve doğrudan ajanın sürecine verilir: ne bir isteme ne de bir günlüğe düşer. Değerler yalnızca yazılabilir, dolayısıyla saklanan bir değer yenisi yazılarak değiştirilir ve hiçbir zaman geri okunmaz.",

package/i18n/locales/uk.json

@@ -2838,6 +2838,48 @@
         "removeFailed": "Не вдалося видалити запис реєстру"
       }
     },
+    "toolServers": {
+      "heading": "Сервери інструментів (MCP)",
+      "intro": "Сервери MCP, які ця інсталяція реєструє для своїх агентів. Перевірка розв’язує облікові дані цієї дошки і спілкується із сервером за протоколом, тож результат такий самий, який отримає запуск.",
+      "transport": {
+        "stdio": "У контейнері",
+        "http": "Віддалений"
+      },
+      "declaredBy": "Призначено: {kinds}",
+      "declaredByNone": "Жоден агент не отримує цей сервер, тож жоден запуск його не запустить.",
+      "servableHarnesses": "Працює з: {harnesses}",
+      "servableHarnessesNone": "Жоден CLI агента не може обслуговувати цей транспорт, тож цей сервер не застосовується ні до якого запуску.",
+      "allowedTools": "Звужено до: {tools}",
+      "credentials": "Облікові дані: {keys}",
+      "test": "Перевірити",
+      "notProbeable": {
+        "stdio": "Працює всередині контейнера агента, тож звідси його перевірити неможливо.",
+        "containerLocal": "Слухає поруч з агентом у його власному контейнері, який звідси недосяжний.",
+        "urlNotAllowed": "За цією адресою сервер інструментів не може бути досяжним (https або звичайний http лише на localhost)."
+      },
+      "status": {
+        "ok": "Відповів",
+        "credentialsMissing": "Немає облікових даних",
+        "credentialRefused": "Облікові дані відхилено",
+        "unreachable": "Немає відповіді",
+        "httpError": "Відхилив запит",
+        "protocolError": "Це не сервер MCP",
+        "notProbeable": "Звідси перевірити неможливо"
+      },
+      "okDetail": "{name} {version}, протокол {protocol}, інструментів: {count}.",
+      "toolsIncomplete": "Сервер має більше інструментів, ніж читає одна перевірка, тож це число є мінімумом.",
+      "unmatchedTools": "Цей сервер не надає інструмента з назвою {tools}, тож агентові повідомляють про інструмент, який він не може викликати.",
+      "allowedToolsUnchecked": "Список інструментів був завеликий, щоб прочитати його повністю, тож звужені назви перевірити не вдалося.",
+      "unresolvedCredentials": "Для {keys} нічого не розв’язано. Введіть значення нижче або задайте його в середовищі інсталяції.",
+      "refusedCredentials": "{keys} називає змінну, що належить власній конфігурації платформи, тож вона ніколи не розв’язується. Змініть оголошення в коді інсталяції.",
+      "httpStatus": "HTTP {status}",
+      "showDetails": "Показати деталі",
+      "hideDetails": "Сховати деталі",
+      "toast": {
+        "loadFailed": "Не вдалося завантажити сервери інструментів",
+        "probeFailed": "Не вдалося перевірити сервер інструментів"
+      }
+    },
     "capabilityCredentials": {
       "tab": "Облікові дані можливостей",
       "intro": "Секрети, які сервери інструментів і генеративні інтеграції цього розгортання запитують за іменем. Значення зберігаються лише для цієї дошки, зашифрованими, і передаються просто в процес агента: вони ніколи не потрапляють ані в підказку, ані в журнал. Значення доступні лише для запису, тож збережене замінюють, ввівши нове, і ніколи не читають назад.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/app",
-  "version": "0.222.0",
+  "version": "0.223.0",
   "description": "Reusable Nuxt layer for the Agent Architecture Board SPA (components, stores, composables, pages). Consume it from a thin deployment app via `extends: ['@cat-factory/app']` and point it at your backend with NUXT_PUBLIC_API_BASE. See deploy/frontend for an example.",
   "repository": {
     "type": "git",
@@ -40,7 +40,7 @@
     "valibot": "^1.4.2",
     "vue": "3.5.40",
     "wretch": "^3.0.9",
-    "@cat-factory/contracts": "0.238.0"
+    "@cat-factory/contracts": "0.239.0"
   },
   "devDependencies": {
     "@toad-contracts/testing": "0.3.2",