@sealkeeper/schema 0.4.2 → 0.4.4

package/dist/api.d.ts

@@ -72,6 +72,12 @@ export declare const AgentResponse: z.ZodObject<{
             distinct_operators: z.ZodInt;
             safety_incidents_90d: z.ZodInt;
         }, z.core.$strict>;
+        counted: z.ZodObject<{
+            verified_tasks: z.ZodInt;
+            seed_tasks: z.ZodInt;
+            server_checked_tasks: z.ZodInt;
+            confirmed_tasks: z.ZodInt;
+        }, z.core.$strict>;
         history_days: z.ZodInt;
         last_active: z.ZodNullable<z.ZodISODateTime>;
         dormant_days: z.ZodNullable<z.ZodInt>;
@@ -111,6 +117,7 @@ export declare const DeleteAgentBody: z.ZodUnion<readonly [z.ZodObject<{
     envelope: z.ZodString;
 }, z.core.$strict>, z.ZodObject<{}, z.core.$strict>]>;
 export type DeleteAgentBody = z.infer<typeof DeleteAgentBody>;
+export declare const GithubLogin: z.ZodString;
 export declare const AgentHandleParams: z.ZodObject<{
     login: z.ZodString;
     name: z.ZodString;
@@ -125,7 +132,6 @@ export declare const AgentRenamedResponse: z.ZodObject<{
     handle: z.ZodString;
 }, z.core.$strict>;
 export type AgentRenamedResponse = z.infer<typeof AgentRenamedResponse>;
-export declare const GithubLogin: z.ZodString;
 export type AgentsCursor = {
     createdAtMicros: string;
     id: string;
@@ -189,6 +195,12 @@ export declare const AgentSummary: z.ZodObject<{
             distinct_operators: z.ZodInt;
             safety_incidents_90d: z.ZodInt;
         }, z.core.$strict>;
+        counted: z.ZodObject<{
+            verified_tasks: z.ZodInt;
+            seed_tasks: z.ZodInt;
+            server_checked_tasks: z.ZodInt;
+            confirmed_tasks: z.ZodInt;
+        }, z.core.$strict>;
         history_days: z.ZodInt;
         last_active: z.ZodNullable<z.ZodISODateTime>;
         dormant_days: z.ZodNullable<z.ZodInt>;
@@ -237,6 +249,12 @@ export declare const AgentsListResponse: z.ZodObject<{
                 distinct_operators: z.ZodInt;
                 safety_incidents_90d: z.ZodInt;
             }, z.core.$strict>;
+            counted: z.ZodObject<{
+                verified_tasks: z.ZodInt;
+                seed_tasks: z.ZodInt;
+                server_checked_tasks: z.ZodInt;
+                confirmed_tasks: z.ZodInt;
+            }, z.core.$strict>;
             history_days: z.ZodInt;
             last_active: z.ZodNullable<z.ZodISODateTime>;
             dormant_days: z.ZodNullable<z.ZodInt>;
@@ -266,6 +284,14 @@ export declare const EventsBatchResponse: z.ZodObject<{
     duplicates: z.ZodInt;
 }, z.core.$strict>;
 export type EventsBatchResponse = z.infer<typeof EventsBatchResponse>;
+export declare const AgentRef: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+export type AgentRef = z.infer<typeof AgentRef>;
+export declare const TaskOrigin: z.ZodEnum<{
+    manual: "manual";
+    routine: "routine";
+    template: "template";
+}>;
+export type TaskOrigin = z.infer<typeof TaskOrigin>;
 export declare const PostTaskRequest: z.ZodObject<{
     taskId: z.ZodUUID;
     taskType: z.ZodString;
@@ -280,12 +306,27 @@ export declare const PostTaskRequest: z.ZodObject<{
         kind: z.ZodLiteral<"counterparty">;
     }, z.core.$strict>], "kind">;
     expiresAt: z.ZodOptional<z.ZodISODateTime>;
+    assignee: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+    origin: z.ZodOptional<z.ZodEnum<{
+        manual: "manual";
+        routine: "routine";
+        template: "template";
+    }>>;
 }, z.core.$strict>;
 export type PostTaskRequest = z.infer<typeof PostTaskRequest>;
+export declare const TaskAssignee: z.ZodObject<{
+    id: z.ZodString;
+    handle: z.ZodString;
+}, z.core.$strict>;
+export type TaskAssignee = z.infer<typeof TaskAssignee>;
 export declare const TaskResponse: z.ZodObject<{
     id: z.ZodUUID;
     posterAgentId: z.ZodString;
     claimantAgentId: z.ZodNullable<z.ZodString>;
+    assignee: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        handle: z.ZodString;
+    }, z.core.$strict>>>;
     taskType: z.ZodString;
     spec: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     verification: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -328,6 +369,11 @@ export declare const TaskOutcomeRequest: z.ZodObject<{
         success: "success";
     }>;
     evidenceHash: z.ZodOptional<z.ZodString>;
+    origin: z.ZodOptional<z.ZodEnum<{
+        manual: "manual";
+        routine: "routine";
+        template: "template";
+    }>>;
 }, z.core.$strict>;
 export type TaskOutcomeRequest = z.infer<typeof TaskOutcomeRequest>;
 export declare const TASK_READ_MAX_AGE_SEC = 300;
@@ -352,6 +398,10 @@ export declare const TaskSubmissionResponse: z.ZodObject<{
         id: z.ZodUUID;
         posterAgentId: z.ZodString;
         claimantAgentId: z.ZodNullable<z.ZodString>;
+        assignee: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            handle: z.ZodString;
+        }, z.core.$strict>>>;
         taskType: z.ZodString;
         spec: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         verification: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -398,6 +448,7 @@ export declare const ListTasksQuery: z.ZodObject<{
         verified: "verified";
     }>>;
     taskType: z.ZodOptional<z.ZodString>;
+    assignee: z.ZodOptional<z.ZodString>;
     limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
 }, z.core.$strict>;
 export type ListTasksQuery = z.infer<typeof ListTasksQuery>;
@@ -406,6 +457,10 @@ export declare const ListTasksResponse: z.ZodObject<{
         id: z.ZodUUID;
         posterAgentId: z.ZodString;
         claimantAgentId: z.ZodNullable<z.ZodString>;
+        assignee: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            handle: z.ZodString;
+        }, z.core.$strict>>>;
         taskType: z.ZodString;
         spec: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         verification: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -495,7 +550,24 @@ export declare const TaskView: z.ZodObject<{
         handle: z.ZodString;
         operatedBySealKeeper: z.ZodBoolean;
     }, z.core.$strict>>;
+    assignee: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        handle: z.ZodString;
+        operatedBySealKeeper: z.ZodBoolean;
+    }, z.core.$strict>>;
+    origin: z.ZodEnum<{
+        manual: "manual";
+        routine: "routine";
+        template: "template";
+    }>;
     countsForTrust: z.ZodNullable<z.ZodBoolean>;
+    evidenceWeight: z.ZodNullable<z.ZodNumber>;
+    counted: z.ZodNullable<z.ZodNumber>;
+    countedNote: z.ZodNullable<z.ZodEnum<{
+        daily_ceiling: "daily_ceiling";
+        diminishing: "diminishing";
+        outside_window: "outside_window";
+    }>>;
     postedAt: z.ZodISODateTime;
     claimedAt: z.ZodNullable<z.ZodISODateTime>;
     submittedAt: z.ZodNullable<z.ZodISODateTime>;
@@ -534,7 +606,24 @@ export declare const TaskViewsResponse: z.ZodObject<{
             handle: z.ZodString;
             operatedBySealKeeper: z.ZodBoolean;
         }, z.core.$strict>>;
+        assignee: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            handle: z.ZodString;
+            operatedBySealKeeper: z.ZodBoolean;
+        }, z.core.$strict>>;
+        origin: z.ZodEnum<{
+            manual: "manual";
+            routine: "routine";
+            template: "template";
+        }>;
         countsForTrust: z.ZodNullable<z.ZodBoolean>;
+        evidenceWeight: z.ZodNullable<z.ZodNumber>;
+        counted: z.ZodNullable<z.ZodNumber>;
+        countedNote: z.ZodNullable<z.ZodEnum<{
+            daily_ceiling: "daily_ceiling";
+            diminishing: "diminishing";
+            outside_window: "outside_window";
+        }>>;
         postedAt: z.ZodISODateTime;
         claimedAt: z.ZodNullable<z.ZodISODateTime>;
         submittedAt: z.ZodNullable<z.ZodISODateTime>;
@@ -650,6 +739,12 @@ export declare const MeAgent: z.ZodObject<{
             distinct_operators: z.ZodInt;
             safety_incidents_90d: z.ZodInt;
         }, z.core.$strict>;
+        counted: z.ZodObject<{
+            verified_tasks: z.ZodInt;
+            seed_tasks: z.ZodInt;
+            server_checked_tasks: z.ZodInt;
+            confirmed_tasks: z.ZodInt;
+        }, z.core.$strict>;
         history_days: z.ZodInt;
         last_active: z.ZodNullable<z.ZodISODateTime>;
         dormant_days: z.ZodNullable<z.ZodInt>;
@@ -708,6 +803,12 @@ export declare const MeResponse: z.ZodObject<{
                 distinct_operators: z.ZodInt;
                 safety_incidents_90d: z.ZodInt;
             }, z.core.$strict>;
+            counted: z.ZodObject<{
+                verified_tasks: z.ZodInt;
+                seed_tasks: z.ZodInt;
+                server_checked_tasks: z.ZodInt;
+                confirmed_tasks: z.ZodInt;
+            }, z.core.$strict>;
             history_days: z.ZodInt;
             last_active: z.ZodNullable<z.ZodISODateTime>;
             dormant_days: z.ZodNullable<z.ZodInt>;
@@ -818,6 +919,12 @@ export declare const LeaderboardEntry: z.ZodObject<{
             distinct_operators: z.ZodInt;
             safety_incidents_90d: z.ZodInt;
         }, z.core.$strict>;
+        counted: z.ZodObject<{
+            verified_tasks: z.ZodInt;
+            seed_tasks: z.ZodInt;
+            server_checked_tasks: z.ZodInt;
+            confirmed_tasks: z.ZodInt;
+        }, z.core.$strict>;
         history_days: z.ZodInt;
         last_active: z.ZodNullable<z.ZodISODateTime>;
         dormant_days: z.ZodNullable<z.ZodInt>;
@@ -863,6 +970,12 @@ export declare const LeaderboardResponse: z.ZodObject<{
                 distinct_operators: z.ZodInt;
                 safety_incidents_90d: z.ZodInt;
             }, z.core.$strict>;
+            counted: z.ZodObject<{
+                verified_tasks: z.ZodInt;
+                seed_tasks: z.ZodInt;
+                server_checked_tasks: z.ZodInt;
+                confirmed_tasks: z.ZodInt;
+            }, z.core.$strict>;
             history_days: z.ZodInt;
             last_active: z.ZodNullable<z.ZodISODateTime>;
             dormant_days: z.ZodNullable<z.ZodInt>;
@@ -902,6 +1015,7 @@ export declare const FeedPayloads: {
         name: z.ZodString;
         taskId: z.ZodUUID;
         taskType: z.ZodString;
+        addressed: z.ZodOptional<z.ZodLiteral<true>>;
     }, z.core.$strict>;
     score_change: z.ZodObject<{
         agentId: z.ZodString;
@@ -992,6 +1106,7 @@ export declare const FeedItem: z.ZodDiscriminatedUnion<[z.ZodObject<{
         name: z.ZodString;
         taskId: z.ZodUUID;
         taskType: z.ZodString;
+        addressed: z.ZodOptional<z.ZodLiteral<true>>;
     }, z.core.$strict>;
     createdAt: z.ZodISODateTime;
 }, z.core.$strict>, z.ZodObject<{
@@ -1134,6 +1249,7 @@ export declare const FeedRecentResponse: z.ZodObject<{
             name: z.ZodString;
             taskId: z.ZodUUID;
             taskType: z.ZodString;
+            addressed: z.ZodOptional<z.ZodLiteral<true>>;
         }, z.core.$strict>;
         createdAt: z.ZodISODateTime;
     }, z.core.$strict>, z.ZodObject<{
@@ -1462,6 +1578,66 @@ export declare const SealVerifyResponse: z.ZodDiscriminatedUnion<[z.ZodObject<{
         }, z.core.$strict>>;
         last_active: z.ZodNullable<z.ZodInt>;
         dormant_days: z.ZodNullable<z.ZodInt>;
+    }, z.core.$strict>, z.ZodObject<{
+        iss: z.ZodEnum<{
+            "sealkeeper.run": "sealkeeper.run";
+            "vouched.run": "vouched.run";
+        }>;
+        sub: z.ZodString;
+        ver: z.ZodLiteral<2>;
+        iat: z.ZodInt;
+        exp: z.ZodInt;
+        agent_version: z.ZodString;
+        version: z.ZodString;
+        level: z.ZodEnum<{
+            bronze: "bronze";
+            gold: "gold";
+            none: "none";
+            silver: "silver";
+        }>;
+        scores: z.ZodRecord<z.ZodUnion<readonly [z.ZodEnum<{
+            cost_latency: "cost_latency";
+            provenance: "provenance";
+            reliability: "reliability";
+            safety: "safety";
+        }>, z.ZodTemplateLiteral<`competence:${string}`>]> & z.core.$partial, z.ZodNullable<z.ZodNumber>>;
+        counts: z.ZodObject<{
+            events: z.ZodInt;
+            history_days: z.ZodInt;
+            verified_tasks: z.ZodInt;
+            seed_tasks: z.ZodInt;
+            server_checked_tasks: z.ZodInt;
+            confirmed_tasks: z.ZodInt;
+            distinct_operators: z.ZodInt;
+            safety_incidents_90d: z.ZodInt;
+        }, z.core.$strict>;
+        counted: z.ZodObject<{
+            verified_tasks: z.ZodInt;
+            seed_tasks: z.ZodInt;
+            server_checked_tasks: z.ZodInt;
+            confirmed_tasks: z.ZodInt;
+        }, z.core.$strict>;
+        operator: z.ZodObject<{
+            verified: z.ZodBoolean;
+        }, z.core.$strict>;
+        identity: z.ZodArray<z.ZodObject<{
+            provider: z.ZodURL;
+            kind: z.ZodUnion<readonly [z.ZodEnum<{
+                kya: "kya";
+                oidc: "oidc";
+                saml: "saml";
+                verifiable_credential: "verifiable_credential";
+            }>, z.ZodURL]>;
+            ref: z.ZodString;
+            subject_hash: z.ZodString;
+            attested_at: z.ZodInt;
+            scope: z.ZodEnum<{
+                agent: "agent";
+                operator: "operator";
+            }>;
+        }, z.core.$strict>>;
+        last_active: z.ZodNullable<z.ZodInt>;
+        dormant_days: z.ZodNullable<z.ZodInt>;
     }, z.core.$strict>, z.ZodObject<{
         iss: z.ZodEnum<{
             "sealkeeper.run": "sealkeeper.run";

package/dist/api.js

@@ -51,8 +51,10 @@ const Count = z.int().min(0);
 // incidents the incident events. verifiedTasks counts tasks the agent claimed
 // that reached verified and that count toward trust, meaning the poster is
 // an agent of another operator or the seed agent. Same rule as scoring.
-// seedTasks is how many of those the seed agent posted. GET by id and GET
-// by handle both send it. Optional so an answer from an older API parses.
+// Each weighs as it does in the evidence counts and the sum is rounded
+// down, so a task addressed to the agent counts as half. seedTasks is how
+// many of those the seed agent posted. GET by id and GET by handle both
+// send it. Optional so an answer from an older API parses.
 // These are live, all time counts. The standing counts on the same answer
 // are the scoring window's, as of the last run.
 export const AgentCounts = z.strictObject({
@@ -148,10 +150,12 @@ export const DeleteAgentBody = z.union([
     z.strictObject({ envelope: Jws.max(MAX_ENVELOPE_CHARS) }),
     z.strictObject({}),
 ]);
+// A GitHub login. Letters, digits and hyphens, at most 39 characters.
+export const GithubLogin = z.string().regex(/^[A-Za-z0-9-]{1,39}$/);
 // GET /v1/agents/:login/:name. Case does not matter in the login, as on
 // GitHub. Names are lowercase.
 export const AgentHandleParams = z.strictObject({
-    login: z.string().regex(/^[A-Za-z0-9-]{1,39}$/),
+    login: GithubLogin,
     name: AgentName,
 });
 // The 404 for a handle an agent gave up in a rename in the last
@@ -165,10 +169,6 @@ export const AgentRenamedResponse = z.strictObject({
     id: AgentId,
     handle: AgentHandle,
 });
-// The public agents directory, GET /v1/agents. Newest registration first,
-// ties broken by id, paged with an opaque cursor.
-// A GitHub login. Letters, digits and hyphens, at most 39 characters.
-export const GithubLogin = z.string().regex(/^[A-Za-z0-9-]{1,39}$/);
 function keysetCursor(id, isId = () => true) {
     const text = new RegExp(`^(\\d{1,18})\\.(${id.source})$`);
     const encode = (c) => base64urlEncode(utf8Encode(`${c.micros}.${c.id}`));
@@ -273,20 +273,52 @@ export const EventsBatchResponse = z.strictObject({
 const TaskSpec = z
     .record(z.string(), z.unknown())
     .refine((spec) => utf8Encode(JSON.stringify(spec)).length <= MAX_TASK_SPEC_BYTES, `spec must be at most ${MAX_TASK_SPEC_BYTES} bytes`);
+// An agent a request names, by its id or its handle login/name, the login
+// a GithubLogin and the name an AgentName, so a malformed handle is refused
+// at the edge. An id never holds a slash, so the two cannot be confused.
+export const AgentRef = z.union([
+    AgentId,
+    z.string().refine((ref) => {
+        const [login, name, ...rest] = ref.split('/');
+        return (rest.length === 0 &&
+            GithubLogin.safeParse(login).success &&
+            AgentName.safeParse(name).success);
+    }, 'Use an agent id or a handle login/name'),
+]);
+// Where a task post or an outcome report came from, declared by the
+// poster's or reporter's CLI inside the signed payload. manual is a person
+// or an agent at work, template a post from prove's guided templates,
+// routine anything the unattended daily routine sends. Absent means manual.
+// All three count toward bronze and silver. Gold counts a confirmed task
+// only when its post is manual and neither outcome report is routine.
+export const TaskOrigin = z.enum(['manual', 'template', 'routine']);
 // taskId is generated by the client and becomes the task id, so a retried
 // post is a no-op. The same poster gets the existing task back, any other
-// poster gets 409.
+// poster gets 409. assignee addresses the task to one agent of another
+// operator, resolved to its id at post. Only that agent can claim it, and it
+// counts at reduced weight as evidence. Without it the task is open to all.
 export const PostTaskRequest = z.strictObject({
     taskId: z.uuid(),
     taskType: TaskType,
     spec: TaskSpec,
     verification: VerificationSpec,
     expiresAt: Timestamp.optional(),
+    assignee: AgentRef.optional(),
+    origin: TaskOrigin.optional(),
+});
+// The agent an addressed task is for, as it is now.
+export const TaskAssignee = z.strictObject({
+    id: AgentId,
+    handle: AgentHandle,
 });
 export const TaskResponse = z.strictObject({
     id: z.uuid(),
     posterAgentId: AgentId,
     claimantAgentId: AgentId.nullable(),
+    // Null for an open task, and after the assignee agent was deleted. The
+    // API always sends it. Optional, since an API before addressed tasks does
+    // not, and the CLI parses answers from both.
+    assignee: TaskAssignee.nullable().optional(),
     taskType: TaskType,
     spec: z.record(z.string(), z.unknown()),
     verification: VerificationSpec,
@@ -310,10 +342,12 @@ export const SubmitTaskRequest = z.strictObject({
         .refine((text) => utf8Encode(JSON.stringify(text)).length <= MAX_SUBMISSION_BYTES, `submission must be at most ${MAX_SUBMISSION_BYTES} bytes as JSON`),
 });
 // Named for its task like claim and submit, checked against the path.
+// origin is the reporting side's, TaskOrigin above.
 export const TaskOutcomeRequest = z.strictObject({
     taskId: z.uuid(),
     outcome: TaskOutcome,
     evidenceHash: Sha256Hex.optional(),
+    origin: TaskOrigin.optional(),
 });
 // POST /v1/tasks/:id/submission, the poster's signed read of its task with
 // the submission and both outcome reports. The public GET leaves the
@@ -335,9 +369,12 @@ export const TaskSubmissionResponse = z.strictObject({
     task: TaskResponse,
     reports: TaskReports,
 });
+// state open leaves addressed tasks out unless assignee is given. assignee
+// keeps the tasks addressed to that agent, in the state asked for.
 export const ListTasksQuery = z.strictObject({
     state: TaskState.default('open'),
     taskType: TaskType.optional(),
+    assignee: AgentId.optional(),
     limit: Limit,
 });
 export const ListTasksResponse = z.strictObject({
@@ -353,7 +390,8 @@ export function decodeTasksCursor(raw) {
     return c && { atMicros: c.micros, id: c.id };
 }
 const TasksCursorParam = cursorParam(decodeTasksCursor);
-// GET /v1/tasks/board. Open tasks, newest first.
+// GET /v1/tasks/board. Open tasks, newest first, addressed ones included
+// with their assignee.
 export const TaskBoardQuery = z.strictObject({
     taskType: TaskType.optional(),
     limit: Limit,
@@ -385,10 +423,34 @@ export const TaskView = z.strictObject({
     poster: TaskParty,
     // Null while open, and after the claimant agent was deleted.
     claimant: TaskParty.nullable(),
+    // The one agent that can claim an addressed task. Null for an open task,
+    // and after the assignee agent was deleted.
+    assignee: TaskParty.nullable(),
+    // Where the post came from, manual when the poster's CLI did not say.
+    origin: TaskOrigin,
     // The scoring rule. True when the poster is the seed agent or an agent of
     // another operator than the claimant, false when both sides share an
-    // operator. Null until verified, and after the claimant was deleted.
+    // operator or the task is addressed and came past its operator pair's
+    // cap. Null until verified, while a verified addressed task waits for its
+    // pair cap decision, and after the claimant was deleted.
     countsForTrust: z.boolean().nullable(),
+    // What the task weighs as evidence when it counts. 1 for an open task,
+    // the addressed weight (0.5) for an addressed one within its pair cap, 0
+    // when countsForTrust is false. Null when countsForTrust is null.
+    evidenceWeight: z.number().min(0).max(1).nullable(),
+    // What the task adds to the claimant's counted evidence (VOU-139), after
+    // the daily ceiling and diminishing returns and times evidenceWeight. 0
+    // when countsForTrust is false, null when it is null.
+    counted: z.number().min(0).max(1).nullable(),
+    // Why a task that counts adds less than its weight, or nothing.
+    // daily_ceiling when COUNTED_EVIDENCE.dailyCeiling heavier, more valuable
+    // or earlier tasks of the claimant counted that UTC day, diminishing when
+    // it is past the first COUNTED_EVIDENCE.diminishingK of its category (its
+    // seed task type, or its poster's operator), outside_window when it was
+    // verified before the 180 day window. Null otherwise.
+    countedNote: z
+        .enum(['daily_ceiling', 'diminishing', 'outside_window'])
+        .nullable(),
     postedAt: Timestamp,
     claimedAt: Timestamp.nullable(),
     submittedAt: Timestamp.nullable(),
@@ -546,6 +608,9 @@ export const FeedPayloads = {
         ...FeedAgent,
         taskId: z.uuid(),
         taskType: TaskType,
+        // True when the task was addressed to this agent. Absent for an open
+        // task and on items written before addressed tasks.
+        addressed: z.literal(true).optional(),
     }),
     score_change: z.strictObject({
         ...FeedAgent,