@anchrd/intel-contract 0.4.2 → 0.7.0

package/dist/contract/contract.d.ts

@@ -16,13 +16,18 @@ export declare const SessionUser: z.ZodObject<{
     name: z.ZodNullable<z.ZodString>;
 }, z.core.$strict>;
 export type SessionUser = z.infer<typeof SessionUser>;
-export declare const KnowledgeNodeKind: z.ZodEnum<{
+export declare const IntelCapabilities: z.ZodObject<{
+    agentRuntime: z.ZodBoolean;
+}, z.core.$strict>;
+export type IntelCapabilities = z.infer<typeof IntelCapabilities>;
+export declare const NodeKind: z.ZodEnum<{
     folder: "folder";
     document: "document";
     attachment: "attachment";
     table: "table";
+    agent: "agent";
 }>;
-export type KnowledgeNodeKind = z.infer<typeof KnowledgeNodeKind>;
+export type NodeKind = z.infer<typeof NodeKind>;
 export declare const ResourceVerb: z.ZodEnum<{
     read: "read";
     write: "write";
@@ -40,7 +45,7 @@ export declare const SharePrincipal: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"organization">;
 }, z.core.$strict>], "type">;
 export type SharePrincipal = z.infer<typeof SharePrincipal>;
-export declare const KnowledgeNode: z.ZodObject<{
+export declare const Node: z.ZodObject<{
     id: z.ZodString;
     parentId: z.ZodNullable<z.ZodString>;
     kind: z.ZodEnum<{
@@ -48,6 +53,7 @@ export declare const KnowledgeNode: z.ZodObject<{
         document: "document";
         attachment: "attachment";
         table: "table";
+        agent: "agent";
     }>;
     title: z.ZodString;
     description: z.ZodNullable<z.ZodString>;
@@ -57,8 +63,13 @@ export declare const KnowledgeNode: z.ZodObject<{
     updatedAt: z.ZodISODateTime;
     archivedAt: z.ZodNullable<z.ZodISODateTime>;
 }, z.core.$strict>;
-export type KnowledgeNode = z.infer<typeof KnowledgeNode>;
-export declare const KnowledgeVersion: z.ZodObject<{
+export type Node = z.infer<typeof Node>;
+export declare const NodeVersionSegment: z.ZodEnum<{
+    append: "append";
+    snapshot: "snapshot";
+}>;
+export type NodeVersionSegment = z.infer<typeof NodeVersionSegment>;
+export declare const NodeVersion: z.ZodObject<{
     id: z.ZodString;
     nodeId: z.ZodString;
     sequence: z.ZodNumber;
@@ -66,54 +77,64 @@ export declare const KnowledgeVersion: z.ZodObject<{
     mediaType: z.ZodString;
     contentHash: z.ZodString;
     size: z.ZodNumber;
+    segment: z.ZodNullable<z.ZodEnum<{
+        append: "append";
+        snapshot: "snapshot";
+    }>>;
     createdBy: z.ZodString;
     createdAt: z.ZodISODateTime;
 }, z.core.$strict>;
-export type KnowledgeVersion = z.infer<typeof KnowledgeVersion>;
-export declare const ListKnowledgeNodesInput: z.ZodObject<{
+export type NodeVersion = z.infer<typeof NodeVersion>;
+export declare const ListNodesInput: z.ZodObject<{
     parentId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
     includeArchived: z.ZodDefault<z.ZodBoolean>;
     archivedOnly: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strict>;
-export type ListKnowledgeNodesInput = z.infer<typeof ListKnowledgeNodesInput>;
-export declare const GetKnowledgeNodeInput: z.ZodObject<{
+export type ListNodesInput = z.infer<typeof ListNodesInput>;
+export declare const GetNodeInput: z.ZodObject<{
+    nodeId: z.ZodString;
+}, z.core.$strict>;
+export type GetNodeInput = z.infer<typeof GetNodeInput>;
+export declare const GetNodeVersionInput: z.ZodObject<{
     nodeId: z.ZodString;
+    versionId: z.ZodString;
 }, z.core.$strict>;
-export type GetKnowledgeNodeInput = z.infer<typeof GetKnowledgeNodeInput>;
-export declare const ListKnowledgeGrantsInput: z.ZodObject<{
+export type GetNodeVersionInput = z.infer<typeof GetNodeVersionInput>;
+export declare const ListGrantsInput: z.ZodObject<{
     resourceId: z.ZodString;
 }, z.core.$strict>;
-export type ListKnowledgeGrantsInput = z.infer<typeof ListKnowledgeGrantsInput>;
-export declare const CreateKnowledgeNodeInput: z.ZodObject<{
+export type ListGrantsInput = z.infer<typeof ListGrantsInput>;
+export declare const CreateNodeInput: z.ZodObject<{
     parentId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
     kind: z.ZodEnum<{
         folder: "folder";
         document: "document";
         attachment: "attachment";
         table: "table";
+        agent: "agent";
     }>;
     title: z.ZodString;
     description: z.ZodDefault<z.ZodNullable<z.ZodString>>;
     idempotencyKey: z.ZodString;
 }, z.core.$strict>;
-export type CreateKnowledgeNodeInput = z.infer<typeof CreateKnowledgeNodeInput>;
-export declare const SaveKnowledgeVersionInput: z.ZodObject<{
+export type CreateNodeInput = z.infer<typeof CreateNodeInput>;
+export declare const SaveNodeVersionInput: z.ZodObject<{
     nodeId: z.ZodString;
     baseVersionId: z.ZodNullable<z.ZodString>;
     content: z.ZodString;
     mediaType: z.ZodDefault<z.ZodString>;
     idempotencyKey: z.ZodString;
 }, z.core.$strict>;
-export type SaveKnowledgeVersionInput = z.infer<typeof SaveKnowledgeVersionInput>;
-export declare const SaveKnowledgeAttachmentInput: z.ZodObject<{
+export type SaveNodeVersionInput = z.infer<typeof SaveNodeVersionInput>;
+export declare const SaveAttachmentInput: z.ZodObject<{
     nodeId: z.ZodString;
     baseVersionId: z.ZodNullable<z.ZodString>;
     contentBase64: z.ZodString;
     mediaType: z.ZodString;
     idempotencyKey: z.ZodString;
 }, z.core.$strict>;
-export type SaveKnowledgeAttachmentInput = z.infer<typeof SaveKnowledgeAttachmentInput>;
-export declare const UpdateKnowledgeNodeInput: z.ZodObject<{
+export type SaveAttachmentInput = z.infer<typeof SaveAttachmentInput>;
+export declare const UpdateNodeInput: z.ZodObject<{
     nodeId: z.ZodString;
     baseUpdatedAt: z.ZodISODateTime;
     title: z.ZodOptional<z.ZodString>;
@@ -121,15 +142,15 @@ export declare const UpdateKnowledgeNodeInput: z.ZodObject<{
     parentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     idempotencyKey: z.ZodString;
 }, z.core.$strict>;
-export type UpdateKnowledgeNodeInput = z.infer<typeof UpdateKnowledgeNodeInput>;
-export declare const ArchiveKnowledgeNodeInput: z.ZodObject<{
+export type UpdateNodeInput = z.infer<typeof UpdateNodeInput>;
+export declare const ArchiveNodeInput: z.ZodObject<{
     nodeId: z.ZodString;
     baseUpdatedAt: z.ZodISODateTime;
     archived: z.ZodBoolean;
     idempotencyKey: z.ZodString;
 }, z.core.$strict>;
-export type ArchiveKnowledgeNodeInput = z.infer<typeof ArchiveKnowledgeNodeInput>;
-export declare const KnowledgeNodeList: z.ZodObject<{
+export type ArchiveNodeInput = z.infer<typeof ArchiveNodeInput>;
+export declare const NodeList: z.ZodObject<{
     items: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         parentId: z.ZodNullable<z.ZodString>;
@@ -138,6 +159,7 @@ export declare const KnowledgeNodeList: z.ZodObject<{
             document: "document";
             attachment: "attachment";
             table: "table";
+            agent: "agent";
         }>;
         title: z.ZodString;
         description: z.ZodNullable<z.ZodString>;
@@ -149,8 +171,8 @@ export declare const KnowledgeNodeList: z.ZodObject<{
     }, z.core.$strict>>;
     withChildren: z.ZodDefault<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;
-export type KnowledgeNodeList = z.infer<typeof KnowledgeNodeList>;
-export declare const KnowledgeVersionList: z.ZodObject<{
+export type NodeList = z.infer<typeof NodeList>;
+export declare const NodeVersionList: z.ZodObject<{
     items: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         nodeId: z.ZodString;
@@ -159,12 +181,16 @@ export declare const KnowledgeVersionList: z.ZodObject<{
         mediaType: z.ZodString;
         contentHash: z.ZodString;
         size: z.ZodNumber;
+        segment: z.ZodNullable<z.ZodEnum<{
+            append: "append";
+            snapshot: "snapshot";
+        }>>;
         createdBy: z.ZodString;
         createdAt: z.ZodISODateTime;
     }, z.core.$strict>>;
 }, z.core.$strict>;
-export type KnowledgeVersionList = z.infer<typeof KnowledgeVersionList>;
-export declare const KnowledgeDocument: z.ZodObject<{
+export type NodeVersionList = z.infer<typeof NodeVersionList>;
+export declare const NodeDocument: z.ZodObject<{
     node: z.ZodObject<{
         id: z.ZodString;
         parentId: z.ZodNullable<z.ZodString>;
@@ -173,6 +199,7 @@ export declare const KnowledgeDocument: z.ZodObject<{
             document: "document";
             attachment: "attachment";
             table: "table";
+            agent: "agent";
         }>;
         title: z.ZodString;
         description: z.ZodNullable<z.ZodString>;
@@ -190,13 +217,17 @@ export declare const KnowledgeDocument: z.ZodObject<{
         mediaType: z.ZodString;
         contentHash: z.ZodString;
         size: z.ZodNumber;
+        segment: z.ZodNullable<z.ZodEnum<{
+            append: "append";
+            snapshot: "snapshot";
+        }>>;
         createdBy: z.ZodString;
         createdAt: z.ZodISODateTime;
     }, z.core.$strict>>;
     content: z.ZodNullable<z.ZodString>;
 }, z.core.$strict>;
-export type KnowledgeDocument = z.infer<typeof KnowledgeDocument>;
-export declare const KnowledgeAttachment: z.ZodObject<{
+export type NodeDocument = z.infer<typeof NodeDocument>;
+export declare const NodeAttachment: z.ZodObject<{
     node: z.ZodObject<{
         id: z.ZodString;
         parentId: z.ZodNullable<z.ZodString>;
@@ -205,6 +236,7 @@ export declare const KnowledgeAttachment: z.ZodObject<{
             document: "document";
             attachment: "attachment";
             table: "table";
+            agent: "agent";
         }>;
         title: z.ZodString;
         description: z.ZodNullable<z.ZodString>;
@@ -222,33 +254,37 @@ export declare const KnowledgeAttachment: z.ZodObject<{
         mediaType: z.ZodString;
         contentHash: z.ZodString;
         size: z.ZodNumber;
+        segment: z.ZodNullable<z.ZodEnum<{
+            append: "append";
+            snapshot: "snapshot";
+        }>>;
         createdBy: z.ZodString;
         createdAt: z.ZodISODateTime;
     }, z.core.$strict>;
     resourceUri: z.ZodString;
 }, z.core.$strict>;
-export type KnowledgeAttachment = z.infer<typeof KnowledgeAttachment>;
+export type NodeAttachment = z.infer<typeof NodeAttachment>;
 export declare const TableMediaType = "text/csv";
 export declare const TableColumn: z.ZodString;
 export declare const TableCell: z.ZodString;
 export declare const TableRow: z.ZodArray<z.ZodString>;
-export declare const DefineKnowledgeTableInput: z.ZodObject<{
+export declare const DefineTableInput: z.ZodObject<{
     nodeId: z.ZodString;
     columns: z.ZodArray<z.ZodString>;
     idempotencyKey: z.ZodString;
 }, z.core.$strict>;
-export type DefineKnowledgeTableInput = z.infer<typeof DefineKnowledgeTableInput>;
-export declare const AppendKnowledgeTableRowsInput: z.ZodObject<{
+export type DefineTableInput = z.infer<typeof DefineTableInput>;
+export declare const AppendTableRowsInput: z.ZodObject<{
     nodeId: z.ZodString;
     rows: z.ZodArray<z.ZodArray<z.ZodString>>;
     idempotencyKey: z.ZodString;
 }, z.core.$strict>;
-export type AppendKnowledgeTableRowsInput = z.infer<typeof AppendKnowledgeTableRowsInput>;
-export declare const GetKnowledgeTableInput: z.ZodObject<{
+export type AppendTableRowsInput = z.infer<typeof AppendTableRowsInput>;
+export declare const GetTableInput: z.ZodObject<{
     nodeId: z.ZodString;
 }, z.core.$strict>;
-export type GetKnowledgeTableInput = z.infer<typeof GetKnowledgeTableInput>;
-export declare const KnowledgeTable: z.ZodObject<{
+export type GetTableInput = z.infer<typeof GetTableInput>;
+export declare const NodeTable: z.ZodObject<{
     node: z.ZodObject<{
         id: z.ZodString;
         parentId: z.ZodNullable<z.ZodString>;
@@ -257,6 +293,7 @@ export declare const KnowledgeTable: z.ZodObject<{
             document: "document";
             attachment: "attachment";
             table: "table";
+            agent: "agent";
         }>;
         title: z.ZodString;
         description: z.ZodNullable<z.ZodString>;
@@ -270,8 +307,8 @@ export declare const KnowledgeTable: z.ZodObject<{
     rows: z.ZodArray<z.ZodArray<z.ZodString>>;
     versionId: z.ZodNullable<z.ZodString>;
 }, z.core.$strict>;
-export type KnowledgeTable = z.infer<typeof KnowledgeTable>;
-export declare const AppendKnowledgeTableRowsResult: z.ZodObject<{
+export type NodeTable = z.infer<typeof NodeTable>;
+export declare const AppendTableRowsResult: z.ZodObject<{
     node: z.ZodObject<{
         id: z.ZodString;
         parentId: z.ZodNullable<z.ZodString>;
@@ -280,6 +317,7 @@ export declare const AppendKnowledgeTableRowsResult: z.ZodObject<{
             document: "document";
             attachment: "attachment";
             table: "table";
+            agent: "agent";
         }>;
         title: z.ZodString;
         description: z.ZodNullable<z.ZodString>;
@@ -297,25 +335,584 @@ export declare const AppendKnowledgeTableRowsResult: z.ZodObject<{
         mediaType: z.ZodString;
         contentHash: z.ZodString;
         size: z.ZodNumber;
+        segment: z.ZodNullable<z.ZodEnum<{
+            append: "append";
+            snapshot: "snapshot";
+        }>>;
         createdBy: z.ZodString;
         createdAt: z.ZodISODateTime;
     }, z.core.$strict>;
     appended: z.ZodNumber;
 }, z.core.$strict>;
-export type AppendKnowledgeTableRowsResult = z.infer<typeof AppendKnowledgeTableRowsResult>;
-export declare const KnowledgeLinkRelation: z.ZodEnum<{
+export type AppendTableRowsResult = z.infer<typeof AppendTableRowsResult>;
+export declare const TableRowPosition: z.ZodNumber;
+export declare const UpdateTableRowsInput: z.ZodObject<{
+    nodeId: z.ZodString;
+    baseVersionId: z.ZodString;
+    updates: z.ZodArray<z.ZodObject<{
+        position: z.ZodNumber;
+        row: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    idempotencyKey: z.ZodString;
+}, z.core.$strict>;
+export type UpdateTableRowsInput = z.infer<typeof UpdateTableRowsInput>;
+export declare const UpdateTableRowsResult: z.ZodObject<{
+    node: z.ZodObject<{
+        id: z.ZodString;
+        parentId: z.ZodNullable<z.ZodString>;
+        kind: z.ZodEnum<{
+            folder: "folder";
+            document: "document";
+            attachment: "attachment";
+            table: "table";
+            agent: "agent";
+        }>;
+        title: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        ownerId: z.ZodString;
+        currentVersionId: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+        archivedAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>;
+    version: z.ZodObject<{
+        id: z.ZodString;
+        nodeId: z.ZodString;
+        sequence: z.ZodNumber;
+        contentKey: z.ZodString;
+        mediaType: z.ZodString;
+        contentHash: z.ZodString;
+        size: z.ZodNumber;
+        segment: z.ZodNullable<z.ZodEnum<{
+            append: "append";
+            snapshot: "snapshot";
+        }>>;
+        createdBy: z.ZodString;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+    updated: z.ZodNumber;
+}, z.core.$strict>;
+export type UpdateTableRowsResult = z.infer<typeof UpdateTableRowsResult>;
+export declare const DeleteTableRowsInput: z.ZodObject<{
+    nodeId: z.ZodString;
+    baseVersionId: z.ZodString;
+    positions: z.ZodArray<z.ZodNumber>;
+    idempotencyKey: z.ZodString;
+}, z.core.$strict>;
+export type DeleteTableRowsInput = z.infer<typeof DeleteTableRowsInput>;
+export declare const DeleteTableRowsResult: z.ZodObject<{
+    node: z.ZodObject<{
+        id: z.ZodString;
+        parentId: z.ZodNullable<z.ZodString>;
+        kind: z.ZodEnum<{
+            folder: "folder";
+            document: "document";
+            attachment: "attachment";
+            table: "table";
+            agent: "agent";
+        }>;
+        title: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        ownerId: z.ZodString;
+        currentVersionId: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+        archivedAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>;
+    version: z.ZodObject<{
+        id: z.ZodString;
+        nodeId: z.ZodString;
+        sequence: z.ZodNumber;
+        contentKey: z.ZodString;
+        mediaType: z.ZodString;
+        contentHash: z.ZodString;
+        size: z.ZodNumber;
+        segment: z.ZodNullable<z.ZodEnum<{
+            append: "append";
+            snapshot: "snapshot";
+        }>>;
+        createdBy: z.ZodString;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+    deleted: z.ZodNumber;
+}, z.core.$strict>;
+export type DeleteTableRowsResult = z.infer<typeof DeleteTableRowsResult>;
+export declare const RedefineTableColumn: z.ZodObject<{
+    name: z.ZodString;
+    source: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export type RedefineTableColumn = z.infer<typeof RedefineTableColumn>;
+export declare const RedefineTableInput: z.ZodObject<{
+    nodeId: z.ZodString;
+    baseVersionId: z.ZodString;
+    columns: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        source: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strict>>;
+    idempotencyKey: z.ZodString;
+}, z.core.$strict>;
+export type RedefineTableInput = z.infer<typeof RedefineTableInput>;
+export declare const AgentMediaType = "application/vnd.anchrd.agent+json";
+export declare const AgentReferenceRole: z.ZodEnum<{
+    "system-message": "system-message";
+    "semantic-context": "semantic-context";
+    memory: "memory";
+}>;
+export type AgentReferenceRole = z.infer<typeof AgentReferenceRole>;
+export declare const AgentReference: z.ZodObject<{
+    nodeId: z.ZodString;
+    role: z.ZodEnum<{
+        "system-message": "system-message";
+        "semantic-context": "semantic-context";
+        memory: "memory";
+    }>;
+}, z.core.$strict>;
+export type AgentReference = z.infer<typeof AgentReference>;
+export declare const AgentScheduleTarget: z.ZodObject<{
+    kind: z.ZodEnum<{
+        document: "document";
+        flow: "flow";
+    }>;
+    id: z.ZodString;
+}, z.core.$strict>;
+export type AgentScheduleTarget = z.infer<typeof AgentScheduleTarget>;
+export declare const AgentSchedule: z.ZodObject<{
+    cron: z.ZodString;
+    target: z.ZodObject<{
+        kind: z.ZodEnum<{
+            document: "document";
+            flow: "flow";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type AgentSchedule = z.infer<typeof AgentSchedule>;
+export declare const AgentModel: z.ZodObject<{
+    provider: z.ZodEnum<{
+        "workers-ai": "workers-ai";
+        anthropic: "anthropic";
+    }>;
+    model: z.ZodString;
+}, z.core.$strict>;
+export type AgentModel = z.infer<typeof AgentModel>;
+/**
+ * One MCP server as the portal names it. The handle is what the portal puts in front of every tool
+ * that server offers (`notion_notion-search` belongs to `notion`), and it is the only identifier
+ * Intel can both store and recognise again in a live `tools/list`.
+ *
+ * ⚠️ A handle is never invented from a tool name. Which servers exist is the portal's answer
+ * (`portal_list_servers`), and the prefix is only used to attribute a tool to a server that answer
+ * already named — see `packages/api/src/tools/tool-servers` for why splitting on the underscore
+ * alone would be ambiguous.
+ */
+export declare const ToolServerHandle: z.ZodString;
+export type ToolServerHandle = z.infer<typeof ToolServerHandle>;
+/**
+ * What a caller may ASK for: whole MCP servers, and nothing about who delegates them (D30).
+ *
+ * ⚠️ The absence of `delegatedBy` is the point, and it is why the write shape differs from the read
+ * shape at all. Intel writes that field from the session it authorized; a caller who could name
+ * somebody else would be handing an agent a portal connection they do not have, and the agent would
+ * act on it unattended. Leaving the field out of the input makes that structural instead of a
+ * runtime overwrite: a body carrying it is a parse error at the boundary, on every surface, and no
+ * screen ever has to invent a value it has no business knowing.
+ */
+export declare const AgentToolSelection: z.ZodObject<{
+    servers: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type AgentToolSelection = z.infer<typeof AgentToolSelection>;
+/**
+ * What is STORED and read back: the selection plus whose portal connection it came from (D30).
+ *
+ * ⚠️ This is a selection, not a permission. Nothing here grants anything: whether a server is
+ * reachable is still decided by one live `tools/list` with `delegatedBy`'s own portal token, so a
+ * delegator who loses the server or the connection takes it away from the agent at the next run
+ * with no edit to this document.
+ *
+ * ⚠️ Read shape only. It appears in `AgentDefinition` and never in an input — see
+ * `AgentToolSelection` for why the two are deliberately different documents rather than one schema
+ * with an optional field.
+ */
+export declare const AgentToolDelegation: z.ZodObject<{
+    delegatedBy: z.ZodString;
+    servers: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type AgentToolDelegation = z.infer<typeof AgentToolDelegation>;
+export declare const AgentDefinition: z.ZodObject<{
+    tools: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        delegatedBy: z.ZodString;
+        servers: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>>;
+    references: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        nodeId: z.ZodString;
+        role: z.ZodEnum<{
+            "system-message": "system-message";
+            "semantic-context": "semantic-context";
+            memory: "memory";
+        }>;
+    }, z.core.$strict>>>;
+    schedules: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        cron: z.ZodString;
+        target: z.ZodObject<{
+            kind: z.ZodEnum<{
+                document: "document";
+                flow: "flow";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>>;
+    model: z.ZodObject<{
+        provider: z.ZodEnum<{
+            "workers-ai": "workers-ai";
+            anthropic: "anthropic";
+        }>;
+        model: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type AgentDefinition = z.infer<typeof AgentDefinition>;
+/**
+ * The same document as `AgentDefinition`, minus the one field a caller may not write.
+ *
+ * ⚠️ Two schemas rather than one, and the split is load-bearing (#208, D30). Everything an agent IS
+ * comes from whoever edits it; **whose portal connection it acts on** does not, because that is an
+ * authority the editor would be granting to themselves. So the write shape simply has no place to
+ * put it: `{ tools: { servers: [...] } }` is what a screen or an MCP client sends, Intel adds
+ * `delegatedBy` from the session, and a body that tries to name one is refused by the strict object
+ * before any of it is read. The reading shape keeps the field because a reader must be able to see
+ * whose connection an agent runs on.
+ */
+export declare const AgentDefinitionInput: z.ZodObject<{
+    tools: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        servers: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>>;
+    references: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        nodeId: z.ZodString;
+        role: z.ZodEnum<{
+            "system-message": "system-message";
+            "semantic-context": "semantic-context";
+            memory: "memory";
+        }>;
+    }, z.core.$strict>>>;
+    schedules: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        cron: z.ZodString;
+        target: z.ZodObject<{
+            kind: z.ZodEnum<{
+                document: "document";
+                flow: "flow";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>>;
+    model: z.ZodObject<{
+        provider: z.ZodEnum<{
+            "workers-ai": "workers-ai";
+            anthropic: "anthropic";
+        }>;
+        model: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type AgentDefinitionInput = z.infer<typeof AgentDefinitionInput>;
+export declare const SaveAgentDefinitionInput: z.ZodObject<{
+    nodeId: z.ZodString;
+    baseVersionId: z.ZodNullable<z.ZodString>;
+    definition: z.ZodObject<{
+        tools: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            servers: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>>;
+        references: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            nodeId: z.ZodString;
+            role: z.ZodEnum<{
+                "system-message": "system-message";
+                "semantic-context": "semantic-context";
+                memory: "memory";
+            }>;
+        }, z.core.$strict>>>;
+        schedules: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            cron: z.ZodString;
+            target: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    document: "document";
+                    flow: "flow";
+                }>;
+                id: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>>;
+        model: z.ZodObject<{
+            provider: z.ZodEnum<{
+                "workers-ai": "workers-ai";
+                anthropic: "anthropic";
+            }>;
+            model: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    idempotencyKey: z.ZodString;
+}, z.core.$strict>;
+export type SaveAgentDefinitionInput = z.infer<typeof SaveAgentDefinitionInput>;
+export declare const GetAgentInput: z.ZodObject<{
+    nodeId: z.ZodString;
+}, z.core.$strict>;
+export type GetAgentInput = z.infer<typeof GetAgentInput>;
+export declare const PauseAgentInput: z.ZodObject<{
+    nodeId: z.ZodString;
+}, z.core.$strict>;
+export type PauseAgentInput = z.infer<typeof PauseAgentInput>;
+export declare const RunAgentNowInput: z.ZodObject<{
+    nodeId: z.ZodString;
+    target: z.ZodObject<{
+        kind: z.ZodEnum<{
+            document: "document";
+            flow: "flow";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type RunAgentNowInput = z.infer<typeof RunAgentNowInput>;
+export declare const ListAgentsInput: z.ZodObject<{
+    parentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    includeArchived: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export type ListAgentsInput = z.infer<typeof ListAgentsInput>;
+export declare const CreateAgentInput: z.ZodObject<{
+    parentId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    title: z.ZodString;
+    description: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    definition: z.ZodObject<{
+        tools: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            servers: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>>;
+        references: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            nodeId: z.ZodString;
+            role: z.ZodEnum<{
+                "system-message": "system-message";
+                "semantic-context": "semantic-context";
+                memory: "memory";
+            }>;
+        }, z.core.$strict>>>;
+        schedules: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            cron: z.ZodString;
+            target: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    document: "document";
+                    flow: "flow";
+                }>;
+                id: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>>;
+        model: z.ZodObject<{
+            provider: z.ZodEnum<{
+                "workers-ai": "workers-ai";
+                anthropic: "anthropic";
+            }>;
+            model: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    idempotencyKey: z.ZodString;
+}, z.core.$strict>;
+export type CreateAgentInput = z.infer<typeof CreateAgentInput>;
+export declare const GateApplicationId: z.ZodString;
+export declare const NodeAgent: z.ZodObject<{
+    node: z.ZodObject<{
+        id: z.ZodString;
+        parentId: z.ZodNullable<z.ZodString>;
+        kind: z.ZodEnum<{
+            folder: "folder";
+            document: "document";
+            attachment: "attachment";
+            table: "table";
+            agent: "agent";
+        }>;
+        title: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        ownerId: z.ZodString;
+        currentVersionId: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+        archivedAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>;
+    version: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        nodeId: z.ZodString;
+        sequence: z.ZodNumber;
+        contentKey: z.ZodString;
+        mediaType: z.ZodString;
+        contentHash: z.ZodString;
+        size: z.ZodNumber;
+        segment: z.ZodNullable<z.ZodEnum<{
+            append: "append";
+            snapshot: "snapshot";
+        }>>;
+        createdBy: z.ZodString;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    definition: z.ZodNullable<z.ZodObject<{
+        tools: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            delegatedBy: z.ZodString;
+            servers: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>>;
+        references: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            nodeId: z.ZodString;
+            role: z.ZodEnum<{
+                "system-message": "system-message";
+                "semantic-context": "semantic-context";
+                memory: "memory";
+            }>;
+        }, z.core.$strict>>>;
+        schedules: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            cron: z.ZodString;
+            target: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    document: "document";
+                    flow: "flow";
+                }>;
+                id: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>>;
+        model: z.ZodObject<{
+            provider: z.ZodEnum<{
+                "workers-ai": "workers-ai";
+                anthropic: "anthropic";
+            }>;
+            model: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    applicationId: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type NodeAgent = z.infer<typeof NodeAgent>;
+/**
+ * ⚠️ There is NO key field in this file, and adding one back would be the regression (D29, #207).
+ *
+ * Until #207 the create answer carried the Application key in plain text, once, and a person had to
+ * carry it into a Worker secret by hand — which is why an agent created through the screen could
+ * never run (#200). The key now goes from Gate straight into the agent runtime over Intel's service
+ * binding and is encrypted into that agent's Durable Object; it reaches no browser, no MCP tool
+ * result and no response body at all. `NodeAgent` is a `z.strictObject`, so a field named `key`
+ * added anywhere in this file is a parse error at the boundary rather than a leak somebody has to
+ * spot in review.
+ *
+ * What `POST /nodes/agents` and `agent_create` answer is therefore exactly what every read answers:
+ * the node, its first definition, and the `applicationId` that NAMES the principal without
+ * authenticating it.
+ */
+export declare const CreatedAgent: z.ZodObject<{
+    node: z.ZodObject<{
+        id: z.ZodString;
+        parentId: z.ZodNullable<z.ZodString>;
+        kind: z.ZodEnum<{
+            folder: "folder";
+            document: "document";
+            attachment: "attachment";
+            table: "table";
+            agent: "agent";
+        }>;
+        title: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        ownerId: z.ZodString;
+        currentVersionId: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+        archivedAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>;
+    version: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        nodeId: z.ZodString;
+        sequence: z.ZodNumber;
+        contentKey: z.ZodString;
+        mediaType: z.ZodString;
+        contentHash: z.ZodString;
+        size: z.ZodNumber;
+        segment: z.ZodNullable<z.ZodEnum<{
+            append: "append";
+            snapshot: "snapshot";
+        }>>;
+        createdBy: z.ZodString;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    definition: z.ZodNullable<z.ZodObject<{
+        tools: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            delegatedBy: z.ZodString;
+            servers: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>>;
+        references: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            nodeId: z.ZodString;
+            role: z.ZodEnum<{
+                "system-message": "system-message";
+                "semantic-context": "semantic-context";
+                memory: "memory";
+            }>;
+        }, z.core.$strict>>>;
+        schedules: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            cron: z.ZodString;
+            target: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    document: "document";
+                    flow: "flow";
+                }>;
+                id: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>>;
+        model: z.ZodObject<{
+            provider: z.ZodEnum<{
+                "workers-ai": "workers-ai";
+                anthropic: "anthropic";
+            }>;
+            model: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    applicationId: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type CreatedAgent = z.infer<typeof CreatedAgent>;
+export declare const RotateAgentKeyInput: z.ZodObject<{
+    nodeId: z.ZodString;
+}, z.core.$strict>;
+export type RotateAgentKeyInput = z.infer<typeof RotateAgentKeyInput>;
+/**
+ * What replacing an agent's key answers.
+ *
+ * ⚠️ No key, and that is the whole shape of D29: Intel asks Gate for a new one, hands it to the
+ * runtime over the service binding, and forgets it inside the same call. What the caller gets is
+ * the fact that it happened, so a screen can say so — `applicationId` names the principal whose key
+ * was replaced, which is a name and not a credential.
+ */
+export declare const AgentKeyRotated: z.ZodObject<{
+    nodeId: z.ZodString;
+    applicationId: z.ZodString;
+    rotatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type AgentKeyRotated = z.infer<typeof AgentKeyRotated>;
+export declare const AgentList: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        parentId: z.ZodNullable<z.ZodString>;
+        kind: z.ZodEnum<{
+            folder: "folder";
+            document: "document";
+            attachment: "attachment";
+            table: "table";
+            agent: "agent";
+        }>;
+        title: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        ownerId: z.ZodString;
+        currentVersionId: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+        archivedAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type AgentList = z.infer<typeof AgentList>;
+export declare const NodeLinkRelation: z.ZodEnum<{
     references: "references";
     related: "related";
     depends_on: "depends_on";
     implements: "implements";
 }>;
-export type KnowledgeLinkRelation = z.infer<typeof KnowledgeLinkRelation>;
-export declare const KnowledgeLinkOrigin: z.ZodEnum<{
+export type NodeLinkRelation = z.infer<typeof NodeLinkRelation>;
+export declare const NodeLinkOrigin: z.ZodEnum<{
     text: "text";
     manual: "manual";
 }>;
-export type KnowledgeLinkOrigin = z.infer<typeof KnowledgeLinkOrigin>;
-export declare const KnowledgeLink: z.ZodObject<{
+export type NodeLinkOrigin = z.infer<typeof NodeLinkOrigin>;
+export declare const NodeLink: z.ZodObject<{
     id: z.ZodString;
     sourceNodeId: z.ZodString;
     targetNodeId: z.ZodString;
@@ -333,8 +930,8 @@ export declare const KnowledgeLink: z.ZodObject<{
     createdBy: z.ZodString;
     createdAt: z.ZodISODateTime;
 }, z.core.$strict>;
-export type KnowledgeLink = z.infer<typeof KnowledgeLink>;
-export declare const KnowledgeLinkList: z.ZodObject<{
+export type NodeLink = z.infer<typeof NodeLink>;
+export declare const NodeLinkList: z.ZodObject<{
     items: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         sourceNodeId: z.ZodString;
@@ -354,29 +951,29 @@ export declare const KnowledgeLinkList: z.ZodObject<{
         createdAt: z.ZodISODateTime;
     }, z.core.$strict>>;
 }, z.core.$strict>;
-export type KnowledgeLinkList = z.infer<typeof KnowledgeLinkList>;
+export type NodeLinkList = z.infer<typeof NodeLinkList>;
 export declare const DocumentLinkInlineType = "documentLink";
-export declare const ResolveKnowledgeLinksInput: z.ZodObject<{
+export declare const ResolveNodeLinksInput: z.ZodObject<{
     nodeIds: z.ZodArray<z.ZodString>;
 }, z.core.$strict>;
-export type ResolveKnowledgeLinksInput = z.infer<typeof ResolveKnowledgeLinksInput>;
-export declare const ResolvedKnowledgeLink: z.ZodObject<{
+export type ResolveNodeLinksInput = z.infer<typeof ResolveNodeLinksInput>;
+export declare const ResolvedNodeLink: z.ZodObject<{
     nodeId: z.ZodString;
     title: z.ZodString;
 }, z.core.$strict>;
-export type ResolvedKnowledgeLink = z.infer<typeof ResolvedKnowledgeLink>;
-export declare const ResolveKnowledgeLinksResult: z.ZodObject<{
+export type ResolvedNodeLink = z.infer<typeof ResolvedNodeLink>;
+export declare const ResolveNodeLinksResult: z.ZodObject<{
     items: z.ZodArray<z.ZodObject<{
         nodeId: z.ZodString;
         title: z.ZodString;
     }, z.core.$strict>>;
 }, z.core.$strict>;
-export type ResolveKnowledgeLinksResult = z.infer<typeof ResolveKnowledgeLinksResult>;
-export declare const KnowledgeGraphInput: z.ZodObject<{
+export type ResolveNodeLinksResult = z.infer<typeof ResolveNodeLinksResult>;
+export declare const NodeGraphInput: z.ZodObject<{
     limit: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strict>;
-export type KnowledgeGraphInput = z.infer<typeof KnowledgeGraphInput>;
-export declare const KnowledgeGraph: z.ZodObject<{
+export type NodeGraphInput = z.infer<typeof NodeGraphInput>;
+export declare const NodeGraph: z.ZodObject<{
     nodes: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         parentId: z.ZodNullable<z.ZodString>;
@@ -385,6 +982,7 @@ export declare const KnowledgeGraph: z.ZodObject<{
             document: "document";
             attachment: "attachment";
             table: "table";
+            agent: "agent";
         }>;
         title: z.ZodString;
         description: z.ZodNullable<z.ZodString>;
@@ -413,7 +1011,7 @@ export declare const KnowledgeGraph: z.ZodObject<{
         createdAt: z.ZodISODateTime;
     }, z.core.$strict>>;
 }, z.core.$strict>;
-export type KnowledgeGraph = z.infer<typeof KnowledgeGraph>;
+export type NodeGraph = z.infer<typeof NodeGraph>;
 export declare const BlockNoteMediaType = "application/vnd.anchrd.intel.blocknote+json";
 export declare const BlockNoteDocument: z.ZodObject<{
     format: z.ZodLiteral<"blocknote">;
@@ -445,7 +1043,7 @@ export declare const ResourceGrant: z.ZodObject<{
     createdAt: z.ZodISODateTime;
 }, z.core.$strict>;
 export type ResourceGrant = z.infer<typeof ResourceGrant>;
-export declare const ShareKnowledgeInput: z.ZodObject<{
+export declare const ShareInput: z.ZodObject<{
     resourceId: z.ZodString;
     principal: z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<"user">;
@@ -465,19 +1063,19 @@ export declare const ShareKnowledgeInput: z.ZodObject<{
     expiresAt: z.ZodDefault<z.ZodNullable<z.ZodISODateTime>>;
     idempotencyKey: z.ZodString;
 }, z.core.$strict>;
-export type ShareKnowledgeInput = z.infer<typeof ShareKnowledgeInput>;
-export declare const RevokeKnowledgeGrantInput: z.ZodObject<{
+export type ShareInput = z.infer<typeof ShareInput>;
+export declare const RevokeGrantInput: z.ZodObject<{
     resourceId: z.ZodString;
     grantId: z.ZodString;
     idempotencyKey: z.ZodString;
 }, z.core.$strict>;
-export type RevokeKnowledgeGrantInput = z.infer<typeof RevokeKnowledgeGrantInput>;
-export declare const UnreadableKnowledge: z.ZodObject<{
+export type RevokeGrantInput = z.infer<typeof RevokeGrantInput>;
+export declare const UnreadableNodes: z.ZodObject<{
     titles: z.ZodArray<z.ZodString>;
     hidden: z.ZodNumber;
 }, z.core.$strict>;
-export type UnreadableKnowledge = z.infer<typeof UnreadableKnowledge>;
-export declare const ShareKnowledgeResult: z.ZodObject<{
+export type UnreadableNodes = z.infer<typeof UnreadableNodes>;
+export declare const ShareResult: z.ZodObject<{
     grant: z.ZodObject<{
         id: z.ZodString;
         resourceId: z.ZodString;
@@ -505,7 +1103,7 @@ export declare const ShareKnowledgeResult: z.ZodObject<{
         hidden: z.ZodNumber;
     }, z.core.$strict>;
 }, z.core.$strict>;
-export type ShareKnowledgeResult = z.infer<typeof ShareKnowledgeResult>;
+export type ShareResult = z.infer<typeof ShareResult>;
 export declare const ResourceGrantList: z.ZodObject<{
     resourceId: z.ZodString;
     applicableVerbs: z.ZodArray<z.ZodEnum<{
@@ -538,12 +1136,13 @@ export declare const ResourceGrantList: z.ZodObject<{
     }, z.core.$strict>>;
 }, z.core.$strict>;
 export type ResourceGrantList = z.infer<typeof ResourceGrantList>;
-export declare const SearchKnowledgeInput: z.ZodObject<{
+export declare const SearchInput: z.ZodObject<{
     query: z.ZodString;
     limit: z.ZodDefault<z.ZodNumber>;
+    scopeId: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
-export type SearchKnowledgeInput = z.infer<typeof SearchKnowledgeInput>;
-export declare const KnowledgeCitation: z.ZodObject<{
+export type SearchInput = z.infer<typeof SearchInput>;
+export declare const NodeCitation: z.ZodObject<{
     nodeId: z.ZodString;
     versionId: z.ZodString;
     title: z.ZodString;
@@ -557,8 +1156,8 @@ export declare const KnowledgeCitation: z.ZodObject<{
         hybrid: "hybrid";
     }>;
 }, z.core.$strict>;
-export type KnowledgeCitation = z.infer<typeof KnowledgeCitation>;
-export declare const SearchKnowledgeResult: z.ZodObject<{
+export type NodeCitation = z.infer<typeof NodeCitation>;
+export declare const SearchResult: z.ZodObject<{
     items: z.ZodArray<z.ZodObject<{
         nodeId: z.ZodString;
         versionId: z.ZodString;
@@ -574,11 +1173,11 @@ export declare const SearchKnowledgeResult: z.ZodObject<{
         }>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
-export type SearchKnowledgeResult = z.infer<typeof SearchKnowledgeResult>;
-export declare const ReindexKnowledgeResult: z.ZodObject<{
+export type SearchResult = z.infer<typeof SearchResult>;
+export declare const ReindexResult: z.ZodObject<{
     queued: z.ZodNumber;
 }, z.core.$strict>;
-export type ReindexKnowledgeResult = z.infer<typeof ReindexKnowledgeResult>;
+export type ReindexResult = z.infer<typeof ReindexResult>;
 export declare const RevokeGrantResult: z.ZodObject<{
     revoked: z.ZodBoolean;
 }, z.core.$strict>;
@@ -628,6 +1227,53 @@ export declare const ToolCatalog: z.ZodObject<{
     }, z.core.$strict>>;
 }, z.core.$strict>;
 export type ToolCatalog = z.infer<typeof ToolCatalog>;
+/**
+ * One MCP server the asking user reaches right now, as the portal itself names it (D30).
+ *
+ * ⚠️ `toolCount` is a fact about this moment and this user, not a size. It exists so a picker can
+ * say "9 tools" instead of showing a handle alone, and it must never be read as what an agent will
+ * get: the delegated run asks the portal again, with the delegator's token.
+ */
+export declare const ToolServer: z.ZodObject<{
+    handle: z.ZodString;
+    name: z.ZodString;
+    toolCount: z.ZodNumber;
+}, z.core.$strict>;
+export type ToolServer = z.infer<typeof ToolServer>;
+export declare const ToolServerCatalog: z.ZodObject<{
+    portalConnected: z.ZodBoolean;
+    items: z.ZodArray<z.ZodObject<{
+        handle: z.ZodString;
+        name: z.ZodString;
+        toolCount: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ToolServerCatalog = z.infer<typeof ToolServerCatalog>;
+/**
+ * Which of the named servers a tool belongs to, or `null` for none of them.
+ *
+ * ⚠️ THE TRAP: a tool name does not say where its server name ends.
+ *
+ * The portal writes `<server>_<tool>`, and both halves may contain underscores — `intel_flow_get`
+ * reads equally well as server `intel` with tool `flow_get` and as a server called `intel_flow`
+ * with tool `get`. Splitting on the first underscore is therefore a guess that is wrong the day
+ * somebody adds a server whose name contains one, and on the API side being wrong means an agent
+ * delegated server A quietly reaching server B.
+ *
+ * So the prefix is never split. It is only ever MATCHED against handles the portal itself named,
+ * and the longest match wins: with `intel` and `intel_flow` both declared, `intel_flow_get` belongs
+ * to `intel_flow`, which is the only reading in which both declarations stay true.
+ *
+ * ⚠️ This lives in the contract because HOW A NAME IS READ is a property of the wire, and both
+ * surfaces read the same wire: `packages/api` cuts a delegation with it, `packages/ui` groups the
+ * tools screen with it (#212). A second implementation in the browser would be the third answer to
+ * one question — the underscore rule has already been answered differently in two places once
+ * (#106, #107), and the copies disagreed. What deliberately stays OUT of here is everything about
+ * reach: which handles are declared, which are enabled, which may be delegated and which one owns
+ * the portal's own management tools are decisions with consequences, and they belong to
+ * `packages/api/src/tools/tool-servers`. This function only reads a name.
+ */
+export declare function serverOf(toolName: string, handles: Iterable<string>): string | null;
 export declare const TestToolInput: z.ZodObject<{
     name: z.ZodString;
     arguments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -1263,6 +1909,32 @@ export declare const FlowDocument: z.ZodObject<{
     }, z.core.$strict>>;
 }, z.core.$strict>;
 export type FlowDocument = z.infer<typeof FlowDocument>;
+export declare const FlowVersionSummary: z.ZodObject<{
+    id: z.ZodString;
+    flowId: z.ZodString;
+    sequence: z.ZodNumber;
+    createdBy: z.ZodString;
+    createdAt: z.ZodISODateTime;
+    published: z.ZodBoolean;
+}, z.core.$strict>;
+export type FlowVersionSummary = z.infer<typeof FlowVersionSummary>;
+export declare const FlowVersionList: z.ZodObject<{
+    flowId: z.ZodString;
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        flowId: z.ZodString;
+        sequence: z.ZodNumber;
+        createdBy: z.ZodString;
+        createdAt: z.ZodISODateTime;
+        published: z.ZodBoolean;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type FlowVersionList = z.infer<typeof FlowVersionList>;
+export declare const GetFlowVersionInput: z.ZodObject<{
+    flowId: z.ZodString;
+    versionId: z.ZodString;
+}, z.core.$strict>;
+export type GetFlowVersionInput = z.infer<typeof GetFlowVersionInput>;
 export declare const FlowList: z.ZodObject<{
     items: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
@@ -1279,19 +1951,19 @@ export declare const FlowList: z.ZodObject<{
     withCalls: z.ZodDefault<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;
 export type FlowList = z.infer<typeof FlowList>;
-export declare const FlowKnowledgeReference: z.ZodObject<{
+export declare const ReferencedNode: z.ZodObject<{
     id: z.ZodString;
     title: z.ZodString;
 }, z.core.$strict>;
-export type FlowKnowledgeReference = z.infer<typeof FlowKnowledgeReference>;
+export type ReferencedNode = z.infer<typeof ReferencedNode>;
 export declare const FlowRequirements: z.ZodObject<{
     flowId: z.ZodString;
     versionId: z.ZodNullable<z.ZodString>;
-    knowledge: z.ZodArray<z.ZodObject<{
+    nodes: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         title: z.ZodString;
     }, z.core.$strict>>;
-    hiddenKnowledge: z.ZodNumber;
+    hiddenNodes: z.ZodNumber;
     tools: z.ZodArray<z.ZodString>;
 }, z.core.$strict>;
 export type FlowRequirements = z.infer<typeof FlowRequirements>;
@@ -1483,6 +2155,11 @@ export declare const PublishFlowInput: z.ZodObject<{
     idempotencyKey: z.ZodString;
 }, z.core.$strict>;
 export type PublishFlowInput = z.infer<typeof PublishFlowInput>;
+export declare const UnpublishFlowInput: z.ZodObject<{
+    flowId: z.ZodString;
+    idempotencyKey: z.ZodString;
+}, z.core.$strict>;
+export type UnpublishFlowInput = z.infer<typeof UnpublishFlowInput>;
 export declare const PreviewFlowPublishInput: z.ZodObject<{
     flowId: z.ZodString;
     versionId: z.ZodString;
@@ -1529,6 +2206,7 @@ export declare const RelationNodeKind: z.ZodEnum<{
     document: "document";
     attachment: "attachment";
     table: "table";
+    agent: "agent";
     flow: "flow";
 }>;
 export type RelationNodeKind = z.infer<typeof RelationNodeKind>;
@@ -1539,6 +2217,7 @@ export declare const RelationNode: z.ZodObject<{
         document: "document";
         attachment: "attachment";
         table: "table";
+        agent: "agent";
         flow: "flow";
     }>;
     title: z.ZodString;
@@ -1589,6 +2268,7 @@ export declare const RelationGraph: z.ZodObject<{
             document: "document";
             attachment: "attachment";
             table: "table";
+            agent: "agent";
             flow: "flow";
         }>;
         title: z.ZodString;
@@ -1812,6 +2492,11 @@ export declare const GetFlowRunInput: z.ZodObject<{
     runId: z.ZodString;
 }, z.core.$strict>;
 export type GetFlowRunInput = z.infer<typeof GetFlowRunInput>;
+export declare const CancelFlowRunInput: z.ZodObject<{
+    runId: z.ZodString;
+    idempotencyKey: z.ZodString;
+}, z.core.$strict>;
+export type CancelFlowRunInput = z.infer<typeof CancelFlowRunInput>;
 export declare const CompleteFlowRunStepInput: z.ZodObject<{
     runId: z.ZodString;
     nodeId: z.ZodString;
@@ -1947,3 +2632,70 @@ export declare const FlowRunHistory: z.ZodObject<{
     }, z.core.$strict>>;
 }, z.core.$strict>;
 export type FlowRunHistory = z.infer<typeof FlowRunHistory>;
+export declare const BundleManifestFilename = "manifest.json";
+export declare const BundleEntryKind: z.ZodEnum<{
+    folder: "folder";
+    document: "document";
+    attachment: "attachment";
+    table: "table";
+    agent: "agent";
+    flow: "flow";
+}>;
+export type BundleEntryKind = z.infer<typeof BundleEntryKind>;
+export declare const BundleManifestEntry: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        folder: "folder";
+        document: "document";
+        attachment: "attachment";
+        table: "table";
+        agent: "agent";
+        flow: "flow";
+    }>;
+    title: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    mediaType: z.ZodNullable<z.ZodString>;
+    path: z.ZodString;
+}, z.core.$strict>;
+export type BundleManifestEntry = z.infer<typeof BundleManifestEntry>;
+export declare const BundleExclusion: z.ZodEnum<{
+    "version-history": "version-history";
+    grants: "grants";
+    "flow-runs": "flow-runs";
+    "archived-nodes": "archived-nodes";
+}>;
+export type BundleExclusion = z.infer<typeof BundleExclusion>;
+export declare const BundleManifest: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    exportedAt: z.ZodISODateTime;
+    rootId: z.ZodNullable<z.ZodString>;
+    entries: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            folder: "folder";
+            document: "document";
+            attachment: "attachment";
+            table: "table";
+            agent: "agent";
+            flow: "flow";
+        }>;
+        title: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        mediaType: z.ZodNullable<z.ZodString>;
+        path: z.ZodString;
+    }, z.core.$strict>>;
+    excluded: z.ZodArray<z.ZodEnum<{
+        "version-history": "version-history";
+        grants: "grants";
+        "flow-runs": "flow-runs";
+        "archived-nodes": "archived-nodes";
+    }>>;
+}, z.core.$strict>;
+export type BundleManifest = z.infer<typeof BundleManifest>;
+export declare const BundleImportResult: z.ZodObject<{
+    nodes: z.ZodNumber;
+    flows: z.ZodNumber;
+    rootNodeIds: z.ZodArray<z.ZodString>;
+    replayed: z.ZodBoolean;
+}, z.core.$strict>;
+export type BundleImportResult = z.infer<typeof BundleImportResult>;