@anchrd/intel 0.59.0

package/dist/contract/node.d.ts

@@ -0,0 +1,551 @@
+import { z } from "zod";
+export declare const NodeKind: z.ZodEnum<{
+    folder: "folder";
+    document: "document";
+    attachment: "attachment";
+    table: "table";
+    board: "board";
+    task: "task";
+}>;
+export type NodeKind = z.infer<typeof NodeKind>;
+export declare const Node: z.ZodObject<{
+    id: z.ZodString;
+    parentId: z.ZodNullable<z.ZodString>;
+    kind: z.ZodEnum<{
+        folder: "folder";
+        document: "document";
+        attachment: "attachment";
+        table: "table";
+        board: "board";
+        task: "task";
+    }>;
+    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>;
+    promptName: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+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;
+    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>;
+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 ListNodesInput = z.infer<typeof ListNodesInput>;
+export declare const GetNodeInput: z.ZodObject<{
+    nodeId: z.ZodString;
+}, z.core.$strict>;
+export type GetNodeInput = z.infer<typeof GetNodeInput>;
+/**
+ * An attachment, with the option of its bytes.
+ *
+ * ⚠️ One tool rather than a second one beside `node_attachment_get`, because the grammar in
+ * `packages/intel/CLAUDE.md` gives one verb one meaning: `get` reads one, and metadata and bytes are
+ * two halves of the same one. It mirrors HTTP, where `GET /nodes/:nodeId/attachment` and its
+ * `/meta` sibling have always been the same tool.
+ *
+ * ⚠️ The default is `false` on purpose. The bytes travel as base64 in the answer, so asking for
+ * them by accident would put a whole file into a model's context; a caller that wants the file says
+ * so. `SaveAttachmentInput` has carried bytes the other way since the beginning — this closes the
+ * asymmetry that let a model upload a PDF it could never read back (#773).
+ */
+export declare const GetAttachmentInput: z.ZodObject<{
+    nodeId: z.ZodString;
+    includeContent: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export type GetAttachmentInput = z.infer<typeof GetAttachmentInput>;
+export declare const GetNodeVersionInput: z.ZodObject<{
+    nodeId: z.ZodString;
+    versionId: z.ZodString;
+}, z.core.$strict>;
+export type GetNodeVersionInput = z.infer<typeof GetNodeVersionInput>;
+export declare const CreateNodeInput: z.ZodObject<{
+    parentId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    kind: z.ZodEnum<{
+        folder: "folder";
+        document: "document";
+        attachment: "attachment";
+        table: "table";
+        board: "board";
+        task: "task";
+    }>;
+    title: z.ZodString;
+    description: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    idempotencyKey: z.ZodString;
+}, z.core.$strict>;
+export type CreateNodeInput = z.infer<typeof CreateNodeInput>;
+export declare const SaveNodeVersionInput: z.ZodObject<{
+    nodeId: z.ZodString;
+    baseVersionId: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
+    content: z.ZodString;
+    mediaType: z.ZodDefault<z.ZodString>;
+    idempotencyKey: z.ZodString;
+}, z.core.$strict>;
+export type SaveNodeVersionInput = z.infer<typeof SaveNodeVersionInput>;
+export declare const SaveAttachmentInput: z.ZodObject<{
+    nodeId: z.ZodString;
+    baseVersionId: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
+    contentBase64: z.ZodString;
+    mediaType: z.ZodString;
+    idempotencyKey: z.ZodString;
+}, z.core.$strict>;
+export type SaveAttachmentInput = z.infer<typeof SaveAttachmentInput>;
+/**
+ * How many bytes an attachment may carry through the streaming door (#821).
+ *
+ * ⚠️ **This is our number, not the platform's.** A Worker refuses a request body over 100 MB on the
+ * Free and Pro plans (200 MB on Business, 500 MB on Enterprise by default), and the isolate that
+ * receives it has 128 MB of memory for everything it does at once. 50 MB is the presentation and
+ * PDF size this was raised for, and it leaves the hard ceiling a factor of two away — which is what
+ * makes a file over the limit a sentence the reader gets rather than a connection that drops.
+ *
+ * ⚠️ It is not the limit of the base64 door beside it. That one stays where it was, because there
+ * the file exists twice in memory before a single byte is stored; `contentBase64` says so.
+ */
+/**
+ * The name a document takes to become the TEXT OF ITS FOLDER (#824).
+ *
+ * ⚠️ It is a convention that already existed: nearly every folder in this installation holds a
+ * document called `index` describing what is in it, and every person had to be told so. A surface
+ * that serves the convention makes the telling unnecessary — and nothing about the model changes:
+ * the document stays a document, in full text and in the vectors, with its versions, without a
+ * length limit and with version-pinned citations.
+ *
+ * ⚠️ **The comparison is case-insensitive, and `index.md` counts too.** The three spellings the
+ * decision names — `index`, `Index`, `index.md` — are all covered by it, and so are the ones nobody
+ * thought of. A list of exact spellings would make `INDEX` a different document from `index` for no
+ * reason a reader could guess.
+ *
+ * ⚠️ It lives in the contract because three surfaces need the same answer: the browser hides the
+ * row, the MCP tool description explains the name to a model, and neither may disagree with the
+ * other about what counts.
+ */
+export declare function isFolderIndexTitle(title: string): boolean;
+export declare const MaxAttachmentBytes = 50000000;
+/**
+ * The largest attachment whose CONTENTS are read and converted for the index (#821).
+ *
+ * ⚠️ A bigger file is stored, opened and downloaded exactly like any other; what it does not get is
+ * a search over its text. The indexing pass reads an attachment into memory whole and hands it to
+ * the converter as a blob beside it, so at 50 MB it would meet the isolate's 128 MB — and an upload
+ * that succeeds and then dies while being indexed is the worst of both: the file is filed and
+ * cannot be found.
+ *
+ * ⚠️ The number is 15 MB because that is what the old upload limit was. Every file that could be
+ * uploaded before this ticket therefore behaves exactly as it did; only the sizes that were
+ * impossible until now fall into the new case. Raising it is a measurement, not a decision to take
+ * in passing.
+ */
+export declare const MaxIndexedAttachmentBytes = 15000000;
+/**
+ * The streaming door for one attachment: everything ABOUT the bytes, while the bytes are the
+ * request body (#821).
+ *
+ * ⚠️ It has no MCP twin, and that is the one place where "every capability has an MCP equivalent"
+ * is answered by the door beside it instead: MCP carries JSON, so a tool cannot hand over a body.
+ * `SaveAttachmentInput` IS the MCP form of this capability, and the size is what separates them.
+ *
+ * ⚠️ `mediaType` travels as the request's own `content-type`, and `size` as its `content-length`.
+ * Both are read from the headers rather than invented here, because the body they describe is the
+ * body being sent; a second, hand-written statement about the same bytes is a second truth.
+ */
+export declare const SaveAttachmentBytesInput: z.ZodObject<{
+    nodeId: z.ZodString;
+    baseVersionId: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
+    mediaType: z.ZodString;
+    size: z.ZodNumber;
+    idempotencyKey: z.ZodString;
+}, z.core.$strict>;
+export type SaveAttachmentBytesInput = z.infer<typeof SaveAttachmentBytesInput>;
+export declare const UpdateNodeInput: z.ZodObject<{
+    nodeId: z.ZodString;
+    baseUpdatedAt: z.ZodISODateTime;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    parentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    promptName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    idempotencyKey: z.ZodString;
+}, z.core.$strict>;
+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 ArchiveNodeInput = z.infer<typeof ArchiveNodeInput>;
+export declare const PurgeNodeInput: z.ZodObject<{
+    nodeId: z.ZodString;
+    idempotencyKey: z.ZodString;
+}, z.core.$strict>;
+export type PurgeNodeInput = z.infer<typeof PurgeNodeInput>;
+export declare const PurgeNodePreviewInput: z.ZodObject<{
+    nodeId: z.ZodString;
+}, z.core.$strict>;
+export type PurgeNodePreviewInput = z.infer<typeof PurgeNodePreviewInput>;
+/**
+ * ⚠️ **A count is not an answer before a deletion that cannot be undone** (D71, #733). `totalItems`
+ * alone reads as "82 items" for a folder holding somebody's whole memory, and `destructive.md` asks
+ * for the number to be named BEFORE the confirmation — one step more precise is the difference
+ * between a number and something a person can decide on.
+ *
+ * `items` is capped, and the cap is visible rather than silent: `totalItems` keeps counting past it,
+ * so a caller can always say "and 40 more". A list of ten thousand rows would be an answer nobody
+ * reads and a response nobody can render.
+ */
+export declare const PurgeNodePreview: z.ZodObject<{
+    inboundLinks: z.ZodNumber;
+    totalItems: z.ZodNumber;
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodUnion<readonly [z.ZodEnum<{
+            folder: "folder";
+            document: "document";
+            attachment: "attachment";
+            table: "table";
+            board: "board";
+            task: "task";
+        }>, z.ZodLiteral<"flow">]>;
+        title: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type PurgeNodePreview = z.infer<typeof PurgeNodePreview>;
+export declare const PurgeNodeResult: z.ZodObject<{
+    purged: z.ZodLiteral<true>;
+    title: z.ZodString;
+}, z.core.$strict>;
+export type PurgeNodeResult = z.infer<typeof PurgeNodeResult>;
+export declare const NodeList: 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";
+            board: "board";
+            task: "task";
+        }>;
+        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>;
+        promptName: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    withChildren: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type NodeList = z.infer<typeof NodeList>;
+export declare const NodeVersionList: z.ZodObject<{
+    items: z.ZodArray<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>>;
+}, z.core.$strict>;
+export type NodeVersionList = z.infer<typeof NodeVersionList>;
+export declare const NodeDocument: z.ZodObject<{
+    node: z.ZodObject<{
+        id: z.ZodString;
+        parentId: z.ZodNullable<z.ZodString>;
+        kind: z.ZodEnum<{
+            folder: "folder";
+            document: "document";
+            attachment: "attachment";
+            table: "table";
+            board: "board";
+            task: "task";
+        }>;
+        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>;
+        promptName: z.ZodNullable<z.ZodString>;
+    }, 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>>;
+    content: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type NodeDocument = z.infer<typeof NodeDocument>;
+export declare const NodeAttachment: z.ZodObject<{
+    node: z.ZodObject<{
+        id: z.ZodString;
+        parentId: z.ZodNullable<z.ZodString>;
+        kind: z.ZodEnum<{
+            folder: "folder";
+            document: "document";
+            attachment: "attachment";
+            table: "table";
+            board: "board";
+            task: "task";
+        }>;
+        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>;
+        promptName: z.ZodNullable<z.ZodString>;
+    }, 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>;
+    resourceUri: z.ZodString;
+}, z.core.$strict>;
+export type NodeAttachment = z.infer<typeof NodeAttachment>;
+export declare const NodeTable: z.ZodObject<{
+    node: z.ZodObject<{
+        id: z.ZodString;
+        parentId: z.ZodNullable<z.ZodString>;
+        kind: z.ZodEnum<{
+            folder: "folder";
+            document: "document";
+            attachment: "attachment";
+            table: "table";
+            board: "board";
+            task: "task";
+        }>;
+        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>;
+        promptName: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    columns: z.ZodArray<z.ZodString>;
+    rows: z.ZodArray<z.ZodArray<z.ZodString>>;
+    versionId: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type NodeTable = z.infer<typeof NodeTable>;
+export declare const NodeLinkRelation: z.ZodEnum<{
+    references: "references";
+    related: "related";
+    depends_on: "depends_on";
+    implements: "implements";
+}>;
+export type NodeLinkRelation = z.infer<typeof NodeLinkRelation>;
+export declare const NodeLinkOrigin: z.ZodEnum<{
+    text: "text";
+    manual: "manual";
+}>;
+export type NodeLinkOrigin = z.infer<typeof NodeLinkOrigin>;
+export declare const NodeLink: z.ZodObject<{
+    id: z.ZodString;
+    sourceNodeId: z.ZodString;
+    targetNodeId: z.ZodString;
+    relation: z.ZodEnum<{
+        references: "references";
+        related: "related";
+        depends_on: "depends_on";
+        implements: "implements";
+    }>;
+    origin: z.ZodEnum<{
+        text: "text";
+        manual: "manual";
+    }>;
+    label: z.ZodNullable<z.ZodString>;
+    createdBy: z.ZodString;
+    createdAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type NodeLink = z.infer<typeof NodeLink>;
+export declare const NodeLinkList: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        sourceNodeId: z.ZodString;
+        targetNodeId: z.ZodString;
+        relation: z.ZodEnum<{
+            references: "references";
+            related: "related";
+            depends_on: "depends_on";
+            implements: "implements";
+        }>;
+        origin: z.ZodEnum<{
+            text: "text";
+            manual: "manual";
+        }>;
+        label: z.ZodNullable<z.ZodString>;
+        createdBy: z.ZodString;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type NodeLinkList = z.infer<typeof NodeLinkList>;
+export declare const DocumentLinkInlineType = "documentLink";
+export declare const ResolveNodeLinksInput: z.ZodObject<{
+    nodeIds: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type ResolveNodeLinksInput = z.infer<typeof ResolveNodeLinksInput>;
+export declare const ResolvedNodeLink: z.ZodObject<{
+    nodeId: z.ZodString;
+    title: z.ZodString;
+}, z.core.$strict>;
+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 ResolveNodeLinksResult = z.infer<typeof ResolveNodeLinksResult>;
+export declare const NodeGraphInput: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+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>;
+        kind: z.ZodEnum<{
+            folder: "folder";
+            document: "document";
+            attachment: "attachment";
+            table: "table";
+            board: "board";
+            task: "task";
+        }>;
+        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>;
+        promptName: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    links: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        sourceNodeId: z.ZodString;
+        targetNodeId: z.ZodString;
+        relation: z.ZodEnum<{
+            references: "references";
+            related: "related";
+            depends_on: "depends_on";
+            implements: "implements";
+        }>;
+        origin: z.ZodEnum<{
+            text: "text";
+            manual: "manual";
+        }>;
+        label: z.ZodNullable<z.ZodString>;
+        createdBy: z.ZodString;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+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">;
+    schemaVersion: z.ZodLiteral<1>;
+    blocks: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    markdown: z.ZodString;
+}, z.core.$strict>;
+export type BlockNoteDocument = z.infer<typeof BlockNoteDocument>;
+export declare const SearchInput: z.ZodObject<{
+    query: z.ZodString;
+    limit: z.ZodDefault<z.ZodNumber>;
+    scopeId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type SearchInput = z.infer<typeof SearchInput>;
+export declare const NodeCitation: z.ZodObject<{
+    nodeId: z.ZodString;
+    versionId: z.ZodString;
+    title: z.ZodString;
+    passage: z.ZodString;
+    source: z.ZodString;
+    freshness: z.ZodISODateTime;
+    score: z.ZodNumber;
+    match: z.ZodEnum<{
+        lexical: "lexical";
+        semantic: "semantic";
+        hybrid: "hybrid";
+    }>;
+}, z.core.$strict>;
+export type NodeCitation = z.infer<typeof NodeCitation>;
+export declare const SearchResult: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        nodeId: z.ZodString;
+        versionId: z.ZodString;
+        title: z.ZodString;
+        passage: z.ZodString;
+        source: z.ZodString;
+        freshness: z.ZodISODateTime;
+        score: z.ZodNumber;
+        match: z.ZodEnum<{
+            lexical: "lexical";
+            semantic: "semantic";
+            hybrid: "hybrid";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type SearchResult = z.infer<typeof SearchResult>;
+export declare const ReindexResult: z.ZodObject<{
+    queued: z.ZodNumber;
+}, z.core.$strict>;
+export type ReindexResult = z.infer<typeof ReindexResult>;