@anchrd/colab-sdk 0.1.22 → 0.1.24

package/dist/skills/skills.js

@@ -0,0 +1,245 @@
+import { z } from "zod";
+import { idSchema } from "../ids/ids.js";
+import { Flag, Limit } from "../list-input.js";
+import { NodeId, NodePath, NodePerson } from "../nodes/nodes.js";
+import { IdempotencyKey, Rev } from "../primitives/primitives.js";
+// Skills (#817, #807, Nodes › Skill, E140): the inputs of `intelligence_skill_create|get|update|test`
+// and `intelligence_skill_run_list|get`, and their answers. A skill says how something is done well:
+// its text in Markdown, the result that is there at the end, and a trigger that says when it fits.
+// Its tests check the result, not the way, with recordings of real runs.
+export const SkillId = NodeId.describe("The skill's id, a `node_…` of kind skill.");
+// A run of a skill is the resource `run` (`run_…`), like a run of a goal.
+const RunId = idSchema("run").describe("The run's id, `run_…`, as intelligence_skill_run_list names it.");
+const Content = z
+    .string()
+    .max(200_000)
+    .describe("The skill's text as Markdown, without a fixed structure and without a title (the name is the title). Its first paragraph says what the skill is for.");
+const Result = z
+    .string()
+    .max(20_000)
+    .describe("What is there at the end, as a Markdown list of checkable sentences, one point per line. The tests check against it; optional, but tests need it.");
+const Trigger = z
+    .string()
+    .max(2000)
+    .describe("When the skill fits, like the description of a Claude skill: an Operator reads it with the name at the start of a run and decides itself whether to load the skill. Used only while triggerOn is true.");
+const TriggerOn = z
+    .boolean()
+    .describe("Whether the trigger is used. Off, the skill comes only when someone names it with @Skill; its trigger text stays.");
+// The code of a skill (#807): `evals.yaml` and `data/<case>/<tool>.json`.
+export const skillFilePattern = /^(evals\.yaml|data\/[a-z0-9][a-z0-9-]{0,63}\/[a-z0-9_]{1,80}\.json)$/;
+export const SkillFilePath = z
+    .string()
+    .regex(skillFilePattern)
+    .describe("`evals.yaml`, or `data/<case>/<tool>.json` with the recorded answers of one tool for one test case (case in kebab-case).");
+const FileText = z.string().max(500_000);
+export const SkillCreateInput = z.strictObject({
+    // ⚠️ Required and nullable (trap C015): null is the top level of Shared.
+    parentId: NodeId.nullable().describe("The folder to create the skill in, one you can write to, mostly `.Skills` or the folder it is for; null creates it on the top level of Shared."),
+    name: z.string().max(200).describe("The name as people read it, like `Leads übernehmen`."),
+    content: Content,
+    result: Result.optional(),
+    trigger: Trigger.optional(),
+    triggerOn: TriggerOn.optional(),
+    idempotencyKey: IdempotencyKey,
+});
+export const SkillGetInput = z.strictObject({
+    skillId: SkillId,
+    files: Flag.optional().describe("Also answer the code (evals.yaml and data/) and the latest test run. Only for whoever may change the skill; a reader gets neither."),
+});
+export const SkillUpdateInput = z.strictObject({
+    skillId: SkillId,
+    content: Content.optional(),
+    result: Result.optional(),
+    trigger: Trigger.optional(),
+    triggerOn: TriggerOn.optional(),
+    files: z
+        .record(SkillFilePath, FileText.nullable())
+        .optional()
+        .describe("Files of the code to write, by path; null removes one. Files you leave out stay as they are."),
+    fromRun: RunId.optional().describe("A run of the skill's log to take over as a test case: writes data/<case>/ with the answers of its reading tools and a case in evals.yaml with aus_lauf. Write the expectation into the case afterwards."),
+    rev: Rev,
+    editSession: z
+        .string()
+        .min(1)
+        .max(100)
+        .optional()
+        .describe("The editing session the editor keeps while a person stays on the skill: saves of one session go into one version. Leaving it out makes every save a version of its own, which is right for an AI."),
+});
+export const SkillTestInput = z.strictObject({
+    skillId: SkillId,
+    record: z
+        .string()
+        .min(1)
+        .max(200)
+        .optional()
+        .describe("The name of one case to record anew: it runs once with real reading tools and the rights of the Operator in evals.yaml; if it passes, its data/ replaces the old recording. Writing still goes into the sandbox."),
+});
+export const SkillRunListInput = z.strictObject({
+    skillId: SkillId,
+    cursor: z
+        .string()
+        .max(1000)
+        .optional()
+        .describe("The nextCursor of the previous page, unchanged. Leaving it out starts at the newest."),
+    limit: Limit.optional().describe("How many runs one page holds, 1 to 100. Leaving it out gives 50."),
+});
+export const SkillRunGetInput = z.strictObject({ skillId: SkillId, runId: RunId });
+export const SkillFile = z.object({ path: z.string(), content: z.string() });
+// One point a case is checked against: a line of the result, or one it expects in addition.
+export const SkillPoint = z.object({
+    text: z.string(),
+    kind: z.enum(["result", "expected"]),
+    ok: z.boolean(),
+    // Why it failed, as the grading model read the trace and the result; null when it passed.
+    reason: z.string().nullable(),
+});
+export const skillCaseStatuses = ["passed", "failed", "missing"];
+// What the model read and wrote in a step of the tests, in tokens (#835, E146).
+export const SkillTokens = z.object({ input: z.int(), output: z.int() });
+export const SkillCaseResult = z.object({
+    name: z.string(),
+    // passed: every run passed every point; failed: one did not; missing: a tool without a recording
+    // was called, so the case stopped before it ran it. Not a fault of the skill.
+    status: z.enum(skillCaseStatuses),
+    // When the case's data was recorded, with which version; null where evals.yaml does not say.
+    recordedAt: z.string().nullable(),
+    fromRun: z.string().nullable(),
+    runs: z.int(),
+    passedRuns: z.int(),
+    points: z.array(SkillPoint),
+    // The call without a recording that stopped the case.
+    missing: z.object({ tool: z.string(), path: z.string() }).nullable(),
+    // The sandbox's writes of the last run: what it would have written, written nowhere.
+    sandbox: z.array(z.object({ tool: z.string() })),
+    costUsd: z.number(),
+    // The model's tokens over every run of the case (#835); absent in a report from before.
+    tokens: SkillTokens.optional(),
+    // The probe run of the case's last attempt, its trace in the log.
+    runId: RunId.nullable(),
+});
+export const SkillTriggerHit = z.object({
+    kind: z.enum(["should", "shouldNot"]),
+    request: z.string(),
+    // The skill the model chose for the request, by name; null for none.
+    chosen: z.string().nullable(),
+    ok: z.boolean(),
+});
+export const SkillTestReport = z.object({
+    version: z.int(),
+    at: z.iso.datetime(),
+    by: NodePerson,
+    passed: z.int(),
+    failed: z.int(),
+    missing: z.int(),
+    // Only while the trigger is on and evals.yaml names requests.
+    trigger: z
+        .object({
+        // How many skills the list held that the Operator sees at its start.
+        skills: z.int(),
+        operator: NodePerson.nullable(),
+        hits: z.array(SkillTriggerHit),
+        costUsd: z.number(),
+        tokens: SkillTokens.optional(),
+    })
+        .nullable(),
+    cases: z.array(SkillCaseResult),
+    // What evals.yaml got wrong, a sentence; null when it reads.
+    problem: z.string().nullable(),
+});
+export const SkillDetail = z.object({
+    skillId: SkillId,
+    name: z.string(),
+    hidden: z.boolean(),
+    parentId: NodeId.nullable(),
+    path: NodePath,
+    content: z.string(),
+    result: z.string(),
+    trigger: z.string(),
+    triggerOn: z.boolean(),
+    // The current version's number ("Version 13").
+    version: z.int(),
+    rev: z.int(),
+    archivedAt: z.iso.datetime().nullable(),
+    // The code and the latest test run, only for whoever may change the skill and asked for them;
+    // null otherwise. Recordings carry real data of runs that a reader does not see (E140).
+    files: z.array(SkillFile).nullable(),
+    test: SkillTestReport.nullable(),
+    rights: z.object({
+        // Change the skill, see its code and console, run its tests.
+        write: z.boolean(),
+    }),
+});
+export const skillRunKinds = ["operator", "person", "probe"];
+export const skillRunStatuses = [
+    "open",
+    "reached",
+    "missed",
+    "passed",
+    "failed",
+    "missing",
+];
+export const SkillRunItem = z.object({
+    runId: RunId,
+    skillId: SkillId,
+    // operator: an Operator ran it; person: a person through their AI; probe: a test case.
+    kind: z.enum(skillRunKinds),
+    by: NodePerson,
+    // The connected app it came through ("Claude"), null for an Operator and a probe.
+    via: z.string().nullable(),
+    // Where it ran: the goal of an Operator run, the chat or a test case.
+    context: z.object({
+        kind: z.enum(["goal", "chat", "tests"]),
+        nodeId: NodeId.nullable(),
+        name: z.string().nullable(),
+    }),
+    // The skill's version it ran with.
+    version: z.int(),
+    // open while nothing says how it ended; reached and missed from the goal run it worked for;
+    // passed, failed and missing for a probe.
+    status: z.enum(skillRunStatuses),
+    startedAt: z.iso.datetime(),
+    calls: z.int(),
+    // The case of a probe, null otherwise.
+    caseName: z.string().nullable(),
+    // Taken over as a test case: its recording stays past the 30 days.
+    kept: z.boolean(),
+});
+export const SkillRunCall = z.object({
+    seq: z.int(),
+    tool: z.string(),
+    write: z.boolean(),
+    // Recorded only in the sandbox of a probe: written nowhere.
+    sandbox: z.boolean(),
+    input: z.unknown(),
+    answer: z.unknown(),
+    // How many rows or entries the answer carried, null where it holds no list.
+    size: z.int().nullable(),
+    durationMs: z.int(),
+    // The error code of a refused call, null otherwise.
+    code: z.string().nullable(),
+});
+export const SkillRunDetail = SkillRunItem.extend({
+    calls: z.array(SkillRunCall),
+    // A point that failed, with the grading's reason; null where nothing failed.
+    note: z.string().nullable(),
+    // When the recording goes: 30 days after the run, null when kept.
+    expiresAt: z.iso.datetime().nullable(),
+});
+export const SkillRunList = z.object({
+    items: z.array(SkillRunItem),
+    nextCursor: z.string().nullable(),
+});
+// What a version of a skill holds beside its text (E140): result, trigger and the code.
+export const SkillFields = z.object({
+    result: z.string(),
+    trigger: z.string(),
+    triggerOn: z.boolean(),
+    files: z.record(z.string(), z.string()),
+});
+// The skills an Operator gets at the start of a run (E140): name and trigger of every readable skill
+// with its trigger on, from `.Skills` and the folders above the nodes it works at.
+export const SkillOffer = z.object({
+    skillId: SkillId,
+    name: z.string(),
+    trigger: z.string(),
+});

package/dist/tool.d.ts

@@ -10,6 +10,7 @@ export type Actor = {
     adminMode: boolean;
     client?: string;
     session?: string;
+    operator?: string;
 };
 export type ToolSource = "api" | "mcp";
 export type ToolContext = {

package/dist/validation/validation.d.ts

@@ -2,6 +2,7 @@ import { z } from "zod";
 export declare const validationBoardId: "node_0000000000000000000000VA1D";
 export declare const ValidationBoardId: z.ZodLiteral<"node_0000000000000000000000VA1D">;
 export type ValidationBoardId = z.infer<typeof ValidationBoardId>;
+export declare const validationGoalId: "node_0000000000000000000000VA1G";
 export declare const TicketSubject: z.ZodObject<{
     nodeId: z.ZodTemplateLiteral<`node_${string}`>;
     kind: z.ZodEnum<{
@@ -12,6 +13,8 @@ export declare const TicketSubject: z.ZodObject<{
         board: "board";
         task: "task";
         gadget: "gadget";
+        goal: "goal";
+        skill: "skill";
     }>;
     name: z.ZodString;
     path: z.ZodObject<{
@@ -37,6 +40,8 @@ export declare const TicketSubjectRef: z.ZodObject<{
         board: "board";
         task: "task";
         gadget: "gadget";
+        goal: "goal";
+        skill: "skill";
     }>;
     path: z.ZodObject<{
         section: z.ZodEnum<{

package/dist/validation/validation.js

@@ -10,6 +10,10 @@ export const validationBoardId = "node_0000000000000000000000VA1D";
 export const ValidationBoardId = z
     .literal(validationBoardId)
     .describe("The validation board, the same id in every Colab.");
+// ⚠️ The system goal of the validation (#814, E139): when and how the board is worked, a goal with
+// rhythm, budget and runs like any. Exactly one per Colab, a node of kind `goal` that stands in no
+// area of the tree, made beside the board on its first use, never archived. A ULID of zeros and `VA1G`.
+export const validationGoalId = "node_0000000000000000000000VA1G";
 // The node a ticket validates, as the caller can read it.
 export const TicketSubject = z.object({
     nodeId: NodeId,

package/dist/versions/versions.d.ts

@@ -52,11 +52,11 @@ export declare const TaskVersionChange: z.ZodEnum<{
     title: "title";
     text: "text";
     dates: "dates";
+    waiting: "waiting";
     assignee: "assignee";
     labels: "labels";
     parent: "parent";
     dependencies: "dependencies";
-    waiting: "waiting";
 }>;
 export type TaskVersionChange = z.infer<typeof TaskVersionChange>;
 export declare const TaskMove: z.ZodObject<{
@@ -168,11 +168,11 @@ export declare const NodeVersion: z.ZodObject<{
         title: "title";
         text: "text";
         dates: "dates";
+        waiting: "waiting";
         assignee: "assignee";
         labels: "labels";
         parent: "parent";
         dependencies: "dependencies";
-        waiting: "waiting";
     }>>>;
 }, z.core.$strip>;
 export type NodeVersion = z.infer<typeof NodeVersion>;
@@ -229,11 +229,11 @@ export declare const NodeVersionList: z.ZodObject<{
             title: "title";
             text: "text";
             dates: "dates";
+            waiting: "waiting";
             assignee: "assignee";
             labels: "labels";
             parent: "parent";
             dependencies: "dependencies";
-            waiting: "waiting";
         }>>>;
     }, z.core.$strip>>;
     nextCursor: z.ZodNullable<z.ZodString>;
@@ -292,11 +292,11 @@ export declare const NodeVersionDetail: z.ZodObject<{
         title: "title";
         text: "text";
         dates: "dates";
+        waiting: "waiting";
         assignee: "assignee";
         labels: "labels";
         parent: "parent";
         dependencies: "dependencies";
-        waiting: "waiting";
     }>>>;
     secret: z.ZodOptional<z.ZodLiteral<true>>;
     locked: z.ZodOptional<z.ZodBoolean>;
@@ -328,6 +328,66 @@ export declare const NodeVersionDetail: z.ZodObject<{
             done: z.ZodBoolean;
         }, z.core.$strip>>]>;
     }, z.core.$strip>>>;
+    goal: z.ZodNullable<z.ZodObject<{
+        operatorId: z.ZodNullable<z.ZodString>;
+        rhythm: z.ZodNullable<z.ZodObject<{
+            rhythm: z.ZodEnum<{
+                manual: "manual";
+                daily: "daily";
+                weekly: "weekly";
+                monthly: "monthly";
+                dates: "dates";
+            }>;
+            days: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                monday: "monday";
+                tuesday: "tuesday";
+                wednesday: "wednesday";
+                thursday: "thursday";
+                friday: "friday";
+                saturday: "saturday";
+                sunday: "sunday";
+            }>>>;
+            dayOfMonth: z.ZodOptional<z.ZodArray<z.ZodInt>>;
+            weekdayOfMonth: z.ZodOptional<z.ZodObject<{
+                week: z.ZodEnum<{
+                    first: "first";
+                    last: "last";
+                    second: "second";
+                    third: "third";
+                    fourth: "fourth";
+                }>;
+                day: z.ZodEnum<{
+                    monday: "monday";
+                    tuesday: "tuesday";
+                    wednesday: "wednesday";
+                    thursday: "thursday";
+                    friday: "friday";
+                    saturday: "saturday";
+                    sunday: "sunday";
+                }>;
+            }, z.core.$strict>>;
+            times: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            dates: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            zone: z.ZodOptional<z.ZodString>;
+            whileOpen: z.ZodOptional<z.ZodEnum<{
+                wait: "wait";
+                continue: "continue";
+            }>>;
+        }, z.core.$strict>>;
+        budget: z.ZodNullable<z.ZodNumber>;
+        maxHours: z.ZodNullable<z.ZodInt>;
+        planning: z.ZodEnum<{
+            short: "short";
+            detailed: "detailed";
+        }>;
+        reportToId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    skill: z.ZodNullable<z.ZodObject<{
+        result: z.ZodString;
+        trigger: z.ZodString;
+        triggerOn: z.ZodBoolean;
+        files: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strip>>;
     rev: z.ZodNumber;
 }, z.core.$strip>;
 export type NodeVersionDetail = z.infer<typeof NodeVersionDetail>;
@@ -383,11 +443,11 @@ export declare const NodeVersionExcerpt: z.ZodObject<{
         title: "title";
         text: "text";
         dates: "dates";
+        waiting: "waiting";
         assignee: "assignee";
         labels: "labels";
         parent: "parent";
         dependencies: "dependencies";
-        waiting: "waiting";
     }>>>;
     secret: z.ZodOptional<z.ZodLiteral<true>>;
     locked: z.ZodOptional<z.ZodBoolean>;
@@ -419,6 +479,66 @@ export declare const NodeVersionExcerpt: z.ZodObject<{
             done: z.ZodBoolean;
         }, z.core.$strip>>]>;
     }, z.core.$strip>>>;
+    goal: z.ZodNullable<z.ZodObject<{
+        operatorId: z.ZodNullable<z.ZodString>;
+        rhythm: z.ZodNullable<z.ZodObject<{
+            rhythm: z.ZodEnum<{
+                manual: "manual";
+                daily: "daily";
+                weekly: "weekly";
+                monthly: "monthly";
+                dates: "dates";
+            }>;
+            days: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                monday: "monday";
+                tuesday: "tuesday";
+                wednesday: "wednesday";
+                thursday: "thursday";
+                friday: "friday";
+                saturday: "saturday";
+                sunday: "sunday";
+            }>>>;
+            dayOfMonth: z.ZodOptional<z.ZodArray<z.ZodInt>>;
+            weekdayOfMonth: z.ZodOptional<z.ZodObject<{
+                week: z.ZodEnum<{
+                    first: "first";
+                    last: "last";
+                    second: "second";
+                    third: "third";
+                    fourth: "fourth";
+                }>;
+                day: z.ZodEnum<{
+                    monday: "monday";
+                    tuesday: "tuesday";
+                    wednesday: "wednesday";
+                    thursday: "thursday";
+                    friday: "friday";
+                    saturday: "saturday";
+                    sunday: "sunday";
+                }>;
+            }, z.core.$strict>>;
+            times: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            dates: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            zone: z.ZodOptional<z.ZodString>;
+            whileOpen: z.ZodOptional<z.ZodEnum<{
+                wait: "wait";
+                continue: "continue";
+            }>>;
+        }, z.core.$strict>>;
+        budget: z.ZodNullable<z.ZodNumber>;
+        maxHours: z.ZodNullable<z.ZodInt>;
+        planning: z.ZodEnum<{
+            short: "short";
+            detailed: "detailed";
+        }>;
+        reportToId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    skill: z.ZodNullable<z.ZodObject<{
+        result: z.ZodString;
+        trigger: z.ZodString;
+        triggerOn: z.ZodBoolean;
+        files: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strip>>;
     excerpt: z.ZodUnion<readonly [z.ZodObject<{
         offset: z.ZodNumber;
         length: z.ZodNumber;

package/dist/versions/versions.js

@@ -2,10 +2,12 @@ import { z } from "zod";
 import { CardFieldType, CardFieldValue } from "../card-kinds/card-kinds.js";
 import { ColumnId, ColumnType } from "../columns/columns.js";
 import { ExcerptCursor, RowsExcerpt, TextExcerpt } from "../excerpt/excerpt.js";
+import { GoalFields } from "../goals/goals.js";
 import { idSchema } from "../ids/ids.js";
 import { Limit as PageSize } from "../list-input.js";
 import { NodeId, NodePerson, SecretFields } from "../nodes/nodes.js";
 import { Rev } from "../primitives/primitives.js";
+import { SkillFields } from "../skills/skills.js";
 import { TableColumn } from "../tables/tables.js";
 // Versions of documents, tables, files and tasks (#38, #637, Funktionen › Freigeben und Versionen, E37,
 // E70, E117): the inputs of `intelligence_node_version_list`, `_get` and `_create`, and their answers.
@@ -112,6 +114,10 @@ export const NodeVersionDetail = NodeVersion.extend({
     fields: z
         .array(z.object({ name: z.string(), type: CardFieldType, value: CardFieldValue }))
         .nullable(),
+    // Only for a goal (#813, E139): its fields above the line in this version; null for every other.
+    goal: GoalFields.nullable(),
+    // Only for a skill (#817, E140): its result, trigger and code in this version; null for every other.
+    skill: SkillFields.nullable(),
     // The node's revision now: after a restore the one the next save sends.
     rev: z.number().int(),
     // A version of a secret node (#357): `content` and `columns` are null while it is `locked` for

package/dist/written/written.d.ts

@@ -7,6 +7,8 @@ export declare const Changed: z.ZodObject<{
     boardId: z.ZodOptional<z.ZodTemplateLiteral<`node_${string}`>>;
     taskId: z.ZodOptional<z.ZodTemplateLiteral<`node_${string}`>>;
     gadgetId: z.ZodOptional<z.ZodTemplateLiteral<`node_${string}`>>;
+    goalId: z.ZodOptional<z.ZodTemplateLiteral<`node_${string}`>>;
+    skillId: z.ZodOptional<z.ZodTemplateLiteral<`node_${string}`>>;
     runId: z.ZodOptional<z.ZodTemplateLiteral<`run_${string}`>>;
     messageId: z.ZodOptional<z.ZodTemplateLiteral<`message_${string}`>>;
     chatId: z.ZodOptional<z.ZodTemplateLiteral<`node_${string}`>>;
@@ -29,6 +31,7 @@ export declare const Changed: z.ZodObject<{
     connectorId: z.ZodOptional<z.ZodString>;
     connectionId: z.ZodOptional<z.ZodTemplateLiteral<`connection_${string}`>>;
     credentialId: z.ZodOptional<z.ZodTemplateLiteral<`credential_${string}`>>;
+    mcpId: z.ZodOptional<z.ZodTemplateLiteral<`mcp_${string}`>>;
     ref: z.ZodOptional<z.ZodString>;
     rev: z.ZodOptional<z.ZodNumber>;
     version: z.ZodOptional<z.ZodNumber>;
@@ -95,6 +98,8 @@ export declare const Written: z.ZodObject<{
         boardId: z.ZodOptional<z.ZodTemplateLiteral<`node_${string}`>>;
         taskId: z.ZodOptional<z.ZodTemplateLiteral<`node_${string}`>>;
         gadgetId: z.ZodOptional<z.ZodTemplateLiteral<`node_${string}`>>;
+        goalId: z.ZodOptional<z.ZodTemplateLiteral<`node_${string}`>>;
+        skillId: z.ZodOptional<z.ZodTemplateLiteral<`node_${string}`>>;
         runId: z.ZodOptional<z.ZodTemplateLiteral<`run_${string}`>>;
         messageId: z.ZodOptional<z.ZodTemplateLiteral<`message_${string}`>>;
         chatId: z.ZodOptional<z.ZodTemplateLiteral<`node_${string}`>>;
@@ -117,6 +122,7 @@ export declare const Written: z.ZodObject<{
         connectorId: z.ZodOptional<z.ZodString>;
         connectionId: z.ZodOptional<z.ZodTemplateLiteral<`connection_${string}`>>;
         credentialId: z.ZodOptional<z.ZodTemplateLiteral<`credential_${string}`>>;
+        mcpId: z.ZodOptional<z.ZodTemplateLiteral<`mcp_${string}`>>;
         ref: z.ZodOptional<z.ZodString>;
         rev: z.ZodOptional<z.ZodNumber>;
         version: z.ZodOptional<z.ZodNumber>;

package/dist/written/written.js

@@ -7,6 +7,7 @@ import { GrantId } from "../grants/grants.js";
 import { InvitationId } from "../invitations/invitations.js";
 import { LinkId } from "../links/links.js";
 import { MachineId } from "../machines/machines.js";
+import { McpId } from "../mcps/mcps.js";
 import { MessageId } from "../messages/messages.js";
 import { Missing, Reached } from "../missing/missing.js";
 import { NodeId, NodeReader } from "../nodes/nodes.js";
@@ -30,6 +31,8 @@ export const Changed = z.object({
     boardId: NodeId.optional(),
     taskId: NodeId.optional(),
     gadgetId: NodeId.optional(),
+    goalId: NodeId.optional(),
+    skillId: NodeId.optional(),
     runId: RunId.optional(),
     messageId: MessageId.optional(),
     // A chat is its node's (#45).
@@ -54,6 +57,8 @@ export const Changed = z.object({
     connectorId: ConnectorId.optional(),
     connectionId: ConnectionId.optional(),
     credentialId: CredentialId.optional(),
+    // A person's own MCP (#802).
+    mcpId: McpId.optional(),
     // The caller's own name for an entry of a create of many (#625).
     ref: z.string().optional(),
     rev: z.number().int().optional(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anchrd/colab-sdk",
-  "version": "0.1.22",
+  "version": "0.1.24",
   "description": "Types, Zod schemas and the service client of Colab, the contract between its UI, backends and outside services.",
   "type": "module",
   "license": "UNLICENSED",