@anchrd/colab-sdk 0.1.29 → 0.1.31

package/dist/sources/sources.js

@@ -0,0 +1,442 @@
+import { z } from "zod";
+import { GadgetFile, GadgetFilePath, GadgetLevel, GadgetTestRun } from "../gadgets/gadgets.js";
+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";
+import { RunId } from "../runs/runs.js";
+import { UserId } from "../users/users.js";
+// Sources (#900, E151, Nodes › Quelle): a node that fetches data from outside on a schedule and keeps
+// what came as items. Its files (`source.json`, `source.js`, `tests/**`) with a draft and published
+// versions like a gadget, its queries, its runs and its items. The inputs of
+// `intelligence_source_*` and their answers.
+const SourceId = NodeId.describe("The source's id, a `node_…` of kind source.");
+export const QueryId = idSchema("query").describe("A query of the source, `query_…`.");
+export const ItemId = idSchema("item").describe("An item of the source, `item_…`.");
+// ---- The manifest `source.json`, schema `colab:source/1` ----
+export const sourceSchema = "colab:source/1";
+// The column types of a table (Nodes › Tabelle): a source's fields take exactly these.
+export const sourceFieldTypes = ["text", "number", "date", "email", "chip"];
+export const SourceFieldType = z.enum(sourceFieldTypes);
+// Cleaning beyond the type (Nodes › Quelle › Bereinigung): a company's name in its usual spelling,
+// an amount of money as a number.
+export const sourceCleans = ["company", "money"];
+// A path into one entry: `$`, then `.name`, `[0]`, `["name"]`, and `[*]` for every element.
+export const SourcePath = z
+    .string()
+    .min(1)
+    .max(300)
+    .regex(/^\$(\.[A-Za-z_$][A-Za-z0-9_$-]*|\[\d+\]|\[\*\]|\["[^"\]]+"\])*$/, 'A path is $ followed by .name, [0], ["name"] or [*], like $.data[*] or $.company.name.');
+const Word = z.string().regex(/^[a-z][A-Za-z0-9]{0,39}$/, "A key is a word like company or since.");
+const SecretName = z
+    .string()
+    .regex(/^[A-Z][A-Z0-9_]{0,63}$/)
+    .describe("A secret's name in capitals, such as PORTAL_KEY.");
+export const SourceField = z.strictObject({
+    label: z.string().min(1).max(100),
+    type: SourceFieldType,
+    path: SourcePath,
+    clean: z.array(z.enum(sourceCleans)).max(2).optional(),
+});
+export const SourceParam = z.strictObject({
+    label: z.string().min(1).max(100).optional(),
+    type: z.enum(["text", "number", "date"]).optional(),
+    // A query picks one of these.
+    enum: z.array(z.string().min(1).max(200)).min(1).max(200).optional(),
+    required: z.boolean().optional(),
+    // Set by the run itself: the moment the last successful run of the query started.
+    from: z.literal("lastRun").optional(),
+    default: z.union([z.string().max(200), z.number()]).optional(),
+});
+// How the bridge sets the key on every request; the code never sees it.
+export const SourceAccess = z.discriminatedUnion("kind", [
+    z.strictObject({ kind: z.literal("bearer"), secret: SecretName }),
+    z.strictObject({
+        kind: z.literal("header"),
+        name: z.string().regex(/^[A-Za-z0-9-]{1,64}$/),
+        prefix: z.string().max(40).optional(),
+        secret: SecretName,
+    }),
+    z.strictObject({ kind: z.literal("basic"), username: SecretName, password: SecretName }),
+    z.strictObject({
+        kind: z.literal("query"),
+        name: z.string().regex(/^[A-Za-z0-9_.-]{1,64}$/),
+        secret: SecretName,
+    }),
+    z.strictObject({ kind: z.literal("none") }),
+]);
+export const SourcePaging = z.discriminatedUnion("type", [
+    // `?<param>=1`, 2, … until a page has no entries or `max` pages were read.
+    z.strictObject({
+        type: z.literal("page"),
+        param: z.string().regex(/^[A-Za-z0-9_.-]{1,64}$/),
+        start: z.number().int().min(0).max(1).optional(),
+        max: z.number().int().min(1).max(5),
+    }),
+    // The answer names the next page's address under `path`, until it names none.
+    z.strictObject({
+        type: z.literal("next"),
+        path: SourcePath,
+        max: z.number().int().min(1).max(5),
+    }),
+]);
+export const SourceManifest = z.strictObject({
+    $schema: z.literal(sourceSchema),
+    name: z.string().min(1).max(200),
+    description: z.string().max(2000).optional(),
+    // json and rss run through Colab's own interpreter, code through `source.js`.
+    kind: z.enum(["json", "rss", "code"]),
+    // Every request's address starts here, an `https` address on one of the hosts.
+    base: z.string().min(1).max(500),
+    // The only hosts a request reaches: host names, never an address.
+    hosts: z.array(z.string().min(1).max(253)).min(1).max(10),
+    access: SourceAccess.optional(),
+    secrets: z
+        .record(SecretName, z.strictObject({ label: z.string().min(1).max(100), help: z.string().max(500).optional() }))
+        .optional(),
+    params: z.record(Word, SourceParam).optional(),
+    // Below `base`; `{{params.name}}` puts in a query's parameter.
+    request: z
+        .strictObject({
+        path: z.string().min(1).max(2000),
+        query: z.record(z.string().min(1).max(64), z.string().max(500)).optional(),
+    })
+        .optional(),
+    paging: SourcePaging.optional(),
+    // Where the entries stand in an answer; an rss source reads its items itself.
+    items: SourcePath.optional(),
+    // The one required field: what an entry is recognised by again.
+    ref: SourcePath,
+    fields: z.record(Word, SourceField).optional(),
+});
+export const sourceManifestPath = "source.json";
+export const sourceCodePath = "source.js";
+// A run's limits (Nodes › Quelle › Grenzen).
+export const sourceLimits = {
+    timeoutMs: 10_000,
+    bytes: 2 * 1024 * 1024,
+    pages: 5,
+    // A `source.js` sends at most this many requests per run (a list, then a detail per entry).
+    requests: 50,
+    items: 1000,
+};
+export const sourceKeepDays = [30, 90, 180];
+const KeepDays = z
+    .union([z.literal(30), z.literal(90), z.literal(180)])
+    .describe("How many days the items stay: 30, 90 or 180.");
+const LogDays = z
+    .union([z.literal(7), z.literal(14), z.literal(30)])
+    .describe("How many days the runs stay: 7, 14 or 30.");
+// ---- Queries ----
+export const sourceEvery = ["hour", "day", "week"];
+const TimeOfDay = z
+    .string()
+    .regex(/^([01]\d|2[0-3]):00$/, "A time is a full hour, HH:00, like 07:00.");
+export const SourceSchedule = z
+    .strictObject({
+    every: z.enum(sourceEvery).describe("hour, day or week."),
+    time: TimeOfDay.optional().describe("The hour of a daily or weekly run, like 07:00."),
+    day: z
+        .enum(["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"])
+        .optional()
+        .describe("The weekday of a weekly run."),
+    zone: z
+        .string()
+        .max(64)
+        .optional()
+        .describe("The time zone of time, Europe/Berlin if left out."),
+})
+    .refine((value) => value.every === "hour" || value.time !== undefined, {
+    message: "A daily or weekly run needs its time.",
+    path: ["time"],
+})
+    .refine((value) => value.every === "week" || value.day === undefined, {
+    message: "Only a weekly run takes a day.",
+    path: ["day"],
+})
+    .refine((value) => value.every !== "week" || value.day !== undefined, {
+    message: "A weekly run needs its day.",
+    path: ["day"],
+});
+export const SourceWhere = z.strictObject({
+    field: Word,
+    op: z.enum(["eq", "ne", "gte", "lte", "contains"]),
+    value: z.union([z.string().max(200), z.number()]),
+});
+const ParamValues = z
+    .record(Word, z.union([z.string().max(200), z.number()]))
+    .describe("The values of the source's params by name; a param with an enum takes one of it.");
+// ---- Tool inputs ----
+const FileContent = z.string().describe("The file's whole text.");
+export const SourceCreateInput = z.strictObject({
+    parentId: NodeId.nullable().describe("The folder to create the source in, one you can write to; null creates it on the top level of Shared."),
+    name: z.string().max(200).describe("The name as people read it."),
+    files: z
+        .record(GadgetFilePath, FileContent)
+        .optional()
+        .describe("The first files by path: source.json, source.js (only for kind code), tests/*.test.js, tests/fixtures/*, icon.svg. They become the draft. Leaving it out creates an empty source."),
+    idempotencyKey: IdempotencyKey,
+});
+export const SourceVersionRef = z.preprocess((value) => (typeof value === "string" && /^[1-9][0-9]{0,8}$/.test(value) ? Number(value) : value), z.union([z.enum(["live", "draft"]), z.number().int().min(1)]));
+export const SourceGetInput = z.strictObject({
+    sourceId: SourceId,
+    version: SourceVersionRef.optional().describe("Which state to read: live (the default), draft or a published version's number; both only with the right to change the source."),
+    include: z
+        .preprocess((value) => (typeof value === "string" ? value.split(",") : value), z
+        .array(z.enum(["files"]))
+        .min(1)
+        .max(1))
+        .optional()
+        .describe("files: answer the text of every file of that state."),
+});
+export const SourceUpdateInput = z.strictObject({
+    sourceId: SourceId,
+    files: z
+        .record(GadgetFilePath, FileContent.nullable())
+        .optional()
+        .describe("Files to write into the draft by path, each with its whole new text; null removes one. Files you leave out stay. Without a draft, it starts from the live version."),
+    fromVersion: z
+        .number()
+        .int()
+        .min(1)
+        .optional()
+        .describe("Restore a published version into the draft."),
+    discard: z.literal(true).optional().describe("Throw the draft away."),
+    settings: z
+        .strictObject({
+        responsibleId: UserId.nullable().optional(),
+        level: GadgetLevel.optional(),
+        keepDays: KeepDays.optional(),
+        logDays: LogDays.optional(),
+    })
+        .optional()
+        .describe("The settings; they apply at once, not through the draft."),
+    rev: Rev,
+});
+export const SourceTestInput = z.strictObject({
+    sourceId: SourceId,
+    version: z
+        .enum(["live", "draft"])
+        .optional()
+        .describe("draft (the default when there is one) or live."),
+    probe: z
+        .strictObject({
+        queryId: QueryId.optional().describe("Fetch with this query's params."),
+        params: ParamValues.optional(),
+    })
+        .optional()
+        .describe("A probe instead of the tests: fetch from the provider for real with that state and answer the items, without storing anything."),
+});
+export const SourcePublishInput = z.strictObject({
+    sourceId: SourceId,
+    force: z.literal(true).optional().describe("Publish although tests fail. Never for a machine."),
+    rev: Rev,
+});
+export const SourceQueryListInput = z.strictObject({
+    sourceId: SourceId,
+    archived: Flag.optional().describe("true lists the archived queries instead."),
+});
+export const SourceQueryCreateInput = z.strictObject({
+    sourceId: SourceId,
+    name: z.string().trim().min(1).max(200),
+    schedule: SourceSchedule,
+    params: ParamValues.optional(),
+    where: z
+        .array(SourceWhere)
+        .max(10)
+        .optional()
+        .describe("Only if: keep an item only when every condition holds."),
+    enabled: z.boolean().optional().describe("Whether it runs on its schedule; true if left out."),
+    idempotencyKey: IdempotencyKey,
+});
+export const SourceQueryUpdateInput = z.strictObject({
+    sourceId: SourceId,
+    queryId: QueryId,
+    name: z.string().trim().min(1).max(200).optional(),
+    schedule: SourceSchedule.optional(),
+    params: ParamValues.optional(),
+    where: z.array(SourceWhere).max(10).optional(),
+    enabled: z.boolean().optional(),
+    rev: z.number().int().min(1).describe("The query's rev as the last read returned it."),
+});
+export const SourceQueryArchiveInput = z.strictObject({ sourceId: SourceId, queryId: QueryId });
+export const SourceQueryRestoreInput = z.strictObject({ sourceId: SourceId, queryId: QueryId });
+export const SourceRunListInput = z.strictObject({
+    sourceId: SourceId,
+    queryId: QueryId.optional(),
+    status: z.enum(["running", "succeeded", "failed"]).optional(),
+    cursor: z.string().max(200).optional(),
+    limit: Limit.optional(),
+});
+export const SourceRunGetInput = z.strictObject({ sourceId: SourceId, runId: RunId });
+export const SourceRunCreateInput = z.strictObject({
+    sourceId: SourceId,
+    queryId: QueryId.describe("The query to fetch now (Play)."),
+});
+// Over REST the filter arrives as JSON text in the query string.
+const WhereList = z.preprocess((value) => {
+    if (typeof value !== "string")
+        return value;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        // Not JSON: a list of one, so the refusal names the condition, not the list.
+        return [value];
+    }
+}, z.array(SourceWhere).max(10));
+export const SourceItemListInput = z.strictObject({
+    sourceId: SourceId,
+    queryId: QueryId.optional().describe("Only the items of this query."),
+    since: z.iso
+        .datetime({ offset: true })
+        .optional()
+        .describe("Only items fetched at or after this moment. Colab remembers no reader: you say from when."),
+    cursor: z
+        .string()
+        .max(200)
+        .optional()
+        .describe("The nextCursor of an earlier page; it also works after the last page, for what came since."),
+    where: WhereList.optional().describe("Only items whose fields match every condition."),
+    limit: Limit.optional(),
+});
+// ---- Answers ----
+export const SourceStep = z.object({
+    name: z.string(),
+    status: z.enum(["succeeded", "failed"]),
+    durationMs: z.number().int(),
+    detail: z.string().nullable(),
+});
+export const SourceRunCounts = z.object({
+    fetched: z.number().int(),
+    new: z.number().int(),
+    withoutRef: z.number().int(),
+    duplicates: z.number().int(),
+    filtered: z.number().int(),
+    expired: z.number().int(),
+});
+// Why a run failed: `host` a request to a host the source does not name (sent nowhere), `access`
+// the provider refused the key (401, 403), `provider` it failed otherwise, `code` the source's code
+// or manifest broke.
+export const SourceRunFailure = z.enum(["host", "access", "provider", "code"]);
+export const SourceRun = z.object({
+    runId: RunId,
+    sourceId: SourceId,
+    queryId: QueryId,
+    // The workflow instance, `src-<source>-<query>-<time>`: one run per query and moment.
+    instance: z.string(),
+    // schedule, a person or machine by hand, or a probe against the draft.
+    trigger: z.enum(["schedule", "play"]),
+    by: NodePerson.nullable(),
+    version: z.number().int().nullable(),
+    status: z.enum(["running", "succeeded", "failed"]),
+    failure: SourceRunFailure.nullable(),
+    message: z.string().nullable(),
+    counts: SourceRunCounts,
+    steps: z.array(SourceStep),
+    startedAt: z.iso.datetime(),
+    endedAt: z.iso.datetime().nullable(),
+    durationMs: z.number().int().nullable(),
+});
+export const SourceRunList = z.object({
+    items: z.array(SourceRun),
+    nextCursor: z.string().nullable(),
+});
+export const SourceQuery = z.object({
+    queryId: QueryId,
+    sourceId: SourceId,
+    name: z.string(),
+    schedule: SourceSchedule,
+    params: z.record(z.string(), z.union([z.string(), z.number()])),
+    where: z.array(SourceWhere),
+    enabled: z.boolean(),
+    // Paused after the provider refused the key (401, 403), until a person sets it anew.
+    pausedAt: z.iso.datetime().nullable(),
+    archivedAt: z.iso.datetime().nullable(),
+    lastRun: z
+        .object({
+        runId: RunId,
+        status: z.enum(["running", "succeeded", "failed"]),
+        startedAt: z.iso.datetime(),
+        new: z.number().int(),
+    })
+        .nullable(),
+    nextRunAt: z.iso.datetime().nullable(),
+    rev: z.number().int(),
+});
+export const SourceQueryList = z.object({ items: z.array(SourceQuery) });
+export const SourceItem = z.object({
+    itemId: ItemId,
+    sourceId: SourceId,
+    queryId: QueryId,
+    ref: z.string(),
+    version: z.number().int().nullable(),
+    fetchedAt: z.iso.datetime(),
+    // New in the last run of its query.
+    fresh: z.boolean(),
+    fields: z.record(z.string(), z.union([z.string(), z.number(), z.array(z.string()), z.null()])),
+});
+export const SourceItemList = z.object({
+    items: z.array(SourceItem),
+    // ⚠️ Never null: the cursor after the last page is the one to ask again with for what comes next.
+    nextCursor: z.string(),
+    // Whether more pages stand already now.
+    more: z.boolean(),
+});
+// The items of a probe or a test, never stored.
+export const SourceProbe = z.object({
+    status: z.enum(["succeeded", "failed"]),
+    failure: SourceRunFailure.nullable(),
+    message: z.string().nullable(),
+    counts: SourceRunCounts,
+    items: z.array(z.object({ ref: z.string(), fields: SourceItem.shape.fields })),
+});
+export const SourceDetail = z.object({
+    sourceId: SourceId,
+    name: z.string(),
+    hidden: z.boolean(),
+    parentId: NodeId.nullable(),
+    path: NodePath,
+    version: z.union([z.number().int(), z.literal("draft")]).nullable(),
+    // Only for whoever may change the source; null for a reader and without a readable source.json.
+    manifest: SourceManifest.nullable(),
+    // The live fields as the items show them, for every reader: the columns of the view Treffer.
+    fields: z.array(z.object({ name: z.string(), label: z.string(), type: SourceFieldType })),
+    // A reader gets the fields and the queries' names, never the files.
+    files: z.array(GadgetFile),
+    queries: z.array(z.object({ queryId: QueryId, name: z.string() })),
+    live: z
+        .object({ version: z.number().int(), publishedAt: z.iso.datetime(), publishedBy: NodePerson })
+        .nullable(),
+    draft: z
+        .object({
+        updatedAt: z.iso.datetime(),
+        updatedBy: NodePerson,
+        changes: z.array(z.object({ path: z.string(), change: z.enum(["added", "changed", "removed"]) })),
+        // Hosts the draft reaches that live does not; the publish shows them.
+        newHosts: z.array(z.string()),
+        newFields: z.array(z.string()),
+    })
+        .nullable(),
+    test: GadgetTestRun.nullable(),
+    settings: z
+        .object({
+        responsible: NodePerson.nullable(),
+        level: GadgetLevel,
+        keepDays: z.number().int(),
+        logDays: z.number().int(),
+        // Names only, never values: which key is set and when. ⚠️ Not `secrets`: `/mcp` strikes every
+        // value under such a name.
+        credentials: z.array(z.object({ name: z.string(), label: z.string(), setAt: z.iso.datetime().nullable() })),
+    })
+        .nullable(),
+    pausedAt: z.iso.datetime().nullable(),
+    rights: z.object({ write: z.boolean() }),
+    rev: z.number().int(),
+    archivedAt: z.iso.datetime().nullable(),
+});
+// The door of a secret (`PUT /api/intelligence/sources/:sourceId/secrets`, no tool): a person in the
+// browser sets the key, never an AI (Nodes › Quelle › Einstellungen).
+export const SourceSecretsInput = z.strictObject({
+    values: z.record(SecretName, z.string().min(1).max(4000).nullable()),
+});

package/dist/tree-order/tree-order.d.ts

@@ -1,4 +1,4 @@
 import type { NodeKind } from "../nodes/nodes.js";
-export declare const treeKindOrder: readonly ["folder", "document", "table", "board", "gadget", "file", "skill", "goal"];
+export declare const treeKindOrder: readonly ["folder", "document", "table", "board", "gadget", "source", "file", "skill", "goal"];
 export declare function treeKindRank(kind: NodeKind): number;
 export declare function compareTreeNames(a: string, b: string): number;

package/dist/tree-order/tree-order.js

@@ -7,6 +7,7 @@ export const treeKindOrder = [
     "table",
     "board",
     "gadget",
+    "source",
     "file",
     "skill",
     "goal",

package/dist/validation/validation.d.ts

@@ -15,6 +15,7 @@ export declare const TicketSubject: z.ZodObject<{
         gadget: "gadget";
         goal: "goal";
         skill: "skill";
+        source: "source";
     }>;
     name: z.ZodString;
     path: z.ZodObject<{
@@ -42,6 +43,7 @@ export declare const TicketSubjectRef: z.ZodObject<{
         gadget: "gadget";
         goal: "goal";
         skill: "skill";
+        source: "source";
     }>;
     path: z.ZodObject<{
         section: z.ZodEnum<{

package/dist/versions/versions.d.ts

@@ -48,9 +48,9 @@ export declare const VersionMove: z.ZodObject<{
 export type VersionMove = z.infer<typeof VersionMove>;
 export declare const taskVersionChanges: readonly ["title", "text", "assignee", "dates", "labels", "parent", "dependencies", "waiting", "fields"];
 export declare const TaskVersionChange: z.ZodEnum<{
-    fields: "fields";
     title: "title";
     text: "text";
+    fields: "fields";
     dates: "dates";
     waiting: "waiting";
     assignee: "assignee";
@@ -164,9 +164,9 @@ export declare const NodeVersion: z.ZodObject<{
         comment: z.ZodNullable<z.ZodString>;
     }, z.core.$strip>>;
     changes: z.ZodNullable<z.ZodArray<z.ZodEnum<{
-        fields: "fields";
         title: "title";
         text: "text";
+        fields: "fields";
         dates: "dates";
         waiting: "waiting";
         assignee: "assignee";
@@ -225,9 +225,9 @@ export declare const NodeVersionList: z.ZodObject<{
             comment: z.ZodNullable<z.ZodString>;
         }, z.core.$strip>>;
         changes: z.ZodNullable<z.ZodArray<z.ZodEnum<{
-            fields: "fields";
             title: "title";
             text: "text";
+            fields: "fields";
             dates: "dates";
             waiting: "waiting";
             assignee: "assignee";
@@ -288,9 +288,9 @@ export declare const NodeVersionDetail: z.ZodObject<{
         comment: z.ZodNullable<z.ZodString>;
     }, z.core.$strip>>;
     changes: z.ZodNullable<z.ZodArray<z.ZodEnum<{
-        fields: "fields";
         title: "title";
         text: "text";
+        fields: "fields";
         dates: "dates";
         waiting: "waiting";
         assignee: "assignee";
@@ -439,9 +439,9 @@ export declare const NodeVersionExcerpt: z.ZodObject<{
         comment: z.ZodNullable<z.ZodString>;
     }, z.core.$strip>>;
     changes: z.ZodNullable<z.ZodArray<z.ZodEnum<{
-        fields: "fields";
         title: "title";
         text: "text";
+        fields: "fields";
         dates: "dates";
         waiting: "waiting";
         assignee: "assignee";

package/dist/written/written.d.ts

@@ -9,6 +9,8 @@ export declare const Changed: z.ZodObject<{
     gadgetId: z.ZodOptional<z.ZodTemplateLiteral<`node_${string}`>>;
     goalId: z.ZodOptional<z.ZodTemplateLiteral<`node_${string}`>>;
     skillId: z.ZodOptional<z.ZodTemplateLiteral<`node_${string}`>>;
+    sourceId: z.ZodOptional<z.ZodTemplateLiteral<`node_${string}`>>;
+    queryId: z.ZodOptional<z.ZodTemplateLiteral<`query_${string}`>>;
     runId: z.ZodOptional<z.ZodTemplateLiteral<`run_${string}`>>;
     messageId: z.ZodOptional<z.ZodTemplateLiteral<`message_${string}`>>;
     chatId: z.ZodOptional<z.ZodTemplateLiteral<`node_${string}`>>;
@@ -100,6 +102,8 @@ export declare const Written: z.ZodObject<{
         gadgetId: z.ZodOptional<z.ZodTemplateLiteral<`node_${string}`>>;
         goalId: z.ZodOptional<z.ZodTemplateLiteral<`node_${string}`>>;
         skillId: z.ZodOptional<z.ZodTemplateLiteral<`node_${string}`>>;
+        sourceId: z.ZodOptional<z.ZodTemplateLiteral<`node_${string}`>>;
+        queryId: z.ZodOptional<z.ZodTemplateLiteral<`query_${string}`>>;
         runId: z.ZodOptional<z.ZodTemplateLiteral<`run_${string}`>>;
         messageId: z.ZodOptional<z.ZodTemplateLiteral<`message_${string}`>>;
         chatId: z.ZodOptional<z.ZodTemplateLiteral<`node_${string}`>>;

package/dist/written/written.js

@@ -15,6 +15,7 @@ import { CredentialId } from "../operators/operators.js";
 import { RoleId } from "../roles/roles.js";
 import { RunId } from "../runs/runs.js";
 import { FunctionId, InterfaceId, ServiceId } from "../services/services.js";
+import { QueryId } from "../sources/sources.js";
 import { SsoId } from "../sso/sso.js";
 import { UserId } from "../users/users.js";
 // What a write answers over `/mcp` (E126, #672): what it changed and what that caused, never the
@@ -33,6 +34,8 @@ export const Changed = z.object({
     gadgetId: NodeId.optional(),
     goalId: NodeId.optional(),
     skillId: NodeId.optional(),
+    sourceId: NodeId.optional(),
+    queryId: QueryId.optional(),
     runId: RunId.optional(),
     messageId: MessageId.optional(),
     // A chat is its node's (#45).

package/package.json

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