@anchrd/intel-api 0.6.7 → 0.9.0

package/dist/indexing/indexing.js

@@ -10,7 +10,7 @@ function indexText(mediaType, content) {
     catch (error) {
         // Immutable content never becomes parsable on a retry, so treating this as transient would
         // requeue the version until the queue gives up and would bury the real cause.
-        throw new PermanentIndexingError(`Knowledge version content is not a valid BlockNote document: ${error instanceof Error ? error.message : "unknown parse failure"}`);
+        throw new PermanentIndexingError(`Node version content is not a valid BlockNote document: ${error instanceof Error ? error.message : "unknown parse failure"}`);
     }
 }
 async function readCanonical(deps, target) {
@@ -29,13 +29,25 @@ export function createIndexing(deps) {
             const target = await deps.repository.getTarget(versionId);
             if (!target)
                 return;
+            // ⚠️ An agent's body is a definition, not something to read: node IDs, a cron line and a model
+            // name (ADR-0005 §4). Indexing it verbatim would fill the index with identifiers and, worse,
+            // put them into the passage a searcher is shown — the definition names nodes the searcher may
+            // have no access to, and a snippet is the one place their IDs would become visible without
+            // the tree being asked. What makes an agent findable is what a person wrote about it, so the
+            // text is its description, and the FTS table indexes the title on its own (#139).
+            if (target.kind === "agent") {
+                await deps.repository.replace(target, target.description ?? "");
+                await deps.semantic?.replace(target, target.description ?? "");
+                await deps.repository.markIndexed(versionId, deps.now().toISOString());
+                return;
+            }
             // An attachment is one object of bytes; text kinds may be several, because a table's content
             // is the join of its versions (#40). A missing segment fails the whole pass rather than
             // indexing a table with a hole in it.
             const canonical = await readCanonical(deps, target);
             if (canonical === null) {
                 await deps.repository.markError(versionId, "content_missing", deps.now().toISOString());
-                throw new Error("Knowledge version content is missing");
+                throw new Error("Node version content is missing");
             }
             try {
                 const text = typeof canonical === "string"

package/dist/indexing/indexing.types.d.ts

@@ -1,8 +1,8 @@
 import type { DocumentConverter } from "../adapters/document-converter/document-converter.types.js";
 import type { SemanticIndex } from "../adapters/semantic-index/semantic-index.types.js";
-import type { ContentStore, KnowledgeIndexRepository } from "../knowledge/knowledge.types.js";
+import type { ContentStore, NodeIndexRepository } from "../nodes/nodes.types.js";
 export interface IndexingDeps {
-    repository: KnowledgeIndexRepository;
+    repository: NodeIndexRepository;
     content: ContentStore;
     semantic?: SemanticIndex | undefined;
     converter?: DocumentConverter | undefined;

package/dist/intel/intel.js

@@ -1,7 +1,7 @@
 import { Hono } from "hono";
 import { createHttp } from "../http/http.js";
 import { handleMcp } from "../mcp/mcp.js";
-import { authorize, authorizeBearer } from "../shared/gate-authorization/gate-authorization.js";
+import { authorize, authorizeBearer, bearer, } from "../shared/gate-authorization/gate-authorization.js";
 import { IntelError } from "../shared/intel-error/intel-error.js";
 import { problemDetails } from "../shared/problem-details/problem-details.js";
 import { reportUnexpectedError } from "../shared/report-unexpected-error/report-unexpected-error.js";
@@ -68,9 +68,11 @@ export function createIntel(deps) {
     }
     app.route("/api/v1", createHttp({
         gate: deps.gate,
-        knowledge: deps.knowledge,
+        nodes: deps.nodes,
         flows: deps.flows,
         tools: deps.tools,
+        bundle: deps.bundle,
+        agents: deps.agents,
         resource,
         resourceMetadataUrl,
         ...(deps.auth ? { auth: deps.auth } : {}),
@@ -83,9 +85,16 @@ export function createIntel(deps) {
         }
         return await handleMcp(context.req.raw, {
             authorization,
+            // ⚠️ The very token this call was authorized with, so the agent tools reach the runtime as the
+            // caller and not as Intel. There is no cookie path on `/mcp`, so `bearer` is the same value
+            // `authorize` just used — read again rather than passed out of it, because a function that
+            // returned a credential beside its answer would be one somebody logs.
+            bearer: bearer(context.req.raw.headers) ?? "",
+            agents: deps.agents,
             flows: deps.flows,
-            knowledge: deps.knowledge,
+            nodes: deps.nodes,
             tools: deps.tools,
+            bundle: deps.bundle,
         });
     });
     return app;

package/dist/intel/intel.types.d.ts

@@ -1,14 +1,18 @@
 import type { GateClient } from "@anchrd/gate-sdk";
+import type { AgentRuntimeService } from "../agent-runtime/agent-runtime.types.js";
 import type { BrowserAuth } from "../auth/auth.types.js";
+import type { BundleService } from "../bundle/bundle.types.js";
 import type { FlowService } from "../flows/flows.types.js";
-import type { KnowledgeService } from "../knowledge/knowledge.types.js";
+import type { NodeService } from "../nodes/nodes.types.js";
 import type { ToolService } from "../tools/tools.types.js";
 export interface IntelDeps {
     baseUrl: string;
     gateUrl: string;
     gate: Pick<GateClient, "authorize">;
-    knowledge: KnowledgeService;
+    nodes: NodeService;
     flows: FlowService;
     tools: ToolService;
+    bundle: BundleService;
+    agents: AgentRuntimeService;
     auth?: BrowserAuth;
 }