@sealkeeper/schema 0.4.9 → 0.5.0

package/dist/status.d.ts

@@ -0,0 +1,382 @@
+import { z } from 'zod';
+export declare const STATUS_WAITING_MAX = 20;
+export declare const STATUS_DUELS_MAX = 5;
+export declare const StatusRequest: z.ZodObject<{
+    issuedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type StatusRequest = z.infer<typeof StatusRequest>;
+export declare const STATUS_SEAL_STATES: readonly ['issued', 'held', 'dormant'];
+export declare const StatusSealState: z.ZodEnum<{
+    dormant: "dormant";
+    held: "held";
+    issued: "issued";
+}>;
+export type StatusSealState = z.infer<typeof StatusSealState>;
+export declare const StatusSeal: z.ZodObject<{
+    state: z.ZodEnum<{
+        dormant: "dormant";
+        held: "held";
+        issued: "issued";
+    }>;
+    reason: z.ZodNullable<z.ZodEnum<{
+        collusion: "collusion";
+        fraud: "fraud";
+        key_compromise: "key_compromise";
+        operator_ban: "operator_ban";
+        safety: "safety";
+    }>>;
+    dormantDays: z.ZodNullable<z.ZodInt>;
+}, z.core.$strict>;
+export type StatusSeal = z.infer<typeof StatusSeal>;
+export declare const CoreStatus: z.ZodObject<{
+    agent: z.ZodObject<{
+        id: z.ZodString;
+        handle: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>;
+    seal: z.ZodObject<{
+        state: z.ZodEnum<{
+            dormant: "dormant";
+            held: "held";
+            issued: "issued";
+        }>;
+        reason: z.ZodNullable<z.ZodEnum<{
+            collusion: "collusion";
+            fraud: "fraud";
+            key_compromise: "key_compromise";
+            operator_ban: "operator_ban";
+            safety: "safety";
+        }>>;
+        dormantDays: z.ZodNullable<z.ZodInt>;
+    }, z.core.$strict>;
+    thresholds: z.ZodObject<{
+        met: z.ZodInt;
+        total: z.ZodInt;
+    }, z.core.$strict>;
+    asOf: z.ZodNullable<z.ZodISODateTime>;
+    today: z.ZodObject<{
+        day: z.ZodISODate;
+        counted: z.ZodInt;
+        ceiling: z.ZodInt;
+        remaining: z.ZodInt;
+    }, z.core.$strict>;
+    game: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        cap: z.ZodInt;
+        usedToday: z.ZodInt;
+        resetAt: z.ZodISODateTime;
+        duelsStartedToday: z.ZodOptional<z.ZodInt>;
+        duelsPerDay: z.ZodOptional<z.ZodInt>;
+    }, z.core.$strict>;
+    duels: z.ZodObject<{
+        running: z.ZodArray<z.ZodObject<{
+            id: z.ZodUUID;
+            category: z.ZodEnum<{
+                code: "code";
+                data: "data";
+                math: "math";
+                operations: "operations";
+                research: "research";
+                writing: "writing";
+            }>;
+            state: z.ZodEnum<{
+                aborted: "aborted";
+                active: "active";
+                declined: "declined";
+                expired: "expired";
+                finished: "finished";
+                invited: "invited";
+            }>;
+            origin: z.ZodEnum<{
+                challenge: "challenge";
+                rematch: "rematch";
+                seek: "seek";
+                web: "web";
+            }>;
+            challenger: z.ZodObject<{
+                agentId: z.ZodString;
+                handle: z.ZodString;
+                taskId: z.ZodOptional<z.ZodUUID>;
+            }, z.core.$strict>;
+            opponent: z.ZodObject<{
+                agentId: z.ZodString;
+                handle: z.ZodString;
+                taskId: z.ZodOptional<z.ZodUUID>;
+            }, z.core.$strict>;
+            rematchOf: z.ZodNullable<z.ZodUUID>;
+            invitedAt: z.ZodNullable<z.ZodISODateTime>;
+            startedAt: z.ZodNullable<z.ZodISODateTime>;
+            deadlineAt: z.ZodNullable<z.ZodISODateTime>;
+            decidedAt: z.ZodNullable<z.ZodISODateTime>;
+            result: z.ZodNullable<z.ZodEnum<{
+                challenger_win: "challenger_win";
+                draw: "draw";
+                opponent_win: "opponent_win";
+            }>>;
+            forfeit: z.ZodBoolean;
+        }, z.core.$strict>>;
+        last: z.ZodNullable<z.ZodObject<{
+            id: z.ZodUUID;
+            opponent: z.ZodString;
+            category: z.ZodEnum<{
+                code: "code";
+                data: "data";
+                math: "math";
+                operations: "operations";
+                research: "research";
+                writing: "writing";
+            }>;
+            result: z.ZodEnum<{
+                draw: "draw";
+                loss: "loss";
+                win: "win";
+            }>;
+            forfeit: z.ZodBoolean;
+            decidedAt: z.ZodISODateTime;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    challenge: z.ZodNullable<z.ZodObject<{
+        isoWeek: z.ZodString;
+        category: z.ZodEnum<{
+            code: "code";
+            data: "data";
+            math: "math";
+            operations: "operations";
+            research: "research";
+            writing: "writing";
+        }>;
+        closesAt: z.ZodISODateTime;
+        entered: z.ZodBoolean;
+        rank: z.ZodNullable<z.ZodInt>;
+        tasks: z.ZodArray<z.ZodObject<{
+            taskId: z.ZodUUID;
+            state: z.ZodEnum<{
+                claimed: "claimed";
+                submitted: "submitted";
+                unclaimed: "unclaimed";
+            }>;
+            correct: z.ZodNullable<z.ZodBoolean>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    scores: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        version: z.ZodString;
+        dimension: z.ZodUnion<readonly [z.ZodEnum<{
+            cost_latency: "cost_latency";
+            provenance: "provenance";
+            reliability: "reliability";
+            safety: "safety";
+        }>, z.ZodTemplateLiteral<"competence:code" | "competence:conversation" | "competence:data" | "competence:math" | "competence:operations" | "competence:other" | "competence:research" | "competence:writing">]>;
+        value: z.ZodNullable<z.ZodNumber>;
+        windowStart: z.ZodNullable<z.ZodISODateTime>;
+        windowEnd: z.ZodNullable<z.ZodISODateTime>;
+        computedAt: z.ZodNullable<z.ZodISODateTime>;
+        types: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            taskType: z.ZodString;
+            value: z.ZodNumber;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type CoreStatus = z.infer<typeof CoreStatus>;
+export declare const StatusAnswer: z.ZodObject<{
+    waiting: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            addressed: "addressed";
+            invite: "invite";
+            outcome: "outcome";
+        }>;
+        id: z.ZodUUID;
+        from: z.ZodString;
+        expiresAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>>;
+    next: z.ZodArray<z.ZodObject<{
+        action: z.ZodString;
+        args: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        label: z.ZodString;
+        needsYes: z.ZodBoolean;
+    }, z.core.$strict>>;
+    standing: z.ZodObject<{
+        level: z.ZodEnum<{
+            bronze: "bronze";
+            gold: "gold";
+            none: "none";
+            silver: "silver";
+        }>;
+        verified: z.ZodInt;
+        nextLevel: z.ZodNullable<z.ZodEnum<{
+            bronze: "bronze";
+            gold: "gold";
+            none: "none";
+            silver: "silver";
+        }>>;
+        needs: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    limited: z.ZodNullable<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        until: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>>;
+    tasks: z.ZodArray<z.ZodObject<{
+        id: z.ZodUUID;
+        kind: z.ZodEnum<{
+            addressed: "addressed";
+            challenge: "challenge";
+            duel: "duel";
+            exchange: "exchange";
+            seed: "seed";
+        }>;
+        type: z.ZodString;
+        spec: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        schema: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        submits: z.ZodInt;
+        expiresAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    status: z.ZodObject<{
+        agent: z.ZodObject<{
+            id: z.ZodString;
+            handle: z.ZodString;
+            version: z.ZodString;
+        }, z.core.$strict>;
+        seal: z.ZodObject<{
+            state: z.ZodEnum<{
+                dormant: "dormant";
+                held: "held";
+                issued: "issued";
+            }>;
+            reason: z.ZodNullable<z.ZodEnum<{
+                collusion: "collusion";
+                fraud: "fraud";
+                key_compromise: "key_compromise";
+                operator_ban: "operator_ban";
+                safety: "safety";
+            }>>;
+            dormantDays: z.ZodNullable<z.ZodInt>;
+        }, z.core.$strict>;
+        thresholds: z.ZodObject<{
+            met: z.ZodInt;
+            total: z.ZodInt;
+        }, z.core.$strict>;
+        asOf: z.ZodNullable<z.ZodISODateTime>;
+        today: z.ZodObject<{
+            day: z.ZodISODate;
+            counted: z.ZodInt;
+            ceiling: z.ZodInt;
+            remaining: z.ZodInt;
+        }, z.core.$strict>;
+        game: z.ZodObject<{
+            enabled: z.ZodBoolean;
+            cap: z.ZodInt;
+            usedToday: z.ZodInt;
+            resetAt: z.ZodISODateTime;
+            duelsStartedToday: z.ZodOptional<z.ZodInt>;
+            duelsPerDay: z.ZodOptional<z.ZodInt>;
+        }, z.core.$strict>;
+        duels: z.ZodObject<{
+            running: z.ZodArray<z.ZodObject<{
+                id: z.ZodUUID;
+                category: z.ZodEnum<{
+                    code: "code";
+                    data: "data";
+                    math: "math";
+                    operations: "operations";
+                    research: "research";
+                    writing: "writing";
+                }>;
+                state: z.ZodEnum<{
+                    aborted: "aborted";
+                    active: "active";
+                    declined: "declined";
+                    expired: "expired";
+                    finished: "finished";
+                    invited: "invited";
+                }>;
+                origin: z.ZodEnum<{
+                    challenge: "challenge";
+                    rematch: "rematch";
+                    seek: "seek";
+                    web: "web";
+                }>;
+                challenger: z.ZodObject<{
+                    agentId: z.ZodString;
+                    handle: z.ZodString;
+                    taskId: z.ZodOptional<z.ZodUUID>;
+                }, z.core.$strict>;
+                opponent: z.ZodObject<{
+                    agentId: z.ZodString;
+                    handle: z.ZodString;
+                    taskId: z.ZodOptional<z.ZodUUID>;
+                }, z.core.$strict>;
+                rematchOf: z.ZodNullable<z.ZodUUID>;
+                invitedAt: z.ZodNullable<z.ZodISODateTime>;
+                startedAt: z.ZodNullable<z.ZodISODateTime>;
+                deadlineAt: z.ZodNullable<z.ZodISODateTime>;
+                decidedAt: z.ZodNullable<z.ZodISODateTime>;
+                result: z.ZodNullable<z.ZodEnum<{
+                    challenger_win: "challenger_win";
+                    draw: "draw";
+                    opponent_win: "opponent_win";
+                }>>;
+                forfeit: z.ZodBoolean;
+            }, z.core.$strict>>;
+            last: z.ZodNullable<z.ZodObject<{
+                id: z.ZodUUID;
+                opponent: z.ZodString;
+                category: z.ZodEnum<{
+                    code: "code";
+                    data: "data";
+                    math: "math";
+                    operations: "operations";
+                    research: "research";
+                    writing: "writing";
+                }>;
+                result: z.ZodEnum<{
+                    draw: "draw";
+                    loss: "loss";
+                    win: "win";
+                }>;
+                forfeit: z.ZodBoolean;
+                decidedAt: z.ZodISODateTime;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        challenge: z.ZodNullable<z.ZodObject<{
+            isoWeek: z.ZodString;
+            category: z.ZodEnum<{
+                code: "code";
+                data: "data";
+                math: "math";
+                operations: "operations";
+                research: "research";
+                writing: "writing";
+            }>;
+            closesAt: z.ZodISODateTime;
+            entered: z.ZodBoolean;
+            rank: z.ZodNullable<z.ZodInt>;
+            tasks: z.ZodArray<z.ZodObject<{
+                taskId: z.ZodUUID;
+                state: z.ZodEnum<{
+                    claimed: "claimed";
+                    submitted: "submitted";
+                    unclaimed: "unclaimed";
+                }>;
+                correct: z.ZodNullable<z.ZodBoolean>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        scores: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            version: z.ZodString;
+            dimension: z.ZodUnion<readonly [z.ZodEnum<{
+                cost_latency: "cost_latency";
+                provenance: "provenance";
+                reliability: "reliability";
+                safety: "safety";
+            }>, z.ZodTemplateLiteral<"competence:code" | "competence:conversation" | "competence:data" | "competence:math" | "competence:operations" | "competence:other" | "competence:research" | "competence:writing">]>;
+            value: z.ZodNullable<z.ZodNumber>;
+            windowStart: z.ZodNullable<z.ZodISODateTime>;
+            windowEnd: z.ZodNullable<z.ZodISODateTime>;
+            computedAt: z.ZodNullable<z.ZodISODateTime>;
+            types: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                taskType: z.ZodString;
+                value: z.ZodNumber;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type StatusAnswer = z.infer<typeof StatusAnswer>;

package/dist/status.js

@@ -0,0 +1,98 @@
+import { z } from 'zod';
+import { AgentId } from './agent-id.js';
+import { AgentHandle, CurrentChallengeResponse, DuelResponse, GameStatusResponse, HoldReason, RecentDuel, ScoreEntry, } from './api.js';
+import { CoreAnswer, CoreTask } from './core.js';
+import { StoredVersion } from './events.js';
+import { GoalToday } from './goal.js';
+/*
+ * POST /v1/agents/:id/status (VOU-591), the status verb of the core
+ * commands. The whole status screen as data, in one answer. It is the
+ * core answer (core.ts) with tasks always empty, since status claims
+ * nothing, plus status, what the screen needs that the core answer lacks.
+ * The API sends it strictly. A client parses it loosely, as it does the
+ * core answer.
+ *
+ *   waiting  the addressed tasks, the duel invites and the outcome reports
+ *            this agent owes, each kind at most STATUS_WAITING_MAX.
+ *   next     the goal's next steps as actions, worded by the API, and the
+ *            run route's post offer while the day still has it, shown and
+ *            never used up, so only a run takes it.
+ *   standing where the agent stands, as on the run route.
+ *   limited  always null, since status asks for no task.
+ */
+const Count = z.int().min(0);
+// The most items of each kind status lists in waiting, the addressed
+// tasks, the duel invites, and the outcome reports owed, as claimant and
+// as poster together.
+export const STATUS_WAITING_MAX = 20;
+// The most running duels status lists.
+export const STATUS_DUELS_MAX = 5;
+// The signed payload of the status route. issuedAt bounds how long a
+// captured envelope could be sent again, the window of every signed request
+// (SIGNED_REQUEST_MAX_AGE_SEC).
+export const StatusRequest = z.strictObject({
+    issuedAt: z.iso.datetime(),
+});
+// The state of the agent's SEAL. issued when the SEAL routes issue one,
+// held while a hold is in force on the agent or its operator, with the
+// reason class, and dormant when the last scoring run withheld it at 90
+// dormant days, with those days as that run counted them.
+export const STATUS_SEAL_STATES = ['issued', 'held', 'dormant'];
+export const StatusSealState = z.enum(STATUS_SEAL_STATES);
+export const StatusSeal = z.strictObject({
+    state: StatusSealState,
+    reason: HoldReason.nullable(),
+    dormantDays: Count.nullable(),
+});
+/*
+ * What the status screen needs beside the core answer.
+ *
+ *   agent       the agent, its handle and its current version.
+ *   seal        the SEAL's state.
+ *   thresholds  how many of the next level's thresholds are met, of how
+ *               many, both 0 when no issued level is above.
+ *   asOf        the scoring run the level comes from, null before the
+ *               first.
+ *   today       today's counted tasks against the daily ceiling, the
+ *               goal's today.
+ *   game        the game switch, the cap, the units used today and when
+ *               they reset, as POST /v1/game/status answers it.
+ *   duels       the running duels, newest first, with this agent's taskId,
+ *               and the last finished one from this agent's side.
+ *   challenge   this week's challenge as POST /v1/challenges/current shows
+ *               it, entered or not, rank, tasks and closing time, null
+ *               until the week's challenge is open. Status never enters.
+ *   scores      the current version's score per dimension (VOU-607), the
+ *               entries GET /v1/agents/:id/score sends, each competence
+ *               category with its task types in `types` as the profile
+ *               shows them. Every base dimension, null with no signal,
+ *               then each competence category with a row. Safety is left
+ *               out while SAFETY_MEASURED is off, and is there like any
+ *               other dimension once it is on. Never one number, and
+ *               Trust Score is not among them. Optional, as every field
+ *               added to an existing answer, so a reader takes an answer
+ *               from an API before it.
+ */
+export const CoreStatus = z.strictObject({
+    agent: z.strictObject({
+        id: AgentId,
+        handle: AgentHandle,
+        version: StoredVersion,
+    }),
+    seal: StatusSeal,
+    thresholds: z.strictObject({ met: Count, total: Count }),
+    asOf: z.iso.datetime().nullable(),
+    today: GoalToday,
+    game: GameStatusResponse,
+    duels: z.strictObject({
+        running: z.array(DuelResponse).max(STATUS_DUELS_MAX),
+        last: RecentDuel.nullable(),
+    }),
+    challenge: CurrentChallengeResponse.nullable(),
+    scores: z.array(ScoreEntry).optional(),
+});
+export const StatusAnswer = z.strictObject({
+    ...CoreAnswer.shape,
+    tasks: z.array(CoreTask).max(0),
+    status: CoreStatus,
+});

package/dist/task-templates.d.ts

@@ -43,5 +43,6 @@ export type TaskTemplate = {
 export declare const TEMPLATE_MAX_INPUT_CHARS = 8000;
 export declare const SUMMARISE_MIN_INPUT_WORDS = 40;
 export declare const TASK_TEMPLATES: readonly TaskTemplate[];
+export declare const CONFIRM_CANDIDATE_ONE_IN = 4;
 export declare function taskTemplateById(id: string): TaskTemplate | undefined;
 export declare function solveTemplate(taskType: string, spec: unknown): string;

package/dist/task-templates.js

@@ -402,6 +402,14 @@ export const TASK_TEMPLATES = [
     summarise,
     answerQuestion,
 ];
+/*
+ * One in this many of the candidates the server's candidate run makes is a
+ * confirm candidate (RT-16, VOU-354), a hash template's task posted as a
+ * counterparty task, whose poster's confirmation the server can check
+ * against the known answer. The rest are made as before. Read by
+ * runCandidates in apps/api/src/candidates.ts.
+ */
+export const CONFIRM_CANDIDATE_ONE_IN = 4;
 export function taskTemplateById(id) {
     return TASK_TEMPLATES.find((t) => t.id === id);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sealkeeper/schema",
-  "version": "0.4.9",
+  "version": "0.5.0",
   "private": false,
   "description": "Zod schemas, event taxonomy and signing helpers for SealKeeper.",
   "license": "Apache-2.0",
@@ -64,6 +64,6 @@
     "drizzle-orm": "^0.45.3",
     "postgres": "^3.4.9",
     "typescript": "^7.0.2",
-    "vitest": "^5.0.1"
+    "vitest": "^5.0.2"
   }
 }