@anchrd/intel-ui 0.29.0 → 0.31.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anchrd/intel-ui",
-  "version": "0.29.0",
+  "version": "0.31.0",
   "type": "module",
   "license": "UNLICENSED",
   "repository": {
@@ -33,7 +33,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@anchrd/intel-contract": "^0.18.0",
+    "@anchrd/intel-contract": "^0.19.0",
     "@blocknote/core": "^0.52.1",
     "@blocknote/react": "^0.52.1",
     "@blocknote/shadcn": "^0.52.1",

package/src/flows/flows.tsx

@@ -1,6 +1,7 @@
 import type { Flow, FlowGraph, FlowNode } from "@anchrd/intel-contract/flow";
 import { flowNodeLayer } from "@anchrd/intel-contract/flow";
 import type { Node } from "@anchrd/intel-contract/node";
+import { serverOf } from "@anchrd/intel-contract/tool";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import { useNavigate, useRouterState } from "@tanstack/react-router";
 import {
@@ -367,9 +368,25 @@ function FlowsEditor() {
   const navigate = useNavigate();
   // The servers a tool step can name (#489). The flat function list the picker used to show is
   // what that ticket set out to remove; which function runs is decided while the flow runs.
+  // ⚠️ The flat function list is NOT what a step is chosen from any more (#489) — it is only what
+  // an author narrows a chosen server WITH. It is asked for regardless of whether a tool step is
+  // selected, because a query that starts when a panel opens shows a spinner inside the panel.
+  const tools = useQuery({
+    queryKey: ["tools"],
+    queryFn: () => data.listTools(),
+    // ⚠️ No retry. This query only ENRICHES the panel — the server is already chosen without it —
+    // and a retry is paused while the tab is unfocused, so a deterministic failure would leave the
+    // function list empty for as long as the reader looks away, with nothing saying why (#212).
+    retry: false,
+  });
   const toolServers = useQuery({
     queryKey: ["tool-servers"],
     queryFn: () => data.listToolServers(),
+    // ⚠️ No retry here either, and for a sharper reason than the list above: the panel shows
+    // NOTHING while this is pending. A deterministic 502 with an unfocused tab pauses the retry,
+    // and the author then sits in front of an empty server field with no sentence saying why —
+    // which is #212 exactly. `error` is a state this panel can speak; `pending` is not.
+    retry: false,
   });
   // A tree link points at a node, so the editor needs candidates. The graph is the authorized
   // flat list of them; walking the folder tree for a picker would be the N+1 all over again.
@@ -420,6 +437,13 @@ function FlowsEditor() {
   // guarantee that the loaded document is both the selected flow and settled.
   const documentReady = selectedFlowId !== null && document.data?.flow.id === selectedFlowId;
   const canMutate = documentReady && !document.isFetching;
+  // ⚠️ A tool step without a server cannot be saved at all — `ToolServerHandle` has a minimum
+  // length. Letting the request go out anyway answers with a generic failure that names no step, so
+  // the author learns "something is wrong" instead of "this one needs a server". The refusal
+  // belongs here, before the write (#517).
+  const stepsMissingServer = nodes.filter(
+    (node) => node.data.node.kind === "tool" && node.data.node.configuration.server === "",
+  );
   useEffect(() => {
     if (!document.data || document.data.flow.id !== selectedFlowId) return;
     const next = canvas(document.data.version?.graph ?? defaultGraph());
@@ -468,6 +492,7 @@ function FlowsEditor() {
           dirty={dirty}
           saving={save.isPending}
           canMutate={canMutate}
+          incomplete={stepsMissingServer.map((node) => ({ label: node.data.node.label }))}
           onSave={() => save.mutate()}
           onPublish={() => setPublishing(true)}
         />
@@ -647,6 +672,18 @@ function FlowsEditor() {
                   node={selectedNode}
                   update={updateNode}
                   toolServers={toolServers.data?.items ?? []}
+                  toolServersState={
+                    toolServers.isPending
+                      ? "pending"
+                      : toolServers.isError
+                        ? "error"
+                        : toolServers.data?.portalConnected === false
+                          ? "disconnected"
+                          : "ready"
+                  }
+                  toolNames={(tools.data?.items ?? []).map((entry) => entry.name)}
+                  toolNamesFailed={tools.isError}
+                  toolNamesPending={tools.isPending}
                   flows={(callable.data?.items ?? []).filter(
                     (entry) => entry.id !== selectedFlowId,
                   )}
@@ -707,6 +744,7 @@ function FlowTitle({
   dirty,
   saving,
   canMutate,
+  incomplete,
   onSave,
   onPublish,
 }: {
@@ -714,6 +752,9 @@ function FlowTitle({
   dirty: boolean;
   saving: boolean;
   canMutate: boolean;
+  // Tool steps that name no server yet. They cannot be saved, so the refusal is shown here rather
+  // than fetched from the server as a message that names no step.
+  incomplete: Array<{ label: string }>;
   onSave(): void;
   onPublish(): void;
 }) {
@@ -740,7 +781,16 @@ function FlowTitle({
           applies EVERYWHERE stands. But it says how THIS flow is shown, and so belongs in the line
           that names this flow. A flow is the only level with runs, and therefore the only one with
           three views (#35). */}
-      <SaveButton dirty={dirty && canMutate} saving={saving} onSave={onSave} />
+      {incomplete.length > 0 && (
+        <p className="mr-2 text-xs text-destructive">
+          {i18n.t("flows.toolStepNeedsServer", { label: incomplete[0]?.label ?? "" })}
+        </p>
+      )}
+      <SaveButton
+        dirty={dirty && canMutate && incomplete.length === 0}
+        saving={saving}
+        onSave={onSave}
+      />
       <TooltipProvider delayDuration={300}>
         <Tooltip>
           <TooltipTrigger asChild>
@@ -804,10 +854,34 @@ function PublishPreview({
       ) : (
         <>
           <p className="text-sm text-muted-foreground">
-            {preview.data.calls.length === 0
+            {preview.data.calls.length === 0 && preview.data.tools.length === 0
               ? i18n.t("flows.publishPreviewEmpty")
               : i18n.t("flows.publishPreviewIntro")}
           </p>
+          {/* ⚠️ The tool surface belongs in the preview because publishing FREEZES it: after this
+              confirmation the step is pinned to these functions and inherits nothing the provider
+              adds later. An author who is not shown it is asked to freeze something unseen (#517). */}
+          {preview.data.tools.length > 0 && (
+            <ul className="mt-4 space-y-2">
+              {preview.data.tools.map((tool) => (
+                <li key={tool.nodeId} className="rounded-md border p-3 text-sm">
+                  <span className="block font-medium">{tool.nodeLabel}</span>
+                  <span className="block text-xs text-muted-foreground">{tool.server}</span>
+                  <span
+                    className={`mt-1 block text-xs ${tool.available ? "text-muted-foreground" : "text-destructive"}`}
+                  >
+                    {!tool.available
+                      ? i18n.t("flows.publishPreviewToolUnavailable")
+                      : tool.allow === null
+                        ? i18n.t("flows.toolAllowAll")
+                        : i18n.t("flows.publishPreviewToolAllow", {
+                            functions: tool.allow.join(", "),
+                          })}
+                  </span>
+                </li>
+              ))}
+            </ul>
+          )}
           <ul className="mt-4 space-y-2">
             {preview.data.calls.map((call) => {
               // ⚠️ One condition for the sentence and its colour. They were two, so a call that
@@ -860,11 +934,29 @@ function NodeInspector({
   node,
   update,
   toolServers,
+  toolServersState,
+  toolNames,
+  toolNamesFailed,
+  toolNamesPending,
   flows,
 }: {
   node: CanvasNode | null;
   update(fn: (node: FlowNode) => FlowNode): void;
   toolServers: Array<{ handle: string; name: string; toolCount: number }>;
+  // ⚠️ FOUR answers, not two. A list that is still loading is not one that came back empty; a
+  // failure is neither; and a portal this user never connected is not a portal that reaches
+  // nothing. Drawing them all as "no servers" is the mistake #350 records for the tools screen —
+  // and the fourth one is the worst of them: it answers a SIGN-IN problem with a sentence about
+  // reach, in a place that offers no way to sign in.
+  toolServersState: "pending" | "error" | "disconnected" | "ready";
+  toolNames: string[];
+  // Told apart from "this server offers nothing": a function list that could not be loaded must not
+  // read as a narrowing that lost its functions.
+  toolNamesFailed: boolean;
+  // ⚠️ A query that has not answered is not one that answered "nothing". Without this a step opened
+  // while the catalog is still loading shows its allowed functions as missing — the panel accusing
+  // the author of a narrowing that broke, moments before the list arrives.
+  toolNamesPending: boolean;
   flows: Flow[];
 }) {
   const i18n = useI18n();
@@ -953,40 +1045,198 @@ function NodeInspector({
         </div>
       )}
       {contract.kind === "tool" && (
-        <div className="mt-4">
-          <label className="block text-sm font-medium">
-            {i18n.t("flows.tool")}
-            {/* ⚠️ The step names a SERVER since #489. This picker is the smallest thing that keeps
-                the field usable on the new model; the real one — server names from the portal plus
-                an optional narrowing to single functions — is #489's second package and is
-                deliberately not smuggled in here. */}
-            <select
-              value={contract.configuration.server}
-              onChange={(event) => {
-                const server = event.target.value;
-                update((value) =>
-                  value.kind === "tool"
-                    ? {
-                        ...value,
-                        // The fingerprint belongs to a surface that publishing freezes, and it is
-                        // the server's to compute — a value guessed in the browser would be a
-                        // second answer to a question the API already owns.
-                        configuration: { ...value.configuration, server, fingerprint: null },
-                      }
-                    : value,
-                );
-              }}
-              className="mt-2 w-full rounded-md border bg-background px-3 py-2 outline-none focus-visible:ring-2 focus-visible:ring-ring"
-            >
-              <option value="">{i18n.t("flows.selectTool")}</option>
-              {toolServers.map((entry) => (
-                <option key={entry.handle} value={entry.handle}>
-                  {entry.name}
-                </option>
-              ))}
-            </select>
+        <ToolStepFields
+          configuration={contract.configuration}
+          servers={toolServers}
+          state={toolServersState}
+          toolNames={toolNames}
+          toolNamesFailed={toolNamesFailed}
+          toolNamesPending={toolNamesPending}
+          update={update}
+        />
+      )}
+    </div>
+  );
+}
+
+/**
+ * What a tool step may reach: one server, and optionally only some of its functions.
+ *
+ * ⚠️ The server comes first and the functions are a NARROWING, not the other way round (#489). The
+ * old field offered every function of every server in one flat list — 85 entries here, portal
+ * management tools among them — and asked the author to pick the one call they wanted before they
+ * knew what the step would say. Which function runs is a run-time answer; which server may be
+ * reached is an authoring decision, and that is the one this asks for.
+ */
+export function ToolStepFields({
+  configuration,
+  servers,
+  state,
+  toolNames,
+  toolNamesFailed,
+  toolNamesPending,
+  update,
+}: {
+  configuration: { server: string; allow: string[] | null; fingerprint: string | null };
+  servers: Array<{ handle: string; name: string; toolCount: number }>;
+  state: "pending" | "error" | "disconnected" | "ready";
+  toolNames: string[];
+  toolNamesFailed: boolean;
+  toolNamesPending: boolean;
+  update(fn: (node: FlowNode) => FlowNode): void;
+}) {
+  const i18n = useI18n();
+  // ⚠️ The group's identity, not its data. Two steps on one screen with the same server would
+  // otherwise share one radio group and unset each other — and the component is exported now, so
+  // that invariant no longer lives in the file that guarantees it.
+  const groupId = useId();
+  const hintId = `${groupId}-hint`;
+  // The one sentence this field has to say, or none. Derived once so the control and the paragraph
+  // cannot disagree about whether there is something to point at.
+  const hint =
+    state === "error"
+      ? ({ key: "flows.toolServersFailed", tone: "bad" } as const)
+      : state === "disconnected"
+        ? ({ key: "flows.toolServersDisconnected", tone: "bad" } as const)
+        : state === "ready" && servers.length === 0
+          ? ({ key: "flows.toolServersEmpty", tone: "plain" } as const)
+          : null;
+  const ownFunctions = toolNames.filter(
+    (name) => configuration.server !== "" && serverOf(name, [configuration.server]) !== null,
+  );
+  // ⚠️ An allowed function the catalog does not carry is DRAWN, not dropped. Rendering only what
+  // the catalog knows would let the panel and the saved graph disagree in silence: the author reads
+  // "narrowed to nothing" while the step still names something. The API treats the same condition
+  // as serious enough to refuse a publish, so the editor may not swallow it.
+  // Nothing is "missing" until the catalog has actually answered.
+  const missing = toolNamesPending
+    ? []
+    : (configuration.allow ?? []).filter((name) => !ownFunctions.includes(name));
+  const functions = [...ownFunctions, ...missing];
+
+  function setTool(
+    change: (current: { server: string; allow: string[] | null; fingerprint: string | null }) => {
+      server: string;
+      allow: string[] | null;
+      fingerprint: string | null;
+    },
+  ) {
+    update((value) =>
+      value.kind === "tool" ? { ...value, configuration: change(value.configuration) } : value,
+    );
+  }
+
+  return (
+    <div className="mt-4 space-y-3">
+      <label className="block text-sm font-medium">
+        {i18n.t("flows.tool")}
+        <select
+          value={configuration.server}
+          // ⚠️ A disabled control drops out of the tab order, so the reason has to be ANNOUNCED
+          // rather than merely printed beside it. It points at the hint only when the hint is
+          // actually rendered — `pending` prints nothing on purpose, and a reference to an id that
+          // does not exist is worse than none: a screen reader reads it as a broken relation.
+          aria-describedby={hint === null ? undefined : hintId}
+          disabled={state !== "ready" || servers.length === 0}
+          onChange={(event) => {
+            // ⚠️ Read out of the event NOW, not inside the updater. The updater runs later, and by
+            // then this controlled select has been set back to the state's value — the change would
+            // apply to itself and nothing would move.
+            const server = event.target.value;
+            // Changing the server drops the narrowing AND the frozen surface. Keeping `allow` would
+            // leave functions of the old server behind — the contract refuses that outright — and
+            // keeping the fingerprint would claim a surface nobody has confirmed.
+            setTool(() => ({ server, allow: null, fingerprint: null }));
+          }}
+          className="mt-2 w-full rounded-md border bg-background px-3 py-2 outline-none focus-visible:ring-2 focus-visible:ring-ring disabled:opacity-50"
+        >
+          <option value="">{i18n.t("flows.selectTool")}</option>
+          {servers.map((entry) => (
+            <option key={entry.handle} value={entry.handle}>
+              {entry.name}
+            </option>
+          ))}
+        </select>
+      </label>
+      {/* The three states of the list, told apart. Silence while loading; a reason when it failed;
+          and "you reach none" only once that is actually known. */}
+      {hint !== null && (
+        <p
+          id={hintId}
+          className={`text-xs ${hint.tone === "bad" ? "text-destructive" : "text-muted-foreground"}`}
+        >
+          {i18n.t(hint.key)}
+        </p>
+      )}
+      {configuration.server !== "" && (
+        <fieldset className="space-y-2">
+          <legend className="text-sm font-medium">{i18n.t("flows.toolFunctions")}</legend>
+          <label className="flex items-center gap-2 text-sm">
+            <input
+              type="radio"
+              name={groupId}
+              checked={configuration.allow === null}
+              onChange={() =>
+                setTool((current) => ({ ...current, allow: null, fingerprint: null }))
+              }
+              className="size-4"
+            />
+            {i18n.t("flows.toolAllowAll")}
           </label>
-        </div>
+          <label className="flex items-center gap-2 text-sm">
+            <input
+              type="radio"
+              name={groupId}
+              checked={configuration.allow !== null}
+              onChange={() => setTool((current) => ({ ...current, allow: [], fingerprint: null }))}
+              className="size-4"
+            />
+            {i18n.t("flows.toolAllowSome")}
+          </label>
+          {configuration.allow !== null && (
+            <ul className="max-h-48 space-y-1 overflow-y-auto pl-6">
+              {functions.map((name) => (
+                <li key={name}>
+                  <label className="flex items-center gap-2 text-sm">
+                    <input
+                      type="checkbox"
+                      checked={configuration.allow?.includes(name) ?? false}
+                      onChange={(event) => {
+                        // Same reason as the select above: the checked flag is read now, the
+                        // updater runs later.
+                        const add = event.target.checked;
+                        setTool((current) => ({
+                          ...current,
+                          allow: add
+                            ? [...(current.allow ?? []), name]
+                            : (current.allow ?? []).filter((entry) => entry !== name),
+                          fingerprint: null,
+                        }));
+                      }}
+                      className="size-4"
+                    />
+                    <span className="min-w-0 truncate">{name}</span>
+                  </label>
+                </li>
+              ))}
+            </ul>
+          )}
+          {/* Two sentences that only appear when they are true, and neither is the generic hint:
+              a narrowing to nothing cannot be published, and a name the catalog does not carry is
+              something the author has to see rather than lose. */}
+          {configuration.allow?.length === 0 && (
+            <p className="text-xs text-destructive">{i18n.t("flows.toolAllowNone")}</p>
+          )}
+          {toolNamesFailed && (
+            <p className="text-xs text-destructive">{i18n.t("flows.toolFunctionsFailed")}</p>
+          )}
+          {!toolNamesFailed && missing.length > 0 && (
+            <p className="text-xs text-destructive">
+              {i18n.t("flows.toolAllowUnknown", { count: missing.length })}
+            </p>
+          )}
+          <p className="text-xs text-muted-foreground">{i18n.t("flows.toolAllowHint")}</p>
+        </fieldset>
       )}
     </div>
   );

package/src/i18n/de.json

@@ -97,7 +97,7 @@
   "archive.restoreFailed": "Es wurde nicht wiederhergestellt. Vielleicht hat jemand anderes es geändert — lade neu und versuche es erneut.",
   "archive.purge": "{title} endgültig löschen",
   "archive.purge.title": "Endgültig löschen?",
-  "archive.purge.body": "„{title}\u201c und alles, was dazugehört — jede Version, der Inhalt und die Einträge im Suchindex — ist danach weg. Das lässt sich nicht rückgängig machen.",
+  "archive.purge.body": "„{title}“ und alles, was dazugehört — jede Version, der Inhalt und die Einträge im Suchindex — ist danach weg. Das lässt sich nicht rückgängig machen.",
   "archive.purge.links.none": "Keine anderen Dokumente verweisen darauf.",
   "archive.purge.links.one": "Ein anderes Dokument verweist darauf; dieser Verweis wird brechen.",
   "archive.purge.links.many": "{count} andere Dokumente verweisen darauf; diese Verweise werden brechen.",
@@ -275,8 +275,8 @@
   "flows.publishPreviewUnavailable": "Der aufgerufene Flow hat noch nichts veröffentlicht, das lässt sich nicht einfrieren.",
   "flows.publishConfirm": "Veröffentlichen",
   "flows.publishFailed": "Das Veröffentlichen ist fehlgeschlagen. Lade die neueste Fassung und versuche es erneut.",
-  "flows.tool": "MCP-Werkzeug",
-  "flows.selectTool": "Wähle ein gefundenes Werkzeug",
+  "flows.tool": "MCP-Server",
+  "flows.selectTool": "Server auswählen",
   "flows.operationFailed": "Der Flow-Vorgang ist fehlgeschlagen. Lade die neueste Fassung und versuche es erneut.",
   "flows.needs": "Was dieser Flow braucht",
   "flows.needsNodes": "Dokumente",
@@ -351,5 +351,18 @@
   "common.noAccess": "Das ist für dich nicht verfügbar. Es existiert nicht, oder es ist nicht mehr für dich freigegeben.",
   "common.noPermission": "Dir fehlt die Berechtigung, das zu sehen.",
   "title.descriptionMore": "Mehr",
-  "title.descriptionLess": "Weniger"
+  "title.descriptionLess": "Weniger",
+  "flows.toolServersEmpty": "Über das Portal erreichst du noch keinen MCP-Server.",
+  "flows.toolServersFailed": "Die Serverliste ließ sich nicht laden, daher lässt sich gerade keiner auswählen.",
+  "flows.toolAllowAll": "Der Agent darf jede Funktion nutzen",
+  "flows.toolAllowSome": "Den Agenten auf bestimmte Funktionen hinweisen",
+  "flows.toolAllowHint": "Intel sagt, wofür ein Schritt da ist; der Agent wählt den Aufruf und erreicht das Portal mit seinen eigenen Rechten.",
+  "flows.toolFunctions": "Funktionen",
+  "flows.toolServersDisconnected": "Du bist nicht mit dem Portal verbunden, daher lässt sich kein Server wählen. Verbinde es zuerst in den Werkzeug-Einstellungen.",
+  "flows.toolAllowNone": "Es ist noch keine Funktion ausgewählt, daher lässt sich dieser Schritt nicht veröffentlichen.",
+  "flows.toolAllowUnknown": "{count} ausgewählte Funktion(en) bietet dieser Server gerade nicht an.",
+  "flows.toolStepNeedsServer": "Dem Schritt „{label}“ fehlt noch ein Server.",
+  "flows.toolFunctionsFailed": "Die Funktionsliste ließ sich nicht laden, daher ist die Auswahl möglicherweise unvollständig.",
+  "flows.publishPreviewToolUnavailable": "Diesen Server erreichst du nicht, daher wird das Veröffentlichen abgelehnt.",
+  "flows.publishPreviewToolAllow": "Eingefroren auf: {functions}"
 }

package/src/i18n/en.json

@@ -275,8 +275,8 @@
   "flows.publishPreviewUnavailable": "The called flow has published nothing yet, so this cannot be frozen.",
   "flows.publishConfirm": "Publish",
   "flows.publishFailed": "Publishing failed. Reload the latest version and try again.",
-  "flows.tool": "MCP tool",
-  "flows.selectTool": "Select a discovered tool",
+  "flows.tool": "MCP server",
+  "flows.selectTool": "Select a server",
   "flows.operationFailed": "The flow operation failed. Reload the latest version and try again.",
   "flows.needs": "What this flow needs",
   "flows.needsNodes": "Documents",
@@ -351,5 +351,18 @@
   "common.noAccess": "This is not available to you. It may not exist, or it may no longer be shared with you.",
   "common.noPermission": "You do not have permission to see this.",
   "title.descriptionMore": "More",
-  "title.descriptionLess": "Less"
+  "title.descriptionLess": "Less",
+  "flows.toolServersEmpty": "You reach no MCP server through the portal yet.",
+  "flows.toolServersFailed": "The list of servers could not be loaded, so none can be chosen right now.",
+  "flows.toolAllowAll": "Let the agent use any function",
+  "flows.toolAllowSome": "Point the agent at specific functions",
+  "flows.toolAllowHint": "Intel says what a step is for; the agent chooses the call and reaches the portal with its own permissions.",
+  "flows.toolFunctions": "Functions",
+  "flows.toolServersDisconnected": "You are not connected to the portal, so no server can be chosen. Connect it in the tool settings first.",
+  "flows.toolAllowNone": "No function is selected yet, so this step cannot be published.",
+  "flows.toolAllowUnknown": "{count} selected function(s) are not offered by this server right now.",
+  "flows.toolStepNeedsServer": "The step “{label}” still needs a server.",
+  "flows.toolFunctionsFailed": "The list of functions could not be loaded, so the selection may be incomplete.",
+  "flows.publishPreviewToolUnavailable": "You do not reach this server, so publishing will be refused.",
+  "flows.publishPreviewToolAllow": "Frozen to: {functions}"
 }

package/src/i18n/es.json

@@ -275,8 +275,8 @@
   "flows.publishPreviewUnavailable": "El flujo llamado todavía no ha publicado nada, así que esto no se puede congelar.",
   "flows.publishConfirm": "Publicar",
   "flows.publishFailed": "La publicación ha fallado. Carga la versión más reciente e inténtalo de nuevo.",
-  "flows.tool": "Herramienta MCP",
-  "flows.selectTool": "Elige una herramienta descubierta",
+  "flows.tool": "Servidor MCP",
+  "flows.selectTool": "Elegir un servidor",
   "flows.operationFailed": "La operación del flujo ha fallado. Carga la versión más reciente e inténtalo de nuevo.",
   "flows.needs": "Qué necesita este flujo",
   "flows.needsNodes": "Documentos",
@@ -351,5 +351,18 @@
   "common.noAccess": "Esto no está disponible para ti. Puede que no exista o que ya no esté compartido contigo.",
   "common.noPermission": "No tienes permiso para ver esto.",
   "title.descriptionMore": "Más",
-  "title.descriptionLess": "Menos"
+  "title.descriptionLess": "Menos",
+  "flows.toolServersEmpty": "Todavía no alcanzas ningún servidor MCP a través del portal.",
+  "flows.toolServersFailed": "No se pudo cargar la lista de servidores, así que ahora no se puede elegir ninguno.",
+  "flows.toolAllowAll": "El agente puede usar cualquier función",
+  "flows.toolAllowSome": "Indicar al agente funciones concretas",
+  "flows.toolAllowHint": "Intel dice para qué sirve un paso; el agente elige la llamada y accede al portal con sus propios permisos.",
+  "flows.toolFunctions": "Funciones",
+  "flows.toolServersDisconnected": "No estás conectado al portal, así que no se puede elegir ningún servidor. Conéctalo primero en la configuración de herramientas.",
+  "flows.toolAllowNone": "Todavía no hay ninguna función seleccionada, así que este paso no se puede publicar.",
+  "flows.toolAllowUnknown": "Este servidor no ofrece ahora mismo {count} función(es) seleccionada(s).",
+  "flows.toolStepNeedsServer": "Al paso «{label}» todavía le falta un servidor.",
+  "flows.toolFunctionsFailed": "No se pudo cargar la lista de funciones, así que la selección puede estar incompleta.",
+  "flows.publishPreviewToolUnavailable": "No alcanzas este servidor, así que la publicación será rechazada.",
+  "flows.publishPreviewToolAllow": "Congelado en: {functions}"
 }