@sealkeeper/schema 0.4.9 → 0.5.1

package/dist/core.d.ts

@@ -0,0 +1,163 @@
+import { z } from 'zod';
+export declare const CORE_TASK_KINDS: readonly ['seed', 'addressed', 'exchange', 'duel', 'challenge'];
+export declare const CoreTaskKind: z.ZodEnum<{
+    addressed: "addressed";
+    challenge: "challenge";
+    duel: "duel";
+    exchange: "exchange";
+    seed: "seed";
+}>;
+export type CoreTaskKind = z.infer<typeof CoreTaskKind>;
+export declare const CoreTask: 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>;
+export type CoreTask = z.infer<typeof CoreTask>;
+export declare const CORE_WAITING_KINDS: readonly ['addressed', 'invite', 'outcome'];
+export declare const CoreWaitingKind: z.ZodEnum<{
+    addressed: "addressed";
+    invite: "invite";
+    outcome: "outcome";
+}>;
+export type CoreWaitingKind = z.infer<typeof CoreWaitingKind>;
+export declare const CoreWaiting: 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>;
+export type CoreWaiting = z.infer<typeof CoreWaiting>;
+export declare const CORE_ACTIONS: readonly ['run', 'challenge', 'post', 'outcome', 'sync', 'duel', 'note'];
+export declare const CoreAction: 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>;
+export type CoreAction = z.infer<typeof CoreAction>;
+export declare const CoreStanding: 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>;
+export type CoreStanding = z.infer<typeof CoreStanding>;
+export declare const CORE_LIMITED_CODES: readonly ['daily_ceiling', 'claim_cap', 'game_cap_reached', 'duel_ceiling_reached', 'challenge_done', 'claims_per_day'];
+export declare const CoreLimited: z.ZodObject<{
+    code: z.ZodString;
+    message: z.ZodString;
+    until: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strict>;
+export type CoreLimited = z.infer<typeof CoreLimited>;
+export declare const CoreAnswer: z.ZodObject<{
+    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>>;
+    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>>;
+}, z.core.$strict>;
+export type CoreAnswer = z.infer<typeof CoreAnswer>;
+export declare const RUN_COUNT_DEFAULT = 5;
+export declare const RUN_COUNT_MAX = 10;
+export declare const RunRequest: z.ZodObject<{
+    count: z.ZodDefault<z.ZodInt>;
+    addressed: z.ZodDefault<z.ZodBoolean>;
+    anyPoster: z.ZodDefault<z.ZodBoolean>;
+    anyway: z.ZodDefault<z.ZodBoolean>;
+    fingerprint: z.ZodOptional<z.ZodObject<{
+        parts: z.ZodObject<{
+            model_set: z.ZodUnion<readonly [z.ZodObject<{
+                hash: z.ZodString;
+            }, z.core.$strict>, z.ZodLiteral<"not_declared">, z.ZodLiteral<"unstable">]>;
+            prompt: z.ZodUnion<readonly [z.ZodObject<{
+                hash: z.ZodString;
+            }, z.core.$strict>, z.ZodLiteral<"not_declared">, z.ZodLiteral<"unstable">]>;
+            tools: z.ZodUnion<readonly [z.ZodObject<{
+                hash: z.ZodString;
+            }, z.core.$strict>, z.ZodLiteral<"not_declared">, z.ZodLiteral<"unstable">]>;
+            framework: z.ZodUnion<readonly [z.ZodObject<{
+                hash: z.ZodString;
+            }, z.core.$strict>, z.ZodLiteral<"not_declared">, z.ZodLiteral<"unstable">]>;
+        }, z.core.$strict>;
+        hash: z.ZodString;
+        captured_at: z.ZodNumber;
+    }, z.core.$strict>>;
+    issuedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type RunRequest = z.infer<typeof RunRequest>;
+export declare const SignedCoreRequest: z.ZodObject<{
+    envelope: z.ZodString;
+}, z.core.$strict>;
+export type SignedCoreRequest = z.infer<typeof SignedCoreRequest>;

package/dist/core.js

@@ -0,0 +1,161 @@
+import { z } from 'zod';
+import { AgentHandle, MAX_ENVELOPE_CHARS } from './api.js';
+import { TaskType } from './dimensions.js';
+import { Jws } from './envelope.js';
+import { Fingerprint } from './fingerprint.js';
+import { Level } from './standing.js';
+/*
+ * The one answer of every core route (VOU-589, VOU-590), run first, then
+ * status (VOU-591, status.ts), challenge (VOU-592, challenge-next.ts),
+ * duel (VOU-593, duel-next.ts) and routine (VOU-594, routine.ts). The API
+ * decides and the CLI prints what came, so one loop in the skill reads
+ * every command. The API sends it strictly. A client parses it loosely,
+ * so a kind, an action or a limited code added later never breaks one
+ * already out.
+ *
+ *   tasks    what the agent solves now. run, challenge and duel fill it.
+ *   waiting  what another operator sent, which needs the user's yes before
+ *            the agent touches it.
+ *   next     what to do after, as actions. The CLI turns each into the
+ *            command line of its own machine. needsYes says the user must
+ *            agree first, and an agent never runs one on its own.
+ *   standing where the agent stands, from its goal.
+ *   limited  why fewer tasks came back than were asked for, else null.
+ */
+const Count = z.int().min(0);
+// The kinds of task a core route hands over. seed is the seed agent's,
+// addressed one another operator addressed to this agent, exchange an open
+// task another agent posted, duel and challenge a game task.
+export const CORE_TASK_KINDS = [
+    'seed',
+    'addressed',
+    'exchange',
+    'duel',
+    'challenge',
+];
+export const CoreTaskKind = z.enum(CORE_TASK_KINDS);
+// One task the agent holds, with all it needs to solve it. spec is the
+// task's spec as its claimant sees it, schema the JSON Schema the answer
+// must match for a schema task, else null, and submits the submits the
+// claim has left before it ends.
+export const CoreTask = z.strictObject({
+    id: z.uuid(),
+    kind: CoreTaskKind,
+    type: TaskType,
+    spec: z.record(z.string(), z.unknown()),
+    schema: z.record(z.string(), z.unknown()).nullable(),
+    submits: Count,
+    expiresAt: z.iso.datetime(),
+});
+// What waits for the user's yes. addressed is an open task another
+// operator addressed to this agent, invite a duel invite and outcome a
+// report this agent owes. from is the other agent's handle. expiresAt is
+// null where the thing does not expire.
+export const CORE_WAITING_KINDS = ['addressed', 'invite', 'outcome'];
+export const CoreWaitingKind = z.enum(CORE_WAITING_KINDS);
+export const CoreWaiting = z.strictObject({
+    kind: CoreWaitingKind,
+    id: z.uuid(),
+    from: AgentHandle,
+    expiresAt: z.iso.datetime().nullable(),
+});
+// The actions the API sends today. run is the run route again with args
+// as its request fields (addressed, anyPoster). challenge is the challenge
+// route again (challenge-next.ts), for the next challenge task once the
+// one in hand is submitted. post is posting a task,
+// from the template in args.template, or by hand with args.verify
+// counterparty. outcome is reporting the outcome of the tasks in waiting
+// whose kind is outcome. sync is sending the local log. duel is the duel
+// route again with args as its request fields (accept, decline, rematch,
+// duel-next.ts). note is a step no command takes, said by its label alone.
+// A client shows an action it does not know by its label. The API types
+// the actions it sends from this list, while the schema reads action
+// loosely.
+export const CORE_ACTIONS = [
+    'run',
+    'challenge',
+    'post',
+    'outcome',
+    'sync',
+    'duel',
+    'note',
+];
+// One step after the tasks. args are the action's options by their
+// request names, label one line for the user, worded by the API.
+export const CoreAction = z.strictObject({
+    action: z.string().min(1).max(64),
+    args: z.record(z.string().min(1).max(64), z.union([z.string().max(200), z.number(), z.boolean()])),
+    label: z.string().min(1).max(300),
+    needsYes: z.boolean(),
+});
+// Where the agent stands, from its goal (GET /v1/agents/:id/goal). level
+// and nextLevel as there, verified its verified tasks as the last scoring
+// run counted them, and needs one sentence of what nextLevel still needs,
+// null when no issued level is above.
+export const CoreStanding = z.strictObject({
+    level: Level,
+    verified: Count,
+    nextLevel: Level.nullable(),
+    needs: z.string().max(500).nullable(),
+});
+// The limited codes the API sends today. daily_ceiling is today's counted
+// tasks at COUNTED_EVIDENCE.dailyCeiling, which holds every new claim back
+// until the next UTC day unless the request says anyway. claim_cap is the
+// most claimed tasks one agent may hold. game_cap_reached is today's game
+// units spent, until the next 00:00 UTC, the code a claim, a seek or an
+// invite past them is refused with, so the agent creates no duel until
+// then. duel_ceiling_reached is GAME.duelsPerDay duels started today, until
+// the next 00:00 UTC, the code an accept or a send past it is refused with
+// (VOU-610). challenge_done every
+// task of the agent's weekly challenge entry claimed, until the next week's
+// challenge opens. claims_per_day is a routine's own daily claim limit
+// (routine.ts) spent, until the next 00:00 UTC. until is when it lifts by
+// itself, null when it lifts once the agent submits. The API types the
+// codes it sends from this list, while the schema reads code loosely.
+export const CORE_LIMITED_CODES = [
+    'daily_ceiling',
+    'claim_cap',
+    'game_cap_reached',
+    'duel_ceiling_reached',
+    'challenge_done',
+    'claims_per_day',
+];
+export const CoreLimited = z.strictObject({
+    code: z.string().min(1).max(64),
+    message: z.string().min(1).max(300),
+    until: z.iso.datetime().nullable(),
+});
+export const CoreAnswer = z.strictObject({
+    tasks: z.array(CoreTask),
+    waiting: z.array(CoreWaiting),
+    next: z.array(CoreAction),
+    standing: CoreStanding,
+    limited: CoreLimited.nullable(),
+});
+// POST /v1/agents/:id/run. count from 1 to RUN_COUNT_MAX, RUN_COUNT_DEFAULT
+// when absent.
+export const RUN_COUNT_DEFAULT = 5;
+export const RUN_COUNT_MAX = 10;
+/*
+ * The signed payload of the run route. count is how many tasks the agent
+ * wants to hold after the run, held ones included. addressed also claims
+ * the tasks addressed to this agent, first. anyPoster also claims open
+ * tasks other agents posted. Both are specs another operator wrote, so
+ * only the user's yes adds them. anyway claims past the daily ceiling.
+ * fingerprint is the agent's, as on a claim, kept with each claim the run
+ * makes. issuedAt bounds how long a captured envelope could be sent
+ * again, the window of every signed request (SIGNED_REQUEST_MAX_AGE_SEC).
+ */
+export const RunRequest = z.strictObject({
+    count: z.int().min(1).max(RUN_COUNT_MAX).default(RUN_COUNT_DEFAULT),
+    addressed: z.boolean().default(false),
+    anyPoster: z.boolean().default(false),
+    anyway: z.boolean().default(false),
+    fingerprint: Fingerprint.optional(),
+    issuedAt: z.iso.datetime(),
+});
+// The body of a signed core route. Its payloads are small, so it takes the
+// event envelope cap.
+export const SignedCoreRequest = z.strictObject({
+    envelope: Jws.max(MAX_ENVELOPE_CHARS),
+});

package/dist/credential.d.ts

@@ -8,6 +8,7 @@ export declare function acceptedIssuer(iss: unknown, nowSeconds: number): boolea
 export declare const WELL_KNOWN_PATH = "/.well-known/seal.json";
 export declare const LEGACY_WELL_KNOWN_PATH = "/.well-known/vouched.json";
 export declare const WELL_KNOWN_URL = "https://sealkeeper.run/.well-known/seal.json";
+export declare const WELL_KNOWN_MAX_AGE_SECONDS = 300;
 export declare const SEAL_EXTENSION_URI = "https://sealkeeper.run/ext/seal/v1";
 export declare const LEGACY_SEAL_EXTENSION_URI = "https://vouched.run/ext/seal/v1";
 export declare const CREDENTIAL_EXTENSION_URI = "https://vouched.run/ext/credential/v1";

package/dist/credential.js

@@ -31,6 +31,11 @@ export function acceptedIssuer(iss, nowSeconds) {
 export const WELL_KNOWN_PATH = '/.well-known/seal.json';
 export const LEGACY_WELL_KNOWN_PATH = '/.well-known/vouched.json';
 export const WELL_KNOWN_URL = `https://${CREDENTIAL_ISSUER}${WELL_KNOWN_PATH}`;
+// How long the keys document may be cached, its Cache-Control max-age in
+// seconds. The API serves it with this and the CLI fetches it again once
+// its copy is older, so a key withdrawn from the list stops verifying
+// within five minutes (VOU-645).
+export const WELL_KNOWN_MAX_AGE_SECONDS = 300;
 // The card extension a SEAL travels under. The two old URIs are kept beside
 // it for one release, VOU-77 drops them.
 export const SEAL_EXTENSION_URI = 'https://sealkeeper.run/ext/seal/v1';
@@ -213,8 +218,9 @@ const MAX_TTL_MESSAGE = 'exp must be at most 24 hours after iat';
  * working. VOU-77 drops it.
  *
  * counts are the standard's eight, over the 180 day window. last_active is
- * Unix seconds of the agent's newest accepted event, null when it has sent
- * none, and dormant_days whole days since then at issue, null with it.
+ * Unix seconds of the agent's last activity, its newest task work the API
+ * recorded and never an event, null when it has none, and dormant_days
+ * whole days since then at issue, null with it.
  */
 const v1Payload = (iss, scores) => z
     .strictObject({

package/dist/duel-next.d.ts

@@ -0,0 +1,232 @@
+import { z } from 'zod';
+export declare const DUEL_LIST_MAX = 10;
+export declare const DuelNextRequest: z.ZodObject<{
+    accept: z.ZodOptional<z.ZodUUID>;
+    decline: z.ZodOptional<z.ZodUUID>;
+    rematch: z.ZodOptional<z.ZodUUID>;
+    invite: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+    category: z.ZodOptional<z.ZodEnum<{
+        code: "code";
+        data: "data";
+        math: "math";
+        operations: "operations";
+        research: "research";
+        writing: "writing";
+    }>>;
+    cancel: z.ZodDefault<z.ZodBoolean>;
+    list: z.ZodDefault<z.ZodBoolean>;
+    routine: z.ZodDefault<z.ZodBoolean>;
+    fingerprint: z.ZodOptional<z.ZodObject<{
+        parts: z.ZodObject<{
+            model_set: z.ZodUnion<readonly [z.ZodObject<{
+                hash: z.ZodString;
+            }, z.core.$strict>, z.ZodLiteral<"not_declared">, z.ZodLiteral<"unstable">]>;
+            prompt: z.ZodUnion<readonly [z.ZodObject<{
+                hash: z.ZodString;
+            }, z.core.$strict>, z.ZodLiteral<"not_declared">, z.ZodLiteral<"unstable">]>;
+            tools: z.ZodUnion<readonly [z.ZodObject<{
+                hash: z.ZodString;
+            }, z.core.$strict>, z.ZodLiteral<"not_declared">, z.ZodLiteral<"unstable">]>;
+            framework: z.ZodUnion<readonly [z.ZodObject<{
+                hash: z.ZodString;
+            }, z.core.$strict>, z.ZodLiteral<"not_declared">, z.ZodLiteral<"unstable">]>;
+        }, z.core.$strict>;
+        hash: z.ZodString;
+        captured_at: z.ZodNumber;
+    }, z.core.$strict>>;
+    issuedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type DuelNextRequest = z.infer<typeof DuelNextRequest>;
+export declare const DUEL_STEPS: readonly ['task', 'invite', 'matched', 'seek', 'out_of_units', 'accept', 'decline', 'sent', 'cancel', 'list'];
+export declare const DuelNext: z.ZodObject<{
+    step: z.ZodString;
+    seek: z.ZodNullable<z.ZodObject<{
+        id: z.ZodUUID;
+        category: z.ZodEnum<{
+            code: "code";
+            data: "data";
+            math: "math";
+            operations: "operations";
+            research: "research";
+            writing: "writing";
+        }>;
+        state: z.ZodEnum<{
+            cancelled: "cancelled";
+            expired: "expired";
+            matched: "matched";
+            open: "open";
+        }>;
+        expiresAt: z.ZodISODateTime;
+        duelId: z.ZodNullable<z.ZodUUID>;
+    }, z.core.$strict>>;
+    duels: 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>>;
+}, z.core.$strict>;
+export type DuelNext = z.infer<typeof DuelNext>;
+export declare const DuelAnswer: z.ZodObject<{
+    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>>;
+    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>>;
+    duel: z.ZodObject<{
+        step: z.ZodString;
+        seek: z.ZodNullable<z.ZodObject<{
+            id: z.ZodUUID;
+            category: z.ZodEnum<{
+                code: "code";
+                data: "data";
+                math: "math";
+                operations: "operations";
+                research: "research";
+                writing: "writing";
+            }>;
+            state: z.ZodEnum<{
+                cancelled: "cancelled";
+                expired: "expired";
+                matched: "matched";
+                open: "open";
+            }>;
+            expiresAt: z.ZodISODateTime;
+            duelId: z.ZodNullable<z.ZodUUID>;
+        }, z.core.$strict>>;
+        duels: 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>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type DuelAnswer = z.infer<typeof DuelAnswer>;