@anchrd/intel-ui 0.8.7 → 0.9.0

package/src/data/intel-data-provider/intel-data-provider.ts

@@ -1,12 +1,15 @@
 import {
-  AppendKnowledgeTableRowsInput,
-  AppendKnowledgeTableRowsResult,
+  AppendTableRowsInput,
+  AppendTableRowsResult,
   ArchiveFlowInput,
-  ArchiveKnowledgeNodeInput,
+  ArchiveNodeInput,
+  BundleImportResult,
   CompleteFlowRunStepInput,
+  CreateAgentInput,
+  CreatedAgent,
   CreateFlowInput,
-  CreateKnowledgeNodeInput,
-  DefineKnowledgeTableInput,
+  CreateNodeInput,
+  DefineTableInput,
   Flow,
   FlowDocument,
   FlowList,
@@ -16,40 +19,50 @@ import {
   FlowRunList,
   FlowRunStep,
   FlowValidation,
-  KnowledgeDocument,
-  KnowledgeGraph,
-  KnowledgeLinkList,
-  KnowledgeNode,
-  KnowledgeNodeList,
-  KnowledgeTable,
-  KnowledgeVersionList,
+  IntelCapabilities,
   ListFlowRunsInput,
   ListFlowsInput,
-  ListKnowledgeNodesInput,
+  ListNodesInput,
+  Node,
+  NodeAgent,
+  NodeDocument,
+  NodeGraph,
+  NodeLinkList,
+  NodeList,
+  NodeTable,
+  NodeVersionList,
   PreviewFlowPublishInput,
   ProblemDetails,
   PublishFlowInput,
   RelationGraph,
   RelationGraphInput,
-  ResolveKnowledgeLinksInput,
-  ResolveKnowledgeLinksResult,
+  ResolveNodeLinksInput,
+  ResolveNodeLinksResult,
   ResourceGrantList,
+  RevokeGrantInput,
   RevokeGrantResult,
-  RevokeKnowledgeGrantInput,
+  SaveAgentDefinitionInput,
+  SaveAttachmentInput,
   SaveFlowVersionInput,
-  SaveKnowledgeAttachmentInput,
-  SaveKnowledgeVersionInput,
-  SearchKnowledgeInput,
-  SearchKnowledgeResult,
+  SaveNodeVersionInput,
+  SearchInput,
+  SearchResult,
   SessionUser,
-  ShareKnowledgeInput,
-  ShareKnowledgeResult,
+  ShareInput,
+  ShareResult,
   StartFlowRunInput,
   ToolCatalog,
   UpdateFlowInput,
-  UpdateKnowledgeNodeInput,
+  UpdateNodeInput,
 } from "@anchrd/intel-contract";
 import type { z } from "zod";
+import {
+  AgentManualRun,
+  AgentRunDetail,
+  AgentRunList,
+  AgentState,
+  agentRuntimePath,
+} from "@/data/agent-runtime/agent-runtime.ts";
 import { createBrowserSignIn } from "@/data/sign-in/sign-in.ts";
 import type { IntelDataProvider, TreeEntry } from "./intel-data-provider.types.ts";
 
@@ -82,10 +95,10 @@ export function loginPath(returnTo?: string): string {
  * copies of this would keep returning something plausible and slowly stop agreeing on what a flow
  * row is (#30).
  */
-// ⚠️ `openable` ist hier voreingestellt falsch — genauer: unbekannt. Wer die Ebene kennt, setzt es
-// (`listTreeChildren`); wer nur eine einzelne Zeile baut, weiß es nicht und behauptet deshalb das
-// Zurückhaltendere. Ein Pfeil, der zu Unrecht fehlt, kostet einen Klick auf die Zeile; einer, der
-// zu Unrecht steht, kostet Vertrauen (#59).
+// ⚠️ `openable` defaults to false here — more precisely: unknown. Whoever knows the level sets it
+// (`listTreeChildren`); whoever only builds a single row does not know and therefore claims the
+// more reserved of the two. An arrow that is wrongly missing costs a click on the row; one that
+// is wrongly there costs trust (#59).
 export function flowEntry(flow: Flow, openable = false): TreeEntry {
   return { type: "flow", id: flow.id, title: flow.title, kind: "flow", openable, flow };
 }
@@ -165,39 +178,42 @@ export function createIntelDataProvider(
     // Same rule as `parentId`: only the asked-for case is sent. The default is the server's, and a
     // provider that spells it out anyway would have to be changed whenever the server's is.
     if (query.includeArchived) params.set("includeArchived", "true");
+    if (query.archivedOnly) params.set("archivedOnly", "true");
     const search = params.toString();
     return await request(`/flows${search ? `?${search}` : ""}`, FlowList);
   }
 
-  async function listKnowledge(
-    input: Partial<ListKnowledgeNodesInput> = {},
-  ): Promise<z.infer<typeof KnowledgeNodeList>> {
-    const query = ListKnowledgeNodesInput.parse(input);
+  async function listNodes(input: Partial<ListNodesInput> = {}): Promise<z.infer<typeof NodeList>> {
+    const query = ListNodesInput.parse(input);
     const params = new URLSearchParams({ includeArchived: String(query.includeArchived) });
     if (query.parentId !== null) params.set("parentId", query.parentId);
-    return await request(`/knowledge?${params}`, KnowledgeNodeList);
+    // Only the asked-for case travels: `archivedOnly` overrides the folder on the server, so
+    // sending it as `false` on every tree read would be noise on the one request it never applies
+    // to (#113).
+    if (query.archivedOnly) params.set("archivedOnly", "true");
+    return await request(`/nodes?${params}`, NodeList);
   }
 
   return {
     async getSession() {
       return await request("/session", SessionUser);
     },
-    listKnowledge,
+    async getCapabilities() {
+      return await request("/capabilities", IntelCapabilities);
+    },
+    listNodes,
     async listTreeChildren(parentId) {
       // Both sides of one folder, asked for in parallel and merged here rather than on the server:
       // the folder is shared, the two records are not, and no endpoint may return a row that is a
       // bit of both (ADR-0004).
-      const [knowledge, flows] = await Promise.all([
-        listKnowledge({ parentId }),
-        listFlows({ parentId }),
-      ]);
-      // ⚠️ Beide Seiten sagen, welche ihrer Zeilen etwas zum Aufklappen haben (#59) — für DIESEN
-      // Leser. Der Baum weiß es damit beim Zeichnen, ohne die Ebene darunter vorzuladen: Das wäre
-      // ein Ladevorgang pro Zeile statt pro Ordner.
-      const openable = new Set([...knowledge.withChildren, ...flows.withCalls]);
+      const [nodes, flows] = await Promise.all([listNodes({ parentId }), listFlows({ parentId })]);
+      // ⚠️ Both sides say which of their rows have something to expand (#59) — for THIS reader.
+      // The tree therefore knows it while drawing, without preloading the level below: that would
+      // be one load per row instead of per folder.
+      const openable = new Set([...nodes.withChildren, ...flows.withCalls]);
       const entries: TreeEntry[] = [
-        ...knowledge.items.map((node) => ({
-          type: "knowledge" as const,
+        ...nodes.items.map((node) => ({
+          type: "node" as const,
           id: node.id,
           title: node.title,
           kind: node.kind,
@@ -215,115 +231,125 @@ export function createIntelDataProvider(
           left.id.localeCompare(right.id),
       );
     },
-    async getKnowledge(nodeId) {
-      return await request(`/knowledge/${encodeURIComponent(nodeId)}`, KnowledgeDocument);
+    async getNode(nodeId) {
+      return await request(`/nodes/${encodeURIComponent(nodeId)}`, NodeDocument);
     },
-    async createKnowledge(input) {
-      return await request("/knowledge", KnowledgeNode, {
+    async createNodes(input) {
+      return await request("/nodes", Node, {
         method: "POST",
-        body: JSON.stringify(CreateKnowledgeNodeInput.parse(input)),
+        body: JSON.stringify(CreateNodeInput.parse(input)),
       });
     },
-    async getKnowledgeGraph(limit = 250) {
-      return await request(`/knowledge/graph?limit=${encodeURIComponent(limit)}`, KnowledgeGraph);
+    async getNodeGraph(limit = 250) {
+      return await request(`/nodes/graph?limit=${encodeURIComponent(limit)}`, NodeGraph);
     },
-    async listKnowledgeLinks(nodeId) {
-      return await request(`/knowledge/${encodeURIComponent(nodeId)}/links`, KnowledgeLinkList);
+    async listNodeLinks(nodeId) {
+      return await request(`/nodes/${encodeURIComponent(nodeId)}/links`, NodeLinkList);
     },
     // ⚠️ POST, not GET. The identifiers of the documents a text links to belong in a body: a
     // query string of them would end up in logs and referrers.
-    async resolveKnowledgeLinks(input) {
-      return await request("/knowledge/links/resolve", ResolveKnowledgeLinksResult, {
+    async resolveNodeLinks(input) {
+      return await request("/nodes/links/resolve", ResolveNodeLinksResult, {
         method: "POST",
-        body: JSON.stringify(ResolveKnowledgeLinksInput.parse(input)),
+        body: JSON.stringify(ResolveNodeLinksInput.parse(input)),
       });
     },
-    async saveKnowledge(input) {
-      const parsed = SaveKnowledgeVersionInput.parse(input);
-      return await request(
-        `/knowledge/${encodeURIComponent(parsed.nodeId)}/versions`,
-        KnowledgeDocument,
-        { method: "POST", body: JSON.stringify(parsed) },
-      );
+    async saveNode(input) {
+      const parsed = SaveNodeVersionInput.parse(input);
+      return await request(`/nodes/${encodeURIComponent(parsed.nodeId)}/versions`, NodeDocument, {
+        method: "POST",
+        body: JSON.stringify(parsed),
+      });
     },
-    async saveKnowledgeAttachment(input) {
-      const parsed = SaveKnowledgeAttachmentInput.parse(input);
-      return await request(
-        `/knowledge/${encodeURIComponent(parsed.nodeId)}/attachment`,
-        KnowledgeDocument,
-        { method: "POST", body: JSON.stringify(parsed) },
-      );
+    async saveNodeAttachment(input) {
+      const parsed = SaveAttachmentInput.parse(input);
+      return await request(`/nodes/${encodeURIComponent(parsed.nodeId)}/attachment`, NodeDocument, {
+        method: "POST",
+        body: JSON.stringify(parsed),
+      });
     },
-    async getKnowledgeAttachment(nodeId) {
-      return await (await response(`/knowledge/${encodeURIComponent(nodeId)}/attachment`)).blob();
+    async getNodeAttachment(nodeId) {
+      return await (await response(`/nodes/${encodeURIComponent(nodeId)}/attachment`)).blob();
+    },
+    async exportNodeBundle(nodeId) {
+      const path =
+        nodeId === null ? "/nodes/export" : `/nodes/${encodeURIComponent(nodeId)}/export`;
+      return await (await response(path)).blob();
+    },
+    async exportFlowBundle(flowId) {
+      return await (await response(`/flows/${encodeURIComponent(flowId)}/export`)).blob();
+    },
+    // The body IS the zip, so the idempotency key travels as a header — the same reading the
+    // server does (#137).
+    async importNodeBundle(input) {
+      const path =
+        input.nodeId === null
+          ? "/nodes/import"
+          : `/nodes/${encodeURIComponent(input.nodeId)}/import`;
+      return await request(path, BundleImportResult, {
+        method: "POST",
+        body: input.zip,
+        headers: {
+          "content-type": "application/zip",
+          "idempotency-key": input.idempotencyKey,
+        },
+      });
     },
-    async getKnowledgeTable(nodeId) {
-      return await request(`/knowledge/${encodeURIComponent(nodeId)}/table`, KnowledgeTable);
+    async getNodeTable(nodeId) {
+      return await request(`/nodes/${encodeURIComponent(nodeId)}/table`, NodeTable);
     },
-    async defineKnowledgeTable(input) {
-      const parsed = DefineKnowledgeTableInput.parse(input);
-      return await request(
-        `/knowledge/${encodeURIComponent(parsed.nodeId)}/table`,
-        KnowledgeTable,
-        {
-          method: "POST",
-          body: JSON.stringify(parsed),
-        },
-      );
+    async defineTable(input) {
+      const parsed = DefineTableInput.parse(input);
+      return await request(`/nodes/${encodeURIComponent(parsed.nodeId)}/table`, NodeTable, {
+        method: "POST",
+        body: JSON.stringify(parsed),
+      });
     },
-    async appendKnowledgeTableRows(input) {
-      const parsed = AppendKnowledgeTableRowsInput.parse(input);
+    async appendTableRows(input) {
+      const parsed = AppendTableRowsInput.parse(input);
       return await request(
-        `/knowledge/${encodeURIComponent(parsed.nodeId)}/table/rows`,
-        AppendKnowledgeTableRowsResult,
+        `/nodes/${encodeURIComponent(parsed.nodeId)}/table/rows`,
+        AppendTableRowsResult,
         { method: "POST", body: JSON.stringify(parsed) },
       );
     },
-    async listKnowledgeVersions(nodeId) {
-      return await request(
-        `/knowledge/${encodeURIComponent(nodeId)}/versions`,
-        KnowledgeVersionList,
-      );
+    async listNodeVersions(nodeId) {
+      return await request(`/nodes/${encodeURIComponent(nodeId)}/versions`, NodeVersionList);
     },
-    async updateKnowledge(input) {
-      const parsed = UpdateKnowledgeNodeInput.parse(input);
-      return await request(`/knowledge/${encodeURIComponent(parsed.nodeId)}`, KnowledgeNode, {
+    async updateNode(input) {
+      const parsed = UpdateNodeInput.parse(input);
+      return await request(`/nodes/${encodeURIComponent(parsed.nodeId)}`, Node, {
         method: "PATCH",
         body: JSON.stringify(parsed),
       });
     },
-    async archiveKnowledge(input) {
-      const parsed = ArchiveKnowledgeNodeInput.parse(input);
-      return await request(
-        `/knowledge/${encodeURIComponent(parsed.nodeId)}/archive`,
-        KnowledgeNode,
-        { method: "POST", body: JSON.stringify(parsed) },
-      );
+    async archiveNode(input) {
+      const parsed = ArchiveNodeInput.parse(input);
+      return await request(`/nodes/${encodeURIComponent(parsed.nodeId)}/archive`, Node, {
+        method: "POST",
+        body: JSON.stringify(parsed),
+      });
     },
-    async searchKnowledge(input) {
-      return await request("/knowledge/search", SearchKnowledgeResult, {
+    async searchNodes(input) {
+      return await request("/nodes/search", SearchResult, {
         method: "POST",
-        body: JSON.stringify(SearchKnowledgeInput.parse(input)),
+        body: JSON.stringify(SearchInput.parse(input)),
       });
     },
-    async listKnowledgeGrants(resourceId) {
-      return await request(
-        `/knowledge/${encodeURIComponent(resourceId)}/grants`,
-        ResourceGrantList,
-      );
+    async listGrants(resourceId) {
+      return await request(`/nodes/${encodeURIComponent(resourceId)}/grants`, ResourceGrantList);
     },
-    async shareKnowledge(input) {
-      const parsed = ShareKnowledgeInput.parse(input);
-      return await request(
-        `/knowledge/${encodeURIComponent(parsed.resourceId)}/grants`,
-        ShareKnowledgeResult,
-        { method: "POST", body: JSON.stringify(parsed) },
-      );
+    async shareNode(input) {
+      const parsed = ShareInput.parse(input);
+      return await request(`/nodes/${encodeURIComponent(parsed.resourceId)}/grants`, ShareResult, {
+        method: "POST",
+        body: JSON.stringify(parsed),
+      });
     },
-    async revokeKnowledgeGrant(input) {
-      const parsed = RevokeKnowledgeGrantInput.parse(input);
+    async revokeGrant(input) {
+      const parsed = RevokeGrantInput.parse(input);
       return await request(
-        `/knowledge/${encodeURIComponent(parsed.resourceId)}/grants/${encodeURIComponent(parsed.grantId)}/revoke`,
+        `/nodes/${encodeURIComponent(parsed.resourceId)}/grants/${encodeURIComponent(parsed.grantId)}/revoke`,
         RevokeGrantResult,
         { method: "POST", body: JSON.stringify(parsed) },
       );
@@ -435,6 +461,66 @@ export function createIntelDataProvider(
     async listTools() {
       return await request("/tools", ToolCatalog);
     },
+    async getAgent(nodeId) {
+      return await request(`/nodes/${encodeURIComponent(nodeId)}/agent`, NodeAgent);
+    },
+    // ⚠️ `CreatedAgent`, not `NodeAgent`: the create answer carries the Gate application key once
+    // (#182), and the read schema is strict — parsing this response with it would reject the one
+    // response in the product that has a credential in it.
+    async createAgent(input) {
+      return await request("/nodes/agents", CreatedAgent, {
+        method: "POST",
+        body: JSON.stringify(CreateAgentInput.parse(input)),
+      });
+    },
+    async saveAgentDefinition(input) {
+      const parsed = SaveAgentDefinitionInput.parse(input);
+      return await request(`/nodes/${encodeURIComponent(parsed.nodeId)}/agent`, NodeAgent, {
+        method: "POST",
+        body: JSON.stringify(parsed),
+      });
+    },
+    /**
+     * The agent runtime, asked through intel (#178).
+     *
+     * ⚠️ Plain `request`, with no second origin and no bearer of its own — that is the whole change.
+     * The runtime used to be a Worker this page called directly, which meant CORS it does not
+     * answer and a Gate token the browser cannot have. Intel now proxies `/agents/:agentId/*` and
+     * attaches the caller's own token server-side, so a 401 from here really is intel's session
+     * expiring and the sign-in that follows is the right one.
+     *
+     * ⚠️ A 403 is NOT that. It means the reader may not drive agents, which the agent page renders
+     * as an answer rather than as a failure.
+     */
+    async listAgentRuns(agentId) {
+      return await request(agentRuntimePath(agentId, "/runs"), AgentRunList);
+    },
+    async getAgentRun(agentId, runId) {
+      return await request(
+        agentRuntimePath(agentId, `/runs/${encodeURIComponent(runId)}`),
+        AgentRunDetail,
+      );
+    },
+    async getAgentState(agentId) {
+      return await request(agentRuntimePath(agentId, "/state"), AgentState);
+    },
+    async pauseAgent(agentId) {
+      return await request(agentRuntimePath(agentId, "/pause"), AgentState, { method: "POST" });
+    },
+    async resumeAgent(agentId) {
+      return await request(agentRuntimePath(agentId, "/resume"), AgentState, { method: "POST" });
+    },
+    async runAgentNow(agentId, target) {
+      return await request(agentRuntimePath(agentId, "/run"), AgentManualRun, {
+        method: "POST",
+        body: JSON.stringify({ target }),
+      });
+    },
+    agentChatApi(agentId) {
+      // assistant-ui dials this itself, so it needs the path a browser can use — the same one every
+      // other call above goes to, intel's own `/api/v1`.
+      return `${baseUrl}/api/v1${agentRuntimePath(agentId, "/chat")}`;
+    },
 
     // The Worker serves the connect route, so this navigation belongs to the data layer for the
     // same reason `loginPath` does. `silent=1` is what makes it a redirect nobody has to watch.