@anchrd/intel-ui 0.8.8 → 0.9.0

package/src/agent/agent-models/agent-models.ts

@@ -0,0 +1,63 @@
+import { AgentModel } from "@anchrd/intel-contract";
+import { z } from "zod";
+
+/**
+ * Which models this installation offers.
+ *
+ * ⚠️ There is no endpoint to ask. The runtime's registry answers one question — "is this provider
+ * configured" — and only when a run is already starting; nothing anywhere lists what a deployment
+ * pays for. Rather than invent an API for one screen, the list is build configuration
+ * (`VITE_AGENT_MODELS`, a JSON array of `{provider, model}`), with the two the repository's own
+ * fixtures use as the default.
+ *
+ * ⚠️ The definition's current model is always offered, even when it is not in the list. A select
+ * that silently dropped it would turn "look at this agent" into "change this agent" for anyone who
+ * then saved — and the definition is written by MCP and by other installations too, not only here.
+ */
+const ConfiguredModels = z.array(AgentModel);
+
+const firstFallback: AgentModel = { provider: "anthropic", model: "claude-sonnet-4" };
+const fallback: [AgentModel, ...AgentModel[]] = [
+  firstFallback,
+  { provider: "workers-ai", model: "@cf/meta/llama-3.3-70b-instruct-fp8-fast" },
+];
+
+export function modelKey(model: AgentModel): string {
+  return `${model.provider}:${model.model}`;
+}
+
+export function parseModelKey(key: string): AgentModel | null {
+  const boundary = key.indexOf(":");
+  if (boundary <= 0) return null;
+  const parsed = AgentModel.safeParse({
+    provider: key.slice(0, boundary),
+    model: key.slice(boundary + 1),
+  });
+  return parsed.success ? parsed.data : null;
+}
+
+export function configuredModels(): AgentModel[] {
+  const raw = import.meta.env.VITE_AGENT_MODELS;
+  if (!raw) return fallback;
+  try {
+    const parsed = ConfiguredModels.safeParse(JSON.parse(raw));
+    // A malformed variable falls back rather than emptying the select: an agent whose model cannot
+    // be chosen is an agent that cannot be repaired from this screen.
+    return parsed.success && parsed.data.length > 0 ? parsed.data : fallback;
+  } catch {
+    return fallback;
+  }
+}
+
+// The offered list with the agent's own model folded in, deduplicated, order preserved.
+export function selectableModels(current: AgentModel | null): AgentModel[] {
+  const models = configuredModels();
+  if (!current || models.some((model) => modelKey(model) === modelKey(current))) return models;
+  return [current, ...models];
+}
+
+// What a newly created agent gets. The first offered model, because a create dialog that asked for
+// a provider before the agent has a name would be a settings screen wearing a form's clothes.
+export function defaultModel(): AgentModel {
+  return configuredModels()[0] ?? firstFallback;
+}

package/src/agent/agent-profile/agent-profile.tsx

@@ -0,0 +1,512 @@
+import {
+  type AgentDefinition,
+  type AgentReference,
+  AgentReferenceRole,
+  type AgentSchedule,
+  type Node,
+} from "@anchrd/intel-contract";
+import { useQuery } from "@tanstack/react-query";
+import { Check, Copy, MessageSquare, Plus, Trash2, Wrench } from "lucide-react";
+import { useState } from "react";
+import type { AgentDefinitionHandle } from "@/agent/agent-definition/agent-definition.ts";
+import { useEntryTitle } from "@/agent/agent-entry-title/agent-entry-title.ts";
+import { modelKey, parseModelKey, selectableModels } from "@/agent/agent-models/agent-models.ts";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
+import { agentMcpAddress } from "@/data/agent-runtime/agent-runtime.ts";
+import { EntryPicker, type PickerKind } from "@/entry-picker/entry-picker.tsx";
+import { Modal } from "@/modal/modal.tsx";
+import { useIntelRouterContext } from "@/router/router-context.ts";
+
+function Section({
+  title,
+  hint,
+  children,
+}: {
+  title: string;
+  hint?: string;
+  children: React.ReactNode;
+}) {
+  return (
+    <section aria-label={title} className="border-b px-6 py-5 last:border-b-0">
+      <h3 className="text-sm font-semibold">{title}</h3>
+      {hint ? <p className="mt-1 max-w-2xl text-xs text-muted-foreground">{hint}</p> : null}
+      <div className="mt-3">{children}</div>
+    </section>
+  );
+}
+
+/**
+ * Everything an agent is, on one page: how to reach it, what it reads, what it may call, when it
+ * acts on its own, and which model does the thinking.
+ *
+ * ⚠️ Four of the five sections write, and all four write the SAME way — a whole new definition
+ * version through `save` (see `agent-definition.ts`). Tools is the exception and stays read-only on
+ * purpose: the portal decides who reaches which tool, Intel stores none of it, and a control here
+ * would be a promise this product is not allowed to keep (ADR-0003).
+ */
+export function AgentProfile({ node, agent }: { node: Node; agent: AgentDefinitionHandle }) {
+  const { i18n } = useIntelRouterContext();
+  const definition = agent.definition;
+
+  // The definition is `null` in exactly one window: the node exists and no version has been written
+  // yet. Nothing on this page can be edited until there is one, and saying so beats five sections
+  // of empty controls that all refuse.
+  if (agent.query.isPending) {
+    return <p className="p-6 text-sm text-muted-foreground">{i18n.t("common.loading")}</p>;
+  }
+  if (agent.query.isError) {
+    return (
+      <div role="alert" className="space-y-3 p-6 text-sm">
+        <p className="text-destructive">{i18n.t("agent.loadFailed")}</p>
+        <button
+          type="button"
+          onClick={() => void agent.query.refetch()}
+          className="rounded-md border px-3 py-2 outline-none hover:bg-muted focus-visible:ring-2 focus-visible:ring-ring"
+        >
+          {i18n.t("common.retry")}
+        </button>
+      </div>
+    );
+  }
+  if (!definition) {
+    return <p className="p-6 text-sm text-muted-foreground">{i18n.t("agent.noDefinition")}</p>;
+  }
+
+  return (
+    <div className="min-h-0 flex-1 overflow-y-auto">
+      {agent.save.isError ? (
+        <p role="alert" className="border-b bg-destructive/5 px-6 py-3 text-sm text-destructive">
+          {i18n.t("agent.saveFailed")}
+        </p>
+      ) : null}
+      <ContactSection node={node} />
+      <KnowledgeSection definition={definition} agent={agent} />
+      <ToolsSection />
+      <ScheduleSection definition={definition} agent={agent} />
+      <ModelSection definition={definition} agent={agent} />
+    </div>
+  );
+}
+
+/**
+ * How to reach this agent.
+ *
+ * ⚠️ The built-in chat is listed first and cannot be removed, because it is not a channel somebody
+ * configured — it is the runtime itself (ADR-0005 §5). Listing it beside the others, with no
+ * delete, is what says "built in, always there" without a sentence explaining it.
+ */
+function ContactSection({ node }: { node: Node }) {
+  const { i18n } = useIntelRouterContext();
+  const [copied, setCopied] = useState(false);
+  // ⚠️ The runtime's own address, NOT intel's proxy. This one is dialled by a portal or another
+  // agent with its own credential (ADR-0005 §7); intel's door is for this page's browser calls and
+  // deliberately does not carry `/mcp` (#178).
+  const mcpAddress = agentMcpAddress(node.id);
+  // A relative path is what the page was built with when the runtime shares the origin, and a
+  // relative MCP address is useless to the client that has to dial it. Resolving against the page
+  // makes the copied value absolute wherever it came from.
+  const absolute =
+    typeof window === "undefined" ? mcpAddress : new URL(mcpAddress, window.location.origin).href;
+
+  return (
+    <Section title={i18n.t("agent.contact")} hint={i18n.t("agent.contactHint")}>
+      <ul className="space-y-2">
+        <li className="flex items-center gap-3 rounded-lg border bg-card px-4 py-3">
+          <MessageSquare aria-hidden="true" className="size-4 shrink-0 text-primary" />
+          <span className="min-w-0 flex-1">
+            <span className="block text-sm font-medium">{i18n.t("agent.contactChat")}</span>
+            <span className="block text-xs text-muted-foreground">
+              {i18n.t("agent.contactChatBuiltIn")}
+            </span>
+          </span>
+        </li>
+        <li className="flex items-center gap-3 rounded-lg border bg-card px-4 py-3">
+          <Wrench aria-hidden="true" className="size-4 shrink-0 text-primary" />
+          <span className="min-w-0 flex-1">
+            <span className="block text-sm font-medium">{i18n.t("agent.contactMcp")}</span>
+            <code className="mt-0.5 block truncate text-xs text-muted-foreground">{absolute}</code>
+          </span>
+          <button
+            type="button"
+            onClick={() => {
+              void navigator.clipboard.writeText(absolute).then(() => {
+                setCopied(true);
+                setTimeout(() => setCopied(false), 2_000);
+              });
+            }}
+            className="inline-flex shrink-0 items-center gap-1.5 rounded-md border px-2.5 py-1.5 text-xs outline-none hover:bg-muted focus-visible:ring-2 focus-visible:ring-ring"
+          >
+            {copied ? (
+              <Check aria-hidden="true" className="size-3.5" />
+            ) : (
+              <Copy aria-hidden="true" className="size-3.5" />
+            )}
+            {i18n.t(copied ? "agent.copied" : "agent.copy")}
+          </button>
+        </li>
+      </ul>
+      {/* ⚠️ Disabled, and the reason is written rather than hovered. A mail contact is deployment
+          configuration (`AGENT_MAILBOXES`) and deliberately not part of the definition — ADR-0005
+          §4 — so a working button here would write a field the runtime never reads. */}
+      <div className="mt-3">
+        <button
+          type="button"
+          disabled
+          aria-describedby="agent-contact-add-reason"
+          className="inline-flex items-center gap-2 rounded-md border px-3 py-2 text-sm disabled:opacity-50"
+        >
+          <Plus aria-hidden="true" className="size-4" />
+          {i18n.t("agent.contactAdd")}
+        </button>
+        <p id="agent-contact-add-reason" className="mt-1.5 text-xs text-muted-foreground">
+          {i18n.t("agent.contactAddReason")}
+        </p>
+      </div>
+    </Section>
+  );
+}
+
+/**
+ * What the agent reads, and in which capacity.
+ *
+ * ⚠️ The role is a select with a visible chevron, not a coloured word. #143 asks for that
+ * explicitly, and the reason is that the three roles do very different things — a folder read as
+ * the system message becomes instructions, one read as memory is written back to. Something that
+ * changes what a document MEANS to an agent must look changeable.
+ */
+function KnowledgeSection({
+  definition,
+  agent,
+}: {
+  definition: AgentDefinition;
+  agent: AgentDefinitionHandle;
+}) {
+  const { i18n } = useIntelRouterContext();
+  const [adding, setAdding] = useState(false);
+
+  function write(references: AgentReference[]) {
+    agent.save.mutate({ ...definition, references });
+  }
+
+  return (
+    <Section title={i18n.t("agent.knows")} hint={i18n.t("agent.knowsHint")}>
+      {definition.references.length === 0 ? (
+        <p className="text-sm text-muted-foreground">{i18n.t("agent.knowsEmpty")}</p>
+      ) : (
+        <ul className="space-y-2">
+          {/* ⚠️ The position IS the identity here: `references` is an ordered array with no ids,
+              the contract permits the same folder twice, and every edit below addresses a row by
+              its index. A key built from the contents alone would collide on exactly the duplicate
+              the array is allowed to hold. */}
+          {definition.references.map((reference, index) => (
+            <ReferenceRow
+              // biome-ignore lint/suspicious/noArrayIndexKey: the position is the identity — see above
+              key={`${reference.nodeId}:${index}`}
+              reference={reference}
+              setRole={(role) =>
+                write(
+                  definition.references.map((current, position) =>
+                    position === index ? { ...current, role } : current,
+                  ),
+                )
+              }
+              remove={() =>
+                write(definition.references.filter((_, position) => position !== index))
+              }
+            />
+          ))}
+        </ul>
+      )}
+      <button
+        type="button"
+        onClick={() => setAdding(true)}
+        className="mt-3 inline-flex items-center gap-2 rounded-md border px-3 py-2 text-sm outline-none hover:bg-muted focus-visible:ring-2 focus-visible:ring-ring"
+      >
+        <Plus aria-hidden="true" className="size-4" />
+        {i18n.t("agent.addReference")}
+      </button>
+      {adding ? (
+        <Modal title={i18n.t("agent.addReference")} close={() => setAdding(false)}>
+          <EntryPicker
+            kind="folder"
+            value=""
+            label={i18n.t("agent.pickFolder")}
+            onSelect={(nodeId) => {
+              write([...definition.references, { nodeId, role: "semantic-context" }]);
+              setAdding(false);
+            }}
+          />
+        </Modal>
+      ) : null}
+    </Section>
+  );
+}
+
+/**
+ * One folder the agent reads, and what it counts as.
+ *
+ * ⚠️ Its own component so the select can be NAMED after the folder. Three rows carrying the same
+ * "What this folder counts as" are three identical controls to anybody listening rather than
+ * looking — the name is beside them on screen, and the screen is exactly what that reader does not
+ * have. It needs the resolved title, which is why the lookup is a hook rather than a component here.
+ */
+function ReferenceRow({
+  reference,
+  setRole,
+  remove,
+}: {
+  reference: AgentReference;
+  setRole(role: AgentReferenceRole): void;
+  remove(): void;
+}) {
+  const { i18n } = useIntelRouterContext();
+  const { title, known } = useEntryTitle(reference.nodeId);
+  return (
+    <li className="flex flex-wrap items-center gap-3 rounded-lg border bg-card px-4 py-3">
+      <span className={`min-w-0 flex-1 truncate text-sm${known ? "" : " text-muted-foreground"}`}>
+        {title}
+      </span>
+      <Select
+        value={reference.role}
+        onValueChange={(role) => {
+          const parsed = AgentReferenceRole.safeParse(role);
+          if (parsed.success) setRole(parsed.data);
+        }}
+      >
+        <SelectTrigger size="sm" aria-label={i18n.t("agent.roleFor", { title })}>
+          <SelectValue />
+        </SelectTrigger>
+        <SelectContent>
+          {AgentReferenceRole.options.map((role) => (
+            <SelectItem key={role} value={role}>
+              {i18n.t(`agent.role.${role}`)}
+            </SelectItem>
+          ))}
+        </SelectContent>
+      </Select>
+      <button
+        type="button"
+        onClick={remove}
+        aria-label={i18n.t("agent.removeReferenceOf", { title })}
+        className="rounded-md p-2 text-destructive outline-none hover:bg-muted focus-visible:ring-2 focus-visible:ring-ring"
+      >
+        <Trash2 aria-hidden="true" className="size-4" />
+      </button>
+    </li>
+  );
+}
+
+function EntryTitle({ entryId, flow = false }: { entryId: string; flow?: boolean }) {
+  const { title, known } = useEntryTitle(entryId, flow);
+  return (
+    <span className={`min-w-0 flex-1 truncate text-sm${known ? "" : " text-muted-foreground"}`}>
+      {title}
+    </span>
+  );
+}
+
+/**
+ * What the agent may call.
+ *
+ * ⚠️ Read-only, and read live. Intel stores no tool permissions — the catalog is one `tools/list`
+ * with the signed-in user's own portal token (ADR-0003), and this section shows exactly what the
+ * Tools screen shows because it asks the same question through the same provider method. Mirroring
+ * the catalog into the definition is the one thing this product must not do.
+ */
+function ToolsSection() {
+  const { data, i18n } = useIntelRouterContext();
+  const catalog = useQuery({ queryKey: ["tools"], queryFn: () => data.listTools() });
+
+  return (
+    <Section title={i18n.t("agent.tools")} hint={i18n.t("agent.toolsHint")}>
+      {catalog.isPending ? (
+        <p className="text-sm text-muted-foreground">{i18n.t("common.loading")}</p>
+      ) : catalog.isError ? (
+        <p role="alert" className="text-sm text-destructive">
+          {i18n.t("tools.unreachableHelp")}
+        </p>
+      ) : catalog.data && catalog.data.items.length === 0 ? (
+        <p className="text-sm text-muted-foreground">{i18n.t("tools.emptyHelp")}</p>
+      ) : (
+        <ul className="flex flex-wrap gap-2">
+          {catalog.data?.items.map((tool) => (
+            <li
+              key={tool.name}
+              className="rounded-full border bg-card px-3 py-1 text-xs text-muted-foreground"
+            >
+              {tool.name}
+            </li>
+          ))}
+        </ul>
+      )}
+    </Section>
+  );
+}
+
+/**
+ * When the agent acts without being asked.
+ *
+ * ⚠️ The target is a flow OR a document and nothing else — the contract says so, and the picker is
+ * told to offer both rather than being given a free text field. A schedule aimed at something that
+ * cannot be run is a run that fails at 3 a.m. with nobody watching.
+ */
+function ScheduleSection({
+  definition,
+  agent,
+}: {
+  definition: AgentDefinition;
+  agent: AgentDefinitionHandle;
+}) {
+  const { i18n } = useIntelRouterContext();
+  const [adding, setAdding] = useState(false);
+
+  function write(schedules: AgentSchedule[]) {
+    agent.save.mutate({ ...definition, schedules });
+  }
+
+  return (
+    <Section title={i18n.t("agent.schedule")} hint={i18n.t("agent.scheduleHint")}>
+      {definition.schedules.length === 0 ? (
+        <p className="text-sm text-muted-foreground">{i18n.t("agent.scheduleEmpty")}</p>
+      ) : (
+        <ul className="space-y-2">
+          {definition.schedules.map((schedule, index) => (
+            <li
+              // biome-ignore lint/suspicious/noArrayIndexKey: same as the references above — an ordered array with no ids, edited by position
+              key={`${schedule.cron}:${schedule.target.id}:${index}`}
+              className="flex flex-wrap items-center gap-3 rounded-lg border bg-card px-4 py-3"
+            >
+              <code className="rounded bg-muted px-2 py-1 text-xs">{schedule.cron}</code>
+              <EntryTitle entryId={schedule.target.id} flow={schedule.target.kind === "flow"} />
+              <span className="text-xs text-muted-foreground">
+                {i18n.t(`node.kind.${schedule.target.kind}`)}
+              </span>
+              <button
+                type="button"
+                onClick={() =>
+                  write(definition.schedules.filter((_, position) => position !== index))
+                }
+                aria-label={i18n.t("agent.removeSchedule")}
+                className="rounded-md p-2 text-destructive outline-none hover:bg-muted focus-visible:ring-2 focus-visible:ring-ring"
+              >
+                <Trash2 aria-hidden="true" className="size-4" />
+              </button>
+            </li>
+          ))}
+        </ul>
+      )}
+      <button
+        type="button"
+        onClick={() => setAdding(true)}
+        className="mt-3 inline-flex items-center gap-2 rounded-md border px-3 py-2 text-sm outline-none hover:bg-muted focus-visible:ring-2 focus-visible:ring-ring"
+      >
+        <Plus aria-hidden="true" className="size-4" />
+        {i18n.t("agent.addSchedule")}
+      </button>
+      {adding ? (
+        <ScheduleDialog
+          close={() => setAdding(false)}
+          add={(schedule) => {
+            write([...definition.schedules, schedule]);
+            setAdding(false);
+          }}
+        />
+      ) : null}
+    </Section>
+  );
+}
+
+function ScheduleDialog({ close, add }: { close(): void; add(schedule: AgentSchedule): void }) {
+  const { i18n } = useIntelRouterContext();
+  const [cron, setCron] = useState("0 8 * * *");
+  const [target, setTarget] = useState<{ id: string; kind: "document" | "flow" } | null>(null);
+
+  return (
+    <Modal title={i18n.t("agent.addSchedule")} close={close}>
+      <form
+        className="space-y-4"
+        onSubmit={(event) => {
+          event.preventDefault();
+          if (target && cron.trim()) add({ cron: cron.trim(), target });
+        }}
+      >
+        <label className="block text-sm font-medium">
+          {i18n.t("agent.cron")}
+          <input
+            required
+            value={cron}
+            onChange={(event) => setCron(event.target.value)}
+            aria-describedby="agent-cron-hint"
+            className="mt-2 w-full rounded-md border bg-background px-3 py-2 font-mono text-sm outline-none focus-visible:ring-2 focus-visible:ring-ring"
+          />
+          <span
+            id="agent-cron-hint"
+            className="mt-1 block text-xs font-normal text-muted-foreground"
+          >
+            {i18n.t("agent.cronHint")}
+          </span>
+        </label>
+        <EntryPicker
+          kind="document"
+          flows
+          value={target?.id ?? ""}
+          label={i18n.t("agent.scheduleTarget")}
+          onSelect={(entryId, entryKind: PickerKind) => {
+            if (entryKind !== "document" && entryKind !== "flow") return;
+            setTarget({ id: entryId, kind: entryKind });
+          }}
+        />
+        <button
+          type="submit"
+          disabled={!target || cron.trim().length === 0}
+          className="w-full rounded-md bg-primary px-4 py-2 text-sm font-medium text-primary-foreground outline-none hover:bg-primary/90 focus-visible:ring-2 focus-visible:ring-ring disabled:opacity-50"
+        >
+          {i18n.t("common.create")}
+        </button>
+      </form>
+    </Modal>
+  );
+}
+
+// Which model does the thinking. Changing it writes a new definition version like every other edit
+// here — the runtime picks the provider up on its next read (its definition cache is 60 seconds).
+function ModelSection({
+  definition,
+  agent,
+}: {
+  definition: AgentDefinition;
+  agent: AgentDefinitionHandle;
+}) {
+  const { i18n } = useIntelRouterContext();
+  const models = selectableModels(definition.model);
+
+  return (
+    <Section title={i18n.t("agent.model")} hint={i18n.t("agent.modelHint")}>
+      <Select
+        value={modelKey(definition.model)}
+        onValueChange={(key) => {
+          const model = parseModelKey(key);
+          if (model) agent.save.mutate({ ...definition, model });
+        }}
+      >
+        <SelectTrigger aria-label={i18n.t("agent.model")} className="w-full max-w-md">
+          <SelectValue />
+        </SelectTrigger>
+        <SelectContent>
+          {models.map((model) => (
+            <SelectItem key={modelKey(model)} value={modelKey(model)}>
+              {model.model}
+              <span className="text-xs text-muted-foreground">{model.provider}</span>
+            </SelectItem>
+          ))}
+        </SelectContent>
+      </Select>
+    </Section>
+  );
+}

package/src/agent/agent-state/agent-state.ts

@@ -0,0 +1,48 @@
+import { type UseQueryResult, useQuery } from "@tanstack/react-query";
+import type { AgentState } from "@/data/agent-runtime/agent-runtime.ts";
+import { IntelRequestError } from "@/data/intel-data-provider/intel-data-provider.ts";
+import { useIntelRouterContext } from "@/router/router-context.ts";
+
+export const agentStateKey = (agentId: string) => ["agent-state", agentId] as const;
+
+/**
+ * Whether this agent is switched off, read from the runtime through intel.
+ *
+ * ⚠️ One query for the whole page, shared by the status line, the two head actions and the tabs
+ * that have to say "not for you". It is also the page's PROBE: the answer to "may this reader drive
+ * this agent" is only knowable by asking, because `/session` deliberately carries identity and no
+ * capabilities (`SessionUser` — "no capabilities, no token"). So a 403 here is not a failure to
+ * report but a fact to render.
+ */
+export function useAgentState(agentId: string): UseQueryResult<AgentState> {
+  const { data } = useIntelRouterContext();
+  return useQuery({
+    queryKey: agentStateKey(agentId),
+    queryFn: () => data.getAgentState(agentId),
+    // A refusal is an answer, and retrying it three times only delays the sentence that explains it.
+    retry: false,
+  });
+}
+
+/**
+ * The refusal that is about permission rather than about something being broken.
+ *
+ * ⚠️ 403 and nothing else. A 401 has already sent the page to the sign-in, and a 503 means this
+ * installation runs no agent runtime — reading either as "you may not" would tell somebody they
+ * lack a permission they actually have.
+ */
+export function agentAccessDenied(error: unknown): boolean {
+  return error instanceof IntelRequestError && error.status === 403;
+}
+
+/**
+ * The refusal that says this installation runs no agent runtime at all (#190).
+ *
+ * ⚠️ The code, not the 503: a runtime that exists but is down may answer 503 too, and reading that
+ * as "this deployment has no agents" would explain a permanent absence to somebody who is looking
+ * at an outage. Normally `/capabilities` has already said so and the page never asks — this is the
+ * belt to that brace, for the probe that reached the door anyway.
+ */
+export function agentRuntimeMissing(error: unknown): boolean {
+  return error instanceof IntelRequestError && error.code === "agent_runtime_not_configured";
+}