@anchrd/colab-sdk 0.0.0-stage → 0.1.1

package/dist/invitations/invitations.js

@@ -0,0 +1,58 @@
+import { z } from "zod";
+import { idSchema } from "../ids/ids.js";
+import { Name } from "../profile/profile.js";
+import { RoleId } from "../roles/roles.js";
+// Invitations (Einstellungen › Nutzer, #25): the inputs of the `access_invitation_*` tools, the
+// doors under `/auth/invitation` the invited person uses, and the answers. An invitation lives seven
+// days, carries one valid token at a time, and its roles become the person's on acceptance.
+export const InvitationId = idSchema("invitation");
+// A role as the list shows it: its id for the next call, its name for the chip.
+export const RoleChip = z.strictObject({ roleId: RoleId, name: z.string() });
+// What `send` of the package `mail` answered: a failed delivery is an answer, not an exception.
+export const Delivery = z.strictObject({ accepted: z.boolean(), cause: z.string().optional() });
+// The roles a new account gets. Without the field, `mitglied` (E9); an empty list invites to no role.
+const RoleIds = z.array(RoleId).max(50);
+export const InvitationCreateInput = z.strictObject({
+    email: z.email(),
+    roleIds: RoleIds.optional(),
+});
+export const InvitationResendInput = z.strictObject({ invitationId: InvitationId });
+export const InvitationRevokeInput = z.strictObject({ invitationId: InvitationId });
+// `invited` while the link works, `expired` once its seven days passed (a resend restarts them),
+// `revoked` after a withdrawal and `accepted` once the account exists.
+export const InvitationStatus = z.enum(["invited", "expired", "revoked", "accepted"]);
+export const Invitation = z.strictObject({
+    invitationId: InvitationId,
+    email: z.string(),
+    roles: z.array(RoleChip),
+    status: InvitationStatus,
+    invitedBy: idSchema("user").nullable(),
+    expiresAt: z.iso.datetime(),
+    createdAt: z.iso.datetime(),
+});
+// The answer of create and resend: the invitation and what the mail transport said. The token itself
+// never: it leaves Colab once, in the mail.
+export const InvitationSent = Invitation.extend({ delivery: Delivery });
+// `GET /auth/invitation?token=…`, read by the page the invitation link opens (auth-invite.png).
+export const InvitationLookupQuery = z.strictObject({ token: z.string().min(1).max(200) });
+export const InvitationLookup = z.strictObject({
+    email: z.string(),
+    // The display name of whoever invited, or null when that account is gone.
+    inviter: z.string().nullable(),
+    expired: z.boolean(),
+    expiresAt: z.iso.datetime(),
+});
+// `POST /auth/invitation/accept`: the account with name and password. The address and the roles come
+// from the invitation, never from this body.
+export const InvitationAcceptInput = z.strictObject({
+    token: z.string().min(1).max(200),
+    name: Name,
+    password: z.string().min(1),
+});
+// `POST /auth/invitation/social`: the account through Google or Microsoft. Answers like
+// `/auth/sign-in/social`, with the address of the provider to go to.
+export const InvitationSocialInput = z.strictObject({
+    token: z.string().min(1).max(200),
+    provider: z.enum(["google", "microsoft"]),
+    callbackURL: z.string().optional(),
+});

package/dist/links/links.d.ts

@@ -0,0 +1,76 @@
+import { z } from "zod";
+export declare const LinkId: z.ZodTemplateLiteral<`link_${string}`>;
+export type LinkId = z.infer<typeof LinkId>;
+export declare const maxLinkDays = 90;
+export declare const defaultLinkDays = 7;
+export declare const publicLinkPath = "/api/intelligence/public";
+export declare const NodeLinkListInput: z.ZodObject<{
+    nodeId: z.ZodTemplateLiteral<`node_${string}`>;
+    cursor: z.ZodOptional<z.ZodTemplateLiteral<`link_${string}`>>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strict>;
+export type NodeLinkListInput = z.infer<typeof NodeLinkListInput>;
+export declare const NodeLinkCreateInput: z.ZodObject<{
+    nodeId: z.ZodTemplateLiteral<`node_${string}`>;
+    expiresInDays: z.ZodDefault<z.ZodNumber>;
+    idempotencyKey: z.ZodString;
+}, z.core.$strict>;
+export type NodeLinkCreateInput = z.infer<typeof NodeLinkCreateInput>;
+export declare const NodeLinkUpdateInput: z.ZodObject<{
+    nodeId: z.ZodTemplateLiteral<`node_${string}`>;
+    linkId: z.ZodTemplateLiteral<`link_${string}`>;
+    expiresAt: z.ZodISODateTime;
+    baseUpdatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type NodeLinkUpdateInput = z.infer<typeof NodeLinkUpdateInput>;
+export declare const NodeLinkRevokeInput: z.ZodObject<{
+    nodeId: z.ZodTemplateLiteral<`node_${string}`>;
+    linkId: z.ZodTemplateLiteral<`link_${string}`>;
+}, z.core.$strict>;
+export type NodeLinkRevokeInput = z.infer<typeof NodeLinkRevokeInput>;
+export declare const LinkStatus: z.ZodEnum<{
+    expired: "expired";
+    revoked: "revoked";
+    active: "active";
+    inactive: "inactive";
+}>;
+export type LinkStatus = z.infer<typeof LinkStatus>;
+export declare const NodeLink: z.ZodObject<{
+    linkId: z.ZodTemplateLiteral<`link_${string}`>;
+    nodeId: z.ZodTemplateLiteral<`node_${string}`>;
+    url: z.ZodURL;
+    status: z.ZodEnum<{
+        expired: "expired";
+        revoked: "revoked";
+        active: "active";
+        inactive: "inactive";
+    }>;
+    expiresAt: z.ZodISODateTime;
+    revokedAt: z.ZodNullable<z.ZodISODateTime>;
+    createdBy: z.ZodString;
+    createdByName: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type NodeLink = z.infer<typeof NodeLink>;
+export declare const NodeLinkList: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        linkId: z.ZodTemplateLiteral<`link_${string}`>;
+        nodeId: z.ZodTemplateLiteral<`node_${string}`>;
+        url: z.ZodURL;
+        status: z.ZodEnum<{
+            expired: "expired";
+            revoked: "revoked";
+            active: "active";
+            inactive: "inactive";
+        }>;
+        expiresAt: z.ZodISODateTime;
+        revokedAt: z.ZodNullable<z.ZodISODateTime>;
+        createdBy: z.ZodString;
+        createdByName: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodTemplateLiteral<`link_${string}`>>;
+}, z.core.$strict>;
+export type NodeLinkList = z.infer<typeof NodeLinkList>;

package/dist/links/links.js

@@ -0,0 +1,73 @@
+import { z } from "zod";
+import { idSchema } from "../ids/ids.js";
+import { Limit as PageSize } from "../list-input.js";
+import { NodeId } from "../nodes/nodes.js";
+import { IdempotencyKey } from "../primitives/primitives.js";
+// Public links (#49, Funktionen › Freigeben und Versionen, E49, E66): the inputs of
+// `intelligence_node_link_list`, `_create`, `_update` and `_revoke`, and their answers. Reworked
+// from anchrd/intel `src/contract/attachment-link.ts` (f4eccd16, I19): documents too, up to 90 days,
+// for whoever may share the node, and the address in the list.
+//
+// ⚠️ A link is the widest share there is: whoever holds the address reads the current version of
+// the node without signing in. That is why it is narrow in every other way: read only, with an
+// expiry, revocable, and alive only while its creator could still share the node.
+export const LinkId = idSchema("link").describe("The link's id, `link_…`, as intelligence_node_link_list names it.");
+// The longest a link opens a node, counted from its creation, and the default of a new one.
+export const maxLinkDays = 90;
+export const defaultLinkDays = 7;
+// The path the public door answers under; the token follows as the last segment. Under `/api`, so
+// the Worker sees it before the static assets (trap P076).
+export const publicLinkPath = "/api/intelligence/public";
+export const NodeLinkListInput = z.strictObject({
+    nodeId: NodeId.describe("The document or file whose public links to list. Needs the right to share it."),
+    cursor: LinkId.optional().describe("The nextCursor of the previous page, unchanged. Leaving it out starts with the newest link."),
+    limit: PageSize.optional().describe("How many links one page holds, 1 to 100. Leaving it out gives 100."),
+});
+export const NodeLinkCreateInput = z.strictObject({
+    nodeId: NodeId.describe("The document or file to open to everybody holding the address. Needs the right to share it. The link always serves the version that is current when it is opened."),
+    expiresInDays: z
+        .number()
+        .int()
+        .min(1)
+        .max(maxLinkDays, { error: `A public link lasts at most ${maxLinkDays} days.` })
+        .default(defaultLinkDays)
+        .describe(`How many days the link opens the node, 1 to ${maxLinkDays}. Leaving it out gives ${defaultLinkDays}. Ask for no more than the receiving service needs.`),
+    idempotencyKey: IdempotencyKey,
+});
+export const NodeLinkUpdateInput = z.strictObject({
+    nodeId: NodeId.describe("The document or file the link belongs to."),
+    linkId: LinkId,
+    expiresAt: z.iso
+        .datetime()
+        .describe(`The new end of the link, in the future and at most ${maxLinkDays} days after the link was created. Earlier ends it sooner; to end it now, revoke it.`),
+    baseUpdatedAt: z.iso
+        .datetime()
+        .describe("The link's updatedAt as the last list returned it. If someone changed the link in between, the call answers conflict and changes nothing."),
+});
+export const NodeLinkRevokeInput = z.strictObject({
+    nodeId: NodeId.describe("The document or file the link belongs to."),
+    linkId: LinkId.describe("The link to end now. A revoked link stays in the list and never opens again; revoking it twice answers conflict."),
+});
+// What a link is right now: `revoked` wins over `expired`, `expired` over `inactive`. `inactive` is a
+// link the door refuses because its creator could no longer make it: they lost the right to share the
+// node, or `access` locked or archived them. It opens again once that changes (#199).
+export const LinkStatus = z.enum(["active", "expired", "revoked", "inactive"]);
+// One link. `url` is derived from the id every time it is answered and never stored: the table holds
+// only the hash of its token.
+export const NodeLink = z.strictObject({
+    linkId: LinkId,
+    nodeId: NodeId,
+    url: z.url(),
+    status: LinkStatus,
+    expiresAt: z.iso.datetime(),
+    revokedAt: z.iso.datetime().nullable(),
+    // `user_…` of `access`, and the name it has there today; null for an account that is gone.
+    createdBy: z.string(),
+    createdByName: z.string().nullable(),
+    createdAt: z.iso.datetime(),
+    updatedAt: z.iso.datetime(),
+});
+export const NodeLinkList = z.strictObject({
+    items: z.array(NodeLink),
+    nextCursor: LinkId.nullable(),
+});

package/dist/list-input.d.ts

@@ -0,0 +1,3 @@
+import { z } from "zod";
+export declare const Limit: z.ZodCoercedNumber<unknown>;
+export declare const Flag: z.ZodPreprocess<z.ZodBoolean, unknown>;

package/dist/list-input.js

@@ -0,0 +1,11 @@
+import { z } from "zod";
+// The fields of a `list` that are not text. Over REST they arrive in the query string, which carries
+// only text (`?limit=20&archived=true`); over MCP as the JSON value. `mountTools` passes the query
+// on as it came, so the conversion lives here, per field, and a text field holding digits only
+// (`?query=2026`) stays text (#86). The MCP SDK reads the input side of these schemas, so the AI
+// still sees a number and a boolean.
+// The page size of every list.
+export const Limit = z.coerce.number().int().min(1).max(100);
+// A yes or no filter. Only the words `true` and `false`: `z.coerce.boolean()` would read `"false"`
+// as true, like any text that is not empty.
+export const Flag = z.preprocess((value) => (value === "true" ? true : value === "false" ? false : value), z.boolean());

package/dist/machines/machines.d.ts

@@ -0,0 +1,69 @@
+import { z } from "zod";
+export declare const MachineId: z.ZodTemplateLiteral<`user_${string}`>;
+export declare const MachineCreateInput: z.ZodObject<{
+    name: z.ZodString;
+    roleIds: z.ZodOptional<z.ZodArray<z.ZodTemplateLiteral<`role_${string}`>>>;
+}, z.core.$strict>;
+export type MachineCreateInput = z.infer<typeof MachineCreateInput>;
+export declare const MachineUpdateInput: z.ZodObject<{
+    machineId: z.ZodTemplateLiteral<`user_${string}`>;
+    responsibleId: z.ZodTemplateLiteral<`user_${string}`>;
+}, z.core.$strict>;
+export type MachineUpdateInput = z.infer<typeof MachineUpdateInput>;
+export declare const MachineRotateInput: z.ZodObject<{
+    machineId: z.ZodTemplateLiteral<`user_${string}`>;
+}, z.core.$strict>;
+export type MachineRotateInput = z.infer<typeof MachineRotateInput>;
+export declare const MachineArchiveInput: z.ZodObject<{
+    machineId: z.ZodTemplateLiteral<`user_${string}`>;
+}, z.core.$strict>;
+export type MachineArchiveInput = z.infer<typeof MachineArchiveInput>;
+export declare const MachineRestoreInput: z.ZodObject<{
+    machineId: z.ZodTemplateLiteral<`user_${string}`>;
+}, z.core.$strict>;
+export type MachineRestoreInput = z.infer<typeof MachineRestoreInput>;
+export declare const MachinePurgeInput: z.ZodObject<{
+    machineId: z.ZodTemplateLiteral<`user_${string}`>;
+}, z.core.$strict>;
+export type MachinePurgeInput = z.infer<typeof MachinePurgeInput>;
+export declare const MachineKey: z.ZodObject<{
+    machine: z.ZodObject<{
+        userId: z.ZodTemplateLiteral<`user_${string}`>;
+        kind: z.ZodEnum<{
+            machine: "machine";
+            human: "human";
+        }>;
+        name: z.ZodString;
+        email: z.ZodNullable<z.ZodString>;
+        roles: z.ZodArray<z.ZodObject<{
+            roleId: z.ZodTemplateLiteral<`role_${string}`>;
+            name: z.ZodString;
+        }, z.core.$strict>>;
+        status: z.ZodNullable<z.ZodEnum<{
+            archived: "archived";
+            invited: "invited";
+            expired: "expired";
+            disabled: "disabled";
+        }>>;
+        machine: z.ZodNullable<z.ZodObject<{
+            kind: z.ZodEnum<{
+                operator: "operator";
+                external: "external";
+            }>;
+            responsibleId: z.ZodNullable<z.ZodTemplateLiteral<`user_${string}`>>;
+        }, z.core.$strict>>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+    key: z.ZodString;
+    mcpUrl: z.ZodString;
+    tokenUrl: z.ZodString;
+    example: z.ZodString;
+    docs: z.ZodString;
+}, z.core.$strict>;
+export type MachineKey = z.infer<typeof MachineKey>;
+export declare const MachinePurged: z.ZodObject<{
+    machineId: z.ZodTemplateLiteral<`user_${string}`>;
+    name: z.ZodString;
+}, z.core.$strict>;
+export type MachinePurged = z.infer<typeof MachinePurged>;

package/dist/machines/machines.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { RoleId } from "../roles/roles.js";
+import { User, UserId } from "../users/users.js";
+// Machines (Betrieb › Operator und Maschinen, #25, #331): the inputs of the `access_machine_*` tools
+// and their answers. A machine is a row in `users` of kind `machine`, so `machineId` carries its user
+// id (`user_…`); renaming, roles and locking go through the `access_user_*` tools. The tools create
+// an EXTERNAL machine with a key; a Claude-Operator (kind `operator`, no key) comes into being under
+// Einstellungen › Operator, through the package `operator` (E85).
+export const MachineId = UserId;
+export const MachineCreateInput = z.strictObject({
+    name: z.string().trim().min(1).max(64),
+    // Without the field, no role (E84): the machine can do nothing until it gets one.
+    roleIds: z.array(RoleId).max(50).optional(),
+});
+// Hands a machine to another responsible person (E76): the one its disturbances reach.
+export const MachineUpdateInput = z.strictObject({
+    machineId: MachineId,
+    responsibleId: UserId,
+});
+export const MachineRotateInput = z.strictObject({ machineId: MachineId });
+export const MachineArchiveInput = z.strictObject({ machineId: MachineId });
+export const MachineRestoreInput = z.strictObject({ machineId: MachineId });
+export const MachinePurgeInput = z.strictObject({ machineId: MachineId });
+// The answer of create and rotate: the key, shown ONCE (it is stored hashed), and how to connect the
+// machine ("So verbindest du sie"). ⚠️ These two tools are the only ones whose result carries a key
+// (`revealsSecret` on the tool).
+export const MachineKey = z.strictObject({
+    machine: User,
+    key: z.string(),
+    // `<origin>/mcp`, the one address every machine talks to.
+    mcpUrl: z.string(),
+    // `<origin>/auth/machine/token`: the key in `x-api-key` against a 15-minute token for `/mcp`.
+    tokenUrl: z.string(),
+    example: z.string(),
+    // The documentation page "Operator einrichten".
+    docs: z.string(),
+});
+// What fell, by name (trap P334): after the purge nothing else can be read about it.
+export const MachinePurged = z.strictObject({ machineId: MachineId, name: z.string() });

package/dist/messages/messages.d.ts

@@ -0,0 +1,117 @@
+import { z } from "zod";
+export declare const MessageId: z.ZodTemplateLiteral<`message_${string}`>;
+export type MessageId = z.infer<typeof MessageId>;
+export declare const messageMaxLength = 10000;
+export declare const MessageListInput: z.ZodObject<{
+    nodeId: z.ZodTemplateLiteral<`node_${string}`>;
+    cursor: z.ZodOptional<z.ZodString>;
+    after: z.ZodOptional<z.ZodTemplateLiteral<`message_${string}`>>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strict>;
+export type MessageListInput = z.infer<typeof MessageListInput>;
+export declare const MessageCreateInput: z.ZodObject<{
+    nodeId: z.ZodTemplateLiteral<`node_${string}`>;
+    text: z.ZodString;
+    mentions: z.ZodOptional<z.ZodArray<z.ZodTemplateLiteral<`user_${string}`>>>;
+    idempotencyKey: z.ZodString;
+}, z.core.$strict>;
+export type MessageCreateInput = z.infer<typeof MessageCreateInput>;
+export declare const ChatUpdateInput: z.ZodObject<{
+    chatId: z.ZodTemplateLiteral<`node_${string}`>;
+    readUntil: z.ZodTemplateLiteral<`message_${string}`>;
+}, z.core.$strict>;
+export type ChatUpdateInput = z.infer<typeof ChatUpdateInput>;
+export declare const MessageAuthor: z.ZodObject<{
+    userId: z.ZodString;
+    name: z.ZodNullable<z.ZodString>;
+    kind: z.ZodNullable<z.ZodEnum<{
+        machine: "machine";
+        human: "human";
+    }>>;
+    machine: z.ZodNullable<z.ZodObject<{
+        kind: z.ZodEnum<{
+            operator: "operator";
+            external: "external";
+        }>;
+        provider: z.ZodNullable<z.ZodEnum<{
+            claude: "claude";
+            codex: "codex";
+            gemini: "gemini";
+        }>>;
+    }, z.core.$strict>>;
+    appHandle: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type MessageAuthor = z.infer<typeof MessageAuthor>;
+export declare const Message: z.ZodObject<{
+    messageId: z.ZodTemplateLiteral<`message_${string}`>;
+    nodeId: z.ZodTemplateLiteral<`node_${string}`>;
+    text: z.ZodString;
+    author: z.ZodObject<{
+        userId: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        kind: z.ZodNullable<z.ZodEnum<{
+            machine: "machine";
+            human: "human";
+        }>>;
+        machine: z.ZodNullable<z.ZodObject<{
+            kind: z.ZodEnum<{
+                operator: "operator";
+                external: "external";
+            }>;
+            provider: z.ZodNullable<z.ZodEnum<{
+                claude: "claude";
+                codex: "codex";
+                gemini: "gemini";
+            }>>;
+        }, z.core.$strict>>;
+        appHandle: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    mentions: z.ZodArray<z.ZodObject<{
+        userId: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    createdAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type Message = z.infer<typeof Message>;
+export declare const MessageList: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        messageId: z.ZodTemplateLiteral<`message_${string}`>;
+        nodeId: z.ZodTemplateLiteral<`node_${string}`>;
+        text: z.ZodString;
+        author: z.ZodObject<{
+            userId: z.ZodString;
+            name: z.ZodNullable<z.ZodString>;
+            kind: z.ZodNullable<z.ZodEnum<{
+                machine: "machine";
+                human: "human";
+            }>>;
+            machine: z.ZodNullable<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    operator: "operator";
+                    external: "external";
+                }>;
+                provider: z.ZodNullable<z.ZodEnum<{
+                    claude: "claude";
+                    codex: "codex";
+                    gemini: "gemini";
+                }>>;
+            }, z.core.$strict>>;
+            appHandle: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+        mentions: z.ZodArray<z.ZodObject<{
+            userId: z.ZodString;
+            name: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+    unreadCount: z.ZodNumber;
+    readUntil: z.ZodNullable<z.ZodTemplateLiteral<`message_${string}`>>;
+}, z.core.$strict>;
+export type MessageList = z.infer<typeof MessageList>;
+export declare const ChatRead: z.ZodObject<{
+    chatId: z.ZodTemplateLiteral<`node_${string}`>;
+    readUntil: z.ZodNullable<z.ZodTemplateLiteral<`message_${string}`>>;
+    unreadCount: z.ZodNumber;
+}, z.core.$strict>;
+export type ChatRead = z.infer<typeof ChatRead>;

package/dist/messages/messages.js

@@ -0,0 +1,77 @@
+import { z } from "zod";
+import { idSchema } from "../ids/ids.js";
+import { Limit as PageSize } from "../list-input.js";
+import { NodeId } from "../nodes/nodes.js";
+import { IdempotencyKey } from "../primitives/primitives.js";
+import { MessageMachine } from "../users/users.js";
+// The chat of a node (#45, Funktionen › Chat, E49, E67): the inputs of `intelligence_message_list`,
+// `intelligence_message_create` and `intelligence_chat_update`, and their answers. Every node but a
+// folder has a chat; it has no row of its own, and its `chatId` is the node's id. Messages are only
+// appended: no editing, no attachment, no following.
+export const MessageId = idSchema("message").describe("A message's id, `message_…`, as intelligence_message_list returns it.");
+// What a message may hold, in characters of Markdown.
+export const messageMaxLength = 10_000;
+export const MessageListInput = z.strictObject({
+    nodeId: NodeId.describe("The node whose chat to read: any node you can read except a folder, which has no chat."),
+    cursor: z
+        .string()
+        .max(200)
+        .optional()
+        .describe("The nextCursor of the previous page, unchanged, for the messages before it. Leaving it out starts with the newest."),
+    after: MessageId.optional().describe("Only the messages after this one, oldest first, to poll for what is new. A full page means there may be more: ask again with the last id. Not together with cursor."),
+    limit: PageSize.optional().describe("How many messages one page holds, 1 to 100. Leaving it out gives 50."),
+});
+export const MessageCreateInput = z.strictObject({
+    nodeId: NodeId.describe("The node whose chat to write in: any node you can read except a folder. Reading is enough to write."),
+    text: z
+        .string()
+        .trim()
+        .min(1)
+        .max(messageMaxLength)
+        .describe("The message as Markdown, at most 10,000 characters. It cannot be edited afterwards. To point at a file, put it into the tree and link the node."),
+    mentions: z
+        .array(idSchema("user"))
+        .max(50)
+        .optional()
+        .describe("The people and machines this message mentions, `user_…`; they see the chat in their Actions. Only someone who can read the node: find them with intelligence_user_list and readersOnly. One who cannot read it refuses the whole message."),
+    idempotencyKey: IdempotencyKey,
+});
+export const ChatUpdateInput = z.strictObject({
+    chatId: NodeId.describe("The chat to mark as read: the id of its node, `node_…`."),
+    readUntil: MessageId.describe("The newest message of this chat you have read. Your read state never moves back: an older one changes nothing."),
+});
+// Who wrote a message. A person writing in the browser has no `appHandle`; their AI writing through a
+// connected app carries that app's name. A machine carries its kind and an Operator its provider.
+// The UI makes the sentence of it ("Max Member via Claude Code", "Validierung · Claude", "Lead-Import").
+export const MessageAuthor = z.strictObject({
+    userId: z.string(),
+    // As `access` names them today; null for an account that is gone.
+    name: z.string().nullable(),
+    kind: z.enum(["human", "machine"]).nullable(),
+    // Only for a machine `access` still knows; null for a person.
+    machine: MessageMachine.nullable(),
+    appHandle: z.string().nullable(),
+});
+export const Message = z.strictObject({
+    messageId: MessageId,
+    nodeId: NodeId,
+    text: z.string(),
+    author: MessageAuthor,
+    mentions: z.array(z.strictObject({ userId: z.string(), name: z.string().nullable() })),
+    createdAt: z.iso.datetime(),
+});
+export const MessageList = z.strictObject({
+    // Oldest first, as a chat reads.
+    items: z.array(Message),
+    // The page before this one; null when there is none, and always with `after`.
+    nextCursor: z.string().nullable(),
+    // The caller's own: how many messages of others they have not read here, and the newest they have
+    // read (the "Neu" line goes below it). The read state is kept per person and per app.
+    unreadCount: z.number().int(),
+    readUntil: MessageId.nullable(),
+});
+export const ChatRead = z.strictObject({
+    chatId: NodeId,
+    readUntil: MessageId.nullable(),
+    unreadCount: z.number().int(),
+});