@anchrd/colab-sdk 0.1.21 → 0.1.23

package/dist/skills/skills.d.ts

@@ -0,0 +1,437 @@
+import { z } from "zod";
+export declare const SkillId: z.ZodTemplateLiteral<`node_${string}`>;
+export type SkillId = z.infer<typeof SkillId>;
+export declare const skillFilePattern: RegExp;
+export declare const SkillFilePath: z.ZodString;
+export declare const SkillCreateInput: z.ZodObject<{
+    parentId: z.ZodNullable<z.ZodTemplateLiteral<`node_${string}`>>;
+    name: z.ZodString;
+    content: z.ZodString;
+    result: z.ZodOptional<z.ZodString>;
+    trigger: z.ZodOptional<z.ZodString>;
+    triggerOn: z.ZodOptional<z.ZodBoolean>;
+    idempotencyKey: z.ZodString;
+}, z.core.$strict>;
+export type SkillCreateInput = z.infer<typeof SkillCreateInput>;
+export declare const SkillGetInput: z.ZodObject<{
+    skillId: z.ZodTemplateLiteral<`node_${string}`>;
+    files: z.ZodOptional<z.ZodPreprocess<z.ZodBoolean, unknown>>;
+}, z.core.$strict>;
+export type SkillGetInput = z.infer<typeof SkillGetInput>;
+export declare const SkillUpdateInput: z.ZodObject<{
+    skillId: z.ZodTemplateLiteral<`node_${string}`>;
+    content: z.ZodOptional<z.ZodString>;
+    result: z.ZodOptional<z.ZodString>;
+    trigger: z.ZodOptional<z.ZodString>;
+    triggerOn: z.ZodOptional<z.ZodBoolean>;
+    files: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>>;
+    fromRun: z.ZodOptional<z.ZodTemplateLiteral<`run_${string}`>>;
+    rev: z.ZodNumber;
+    editSession: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type SkillUpdateInput = z.infer<typeof SkillUpdateInput>;
+export declare const SkillTestInput: z.ZodObject<{
+    skillId: z.ZodTemplateLiteral<`node_${string}`>;
+    record: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type SkillTestInput = z.infer<typeof SkillTestInput>;
+export declare const SkillRunListInput: z.ZodObject<{
+    skillId: z.ZodTemplateLiteral<`node_${string}`>;
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strict>;
+export type SkillRunListInput = z.infer<typeof SkillRunListInput>;
+export declare const SkillRunGetInput: z.ZodObject<{
+    skillId: z.ZodTemplateLiteral<`node_${string}`>;
+    runId: z.ZodTemplateLiteral<`run_${string}`>;
+}, z.core.$strict>;
+export type SkillRunGetInput = z.infer<typeof SkillRunGetInput>;
+export declare const SkillFile: z.ZodObject<{
+    path: z.ZodString;
+    content: z.ZodString;
+}, z.core.$strip>;
+export type SkillFile = z.infer<typeof SkillFile>;
+export declare const SkillPoint: z.ZodObject<{
+    text: z.ZodString;
+    kind: z.ZodEnum<{
+        expected: "expected";
+        result: "result";
+    }>;
+    ok: z.ZodBoolean;
+    reason: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type SkillPoint = z.infer<typeof SkillPoint>;
+export declare const skillCaseStatuses: readonly ["passed", "failed", "missing"];
+export declare const SkillCaseResult: z.ZodObject<{
+    name: z.ZodString;
+    status: z.ZodEnum<{
+        failed: "failed";
+        passed: "passed";
+        missing: "missing";
+    }>;
+    recordedAt: z.ZodNullable<z.ZodString>;
+    fromRun: z.ZodNullable<z.ZodString>;
+    runs: z.ZodInt;
+    passedRuns: z.ZodInt;
+    points: z.ZodArray<z.ZodObject<{
+        text: z.ZodString;
+        kind: z.ZodEnum<{
+            expected: "expected";
+            result: "result";
+        }>;
+        ok: z.ZodBoolean;
+        reason: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    missing: z.ZodNullable<z.ZodObject<{
+        tool: z.ZodString;
+        path: z.ZodString;
+    }, z.core.$strip>>;
+    sandbox: z.ZodArray<z.ZodObject<{
+        tool: z.ZodString;
+    }, z.core.$strip>>;
+    costUsd: z.ZodNumber;
+    runId: z.ZodNullable<z.ZodTemplateLiteral<`run_${string}`>>;
+}, z.core.$strip>;
+export type SkillCaseResult = z.infer<typeof SkillCaseResult>;
+export declare const SkillTriggerHit: z.ZodObject<{
+    kind: z.ZodEnum<{
+        should: "should";
+        shouldNot: "shouldNot";
+    }>;
+    request: z.ZodString;
+    chosen: z.ZodNullable<z.ZodString>;
+    ok: z.ZodBoolean;
+}, z.core.$strip>;
+export type SkillTriggerHit = z.infer<typeof SkillTriggerHit>;
+export declare const SkillTestReport: z.ZodObject<{
+    version: z.ZodInt;
+    at: z.ZodISODateTime;
+    by: z.ZodObject<{
+        userId: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        kind: z.ZodNullable<z.ZodEnum<{
+            machine: "machine";
+            human: "human";
+        }>>;
+    }, z.core.$strip>;
+    passed: z.ZodInt;
+    failed: z.ZodInt;
+    missing: z.ZodInt;
+    trigger: z.ZodNullable<z.ZodObject<{
+        skills: z.ZodInt;
+        operator: z.ZodNullable<z.ZodObject<{
+            userId: z.ZodString;
+            name: z.ZodNullable<z.ZodString>;
+            kind: z.ZodNullable<z.ZodEnum<{
+                machine: "machine";
+                human: "human";
+            }>>;
+        }, z.core.$strip>>;
+        hits: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                should: "should";
+                shouldNot: "shouldNot";
+            }>;
+            request: z.ZodString;
+            chosen: z.ZodNullable<z.ZodString>;
+            ok: z.ZodBoolean;
+        }, z.core.$strip>>;
+        costUsd: z.ZodNumber;
+    }, z.core.$strip>>;
+    cases: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        status: z.ZodEnum<{
+            failed: "failed";
+            passed: "passed";
+            missing: "missing";
+        }>;
+        recordedAt: z.ZodNullable<z.ZodString>;
+        fromRun: z.ZodNullable<z.ZodString>;
+        runs: z.ZodInt;
+        passedRuns: z.ZodInt;
+        points: z.ZodArray<z.ZodObject<{
+            text: z.ZodString;
+            kind: z.ZodEnum<{
+                expected: "expected";
+                result: "result";
+            }>;
+            ok: z.ZodBoolean;
+            reason: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        missing: z.ZodNullable<z.ZodObject<{
+            tool: z.ZodString;
+            path: z.ZodString;
+        }, z.core.$strip>>;
+        sandbox: z.ZodArray<z.ZodObject<{
+            tool: z.ZodString;
+        }, z.core.$strip>>;
+        costUsd: z.ZodNumber;
+        runId: z.ZodNullable<z.ZodTemplateLiteral<`run_${string}`>>;
+    }, z.core.$strip>>;
+    problem: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type SkillTestReport = z.infer<typeof SkillTestReport>;
+export declare const SkillDetail: z.ZodObject<{
+    skillId: z.ZodTemplateLiteral<`node_${string}`>;
+    name: z.ZodString;
+    hidden: z.ZodBoolean;
+    parentId: z.ZodNullable<z.ZodTemplateLiteral<`node_${string}`>>;
+    path: z.ZodObject<{
+        section: z.ZodEnum<{
+            users: "users";
+            own: "own";
+            shared: "shared";
+        }>;
+        items: z.ZodArray<z.ZodObject<{
+            nodeId: z.ZodTemplateLiteral<`node_${string}`>;
+            name: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    content: z.ZodString;
+    result: z.ZodString;
+    trigger: z.ZodString;
+    triggerOn: z.ZodBoolean;
+    version: z.ZodInt;
+    rev: z.ZodInt;
+    archivedAt: z.ZodNullable<z.ZodISODateTime>;
+    files: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        content: z.ZodString;
+    }, z.core.$strip>>>;
+    test: z.ZodNullable<z.ZodObject<{
+        version: z.ZodInt;
+        at: z.ZodISODateTime;
+        by: z.ZodObject<{
+            userId: z.ZodString;
+            name: z.ZodNullable<z.ZodString>;
+            kind: z.ZodNullable<z.ZodEnum<{
+                machine: "machine";
+                human: "human";
+            }>>;
+        }, z.core.$strip>;
+        passed: z.ZodInt;
+        failed: z.ZodInt;
+        missing: z.ZodInt;
+        trigger: z.ZodNullable<z.ZodObject<{
+            skills: z.ZodInt;
+            operator: z.ZodNullable<z.ZodObject<{
+                userId: z.ZodString;
+                name: z.ZodNullable<z.ZodString>;
+                kind: z.ZodNullable<z.ZodEnum<{
+                    machine: "machine";
+                    human: "human";
+                }>>;
+            }, z.core.$strip>>;
+            hits: z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    should: "should";
+                    shouldNot: "shouldNot";
+                }>;
+                request: z.ZodString;
+                chosen: z.ZodNullable<z.ZodString>;
+                ok: z.ZodBoolean;
+            }, z.core.$strip>>;
+            costUsd: z.ZodNumber;
+        }, z.core.$strip>>;
+        cases: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            status: z.ZodEnum<{
+                failed: "failed";
+                passed: "passed";
+                missing: "missing";
+            }>;
+            recordedAt: z.ZodNullable<z.ZodString>;
+            fromRun: z.ZodNullable<z.ZodString>;
+            runs: z.ZodInt;
+            passedRuns: z.ZodInt;
+            points: z.ZodArray<z.ZodObject<{
+                text: z.ZodString;
+                kind: z.ZodEnum<{
+                    expected: "expected";
+                    result: "result";
+                }>;
+                ok: z.ZodBoolean;
+                reason: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>>;
+            missing: z.ZodNullable<z.ZodObject<{
+                tool: z.ZodString;
+                path: z.ZodString;
+            }, z.core.$strip>>;
+            sandbox: z.ZodArray<z.ZodObject<{
+                tool: z.ZodString;
+            }, z.core.$strip>>;
+            costUsd: z.ZodNumber;
+            runId: z.ZodNullable<z.ZodTemplateLiteral<`run_${string}`>>;
+        }, z.core.$strip>>;
+        problem: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    rights: z.ZodObject<{
+        write: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type SkillDetail = z.infer<typeof SkillDetail>;
+export declare const skillRunKinds: readonly ["operator", "person", "probe"];
+export declare const skillRunStatuses: readonly ["open", "reached", "missed", "passed", "failed", "missing"];
+export declare const SkillRunItem: z.ZodObject<{
+    runId: z.ZodTemplateLiteral<`run_${string}`>;
+    skillId: z.ZodTemplateLiteral<`node_${string}`>;
+    kind: z.ZodEnum<{
+        operator: "operator";
+        person: "person";
+        probe: "probe";
+    }>;
+    by: z.ZodObject<{
+        userId: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        kind: z.ZodNullable<z.ZodEnum<{
+            machine: "machine";
+            human: "human";
+        }>>;
+    }, z.core.$strip>;
+    via: z.ZodNullable<z.ZodString>;
+    context: z.ZodObject<{
+        kind: z.ZodEnum<{
+            goal: "goal";
+            chat: "chat";
+            tests: "tests";
+        }>;
+        nodeId: z.ZodNullable<z.ZodTemplateLiteral<`node_${string}`>>;
+        name: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    version: z.ZodInt;
+    status: z.ZodEnum<{
+        open: "open";
+        failed: "failed";
+        passed: "passed";
+        reached: "reached";
+        missing: "missing";
+        missed: "missed";
+    }>;
+    startedAt: z.ZodISODateTime;
+    calls: z.ZodInt;
+    caseName: z.ZodNullable<z.ZodString>;
+    kept: z.ZodBoolean;
+}, z.core.$strip>;
+export type SkillRunItem = z.infer<typeof SkillRunItem>;
+export declare const SkillRunCall: z.ZodObject<{
+    seq: z.ZodInt;
+    tool: z.ZodString;
+    write: z.ZodBoolean;
+    sandbox: z.ZodBoolean;
+    input: z.ZodUnknown;
+    answer: z.ZodUnknown;
+    size: z.ZodNullable<z.ZodInt>;
+    durationMs: z.ZodInt;
+    code: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type SkillRunCall = z.infer<typeof SkillRunCall>;
+export declare const SkillRunDetail: z.ZodObject<{
+    runId: z.ZodTemplateLiteral<`run_${string}`>;
+    skillId: z.ZodTemplateLiteral<`node_${string}`>;
+    kind: z.ZodEnum<{
+        operator: "operator";
+        person: "person";
+        probe: "probe";
+    }>;
+    by: z.ZodObject<{
+        userId: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        kind: z.ZodNullable<z.ZodEnum<{
+            machine: "machine";
+            human: "human";
+        }>>;
+    }, z.core.$strip>;
+    via: z.ZodNullable<z.ZodString>;
+    context: z.ZodObject<{
+        kind: z.ZodEnum<{
+            goal: "goal";
+            chat: "chat";
+            tests: "tests";
+        }>;
+        nodeId: z.ZodNullable<z.ZodTemplateLiteral<`node_${string}`>>;
+        name: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    version: z.ZodInt;
+    status: z.ZodEnum<{
+        open: "open";
+        failed: "failed";
+        passed: "passed";
+        reached: "reached";
+        missing: "missing";
+        missed: "missed";
+    }>;
+    startedAt: z.ZodISODateTime;
+    caseName: z.ZodNullable<z.ZodString>;
+    kept: z.ZodBoolean;
+    calls: z.ZodArray<z.ZodObject<{
+        seq: z.ZodInt;
+        tool: z.ZodString;
+        write: z.ZodBoolean;
+        sandbox: z.ZodBoolean;
+        input: z.ZodUnknown;
+        answer: z.ZodUnknown;
+        size: z.ZodNullable<z.ZodInt>;
+        durationMs: z.ZodInt;
+        code: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    note: z.ZodNullable<z.ZodString>;
+    expiresAt: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strip>;
+export type SkillRunDetail = z.infer<typeof SkillRunDetail>;
+export declare const SkillRunList: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        runId: z.ZodTemplateLiteral<`run_${string}`>;
+        skillId: z.ZodTemplateLiteral<`node_${string}`>;
+        kind: z.ZodEnum<{
+            operator: "operator";
+            person: "person";
+            probe: "probe";
+        }>;
+        by: z.ZodObject<{
+            userId: z.ZodString;
+            name: z.ZodNullable<z.ZodString>;
+            kind: z.ZodNullable<z.ZodEnum<{
+                machine: "machine";
+                human: "human";
+            }>>;
+        }, z.core.$strip>;
+        via: z.ZodNullable<z.ZodString>;
+        context: z.ZodObject<{
+            kind: z.ZodEnum<{
+                goal: "goal";
+                chat: "chat";
+                tests: "tests";
+            }>;
+            nodeId: z.ZodNullable<z.ZodTemplateLiteral<`node_${string}`>>;
+            name: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+        version: z.ZodInt;
+        status: z.ZodEnum<{
+            open: "open";
+            failed: "failed";
+            passed: "passed";
+            reached: "reached";
+            missing: "missing";
+            missed: "missed";
+        }>;
+        startedAt: z.ZodISODateTime;
+        calls: z.ZodInt;
+        caseName: z.ZodNullable<z.ZodString>;
+        kept: z.ZodBoolean;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type SkillRunList = z.infer<typeof SkillRunList>;
+export declare const SkillFields: z.ZodObject<{
+    result: z.ZodString;
+    trigger: z.ZodString;
+    triggerOn: z.ZodBoolean;
+    files: z.ZodRecord<z.ZodString, z.ZodString>;
+}, z.core.$strip>;
+export type SkillFields = z.infer<typeof SkillFields>;
+export declare const SkillOffer: z.ZodObject<{
+    skillId: z.ZodTemplateLiteral<`node_${string}`>;
+    name: z.ZodString;
+    trigger: z.ZodString;
+}, z.core.$strip>;
+export type SkillOffer = z.infer<typeof SkillOffer>;

package/dist/skills/skills.js

@@ -0,0 +1,240 @@
+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"];
+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 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(),
+    })
+        .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 = {