@capybara-hq/kernel 0.1.0-rc.6 → 0.1.0-rc.7

package/dist/conversations/events.js

@@ -1,6 +1,6 @@
 import { DOCUMENT_MEDIA_TYPES, hasControlChars, IMAGE_MEDIA_TYPES, isAttachmentId, isSkillName, MEDIA_NAME_MAX_CHARS, } from "@capybara-hq/plugin-sdk";
 import { z } from "zod";
-import { AgentDefinitionSchema, AgentToolRef, ModelRef } from "../agents/definition.js";
+import { AgentDefinitionSchema, DisabledToolRef, ModelRef } from "../agents/definition.js";
 import { ORG_ROLES } from "../orgs/roles.js";
 import { TOOL_VIEW_DIFF_MAX_LINES, TOOL_VIEW_LINE_MAX_CHARS, TOOL_VIEW_PATH_MAX_CHARS, } from "../tools/view.js";
 /** 供应商私有数据（`ProviderOpaque`）：原样保存、只回放给同一供应商。 */
@@ -176,6 +176,37 @@ const InputFormSchema = z.object({
 });
 /** 表单答案（plugin-sdk 的 `FormAnswer`）。 */
 const FormAnswerSchema = z.record(z.string(), z.union([z.string(), z.number(), z.boolean(), z.array(z.string())]));
+/** The languages a run context names (the org `locale` values). */
+export const RUN_CONTEXT_LOCALES = ["zh", "en"];
+/** `user_message.sender` (run context spec §3.2). */
+export const MessageSenderSchema = z.object({
+    name: z.string().min(1).max(80),
+    /** Absent = no membership. */
+    role: z.enum(ORG_ROLES).optional(),
+    /** An IM sender served as the org's anonymous guest; `name` is the IM profile name. */
+    anonymous: z.literal(true).optional(),
+});
+/** `run_context` (run context spec §3.1): every field optional, a later event holds changes only. */
+export const RunContextSchema = z.object({
+    /** The agent itself: its name and its versioned description collapsed to one line. */
+    agent: z
+        .object({ name: z.string().min(1).max(130), description: z.string().max(200).optional() })
+        .optional(),
+    org: z.object({ name: z.string().min(1).max(200) }).optional(),
+    /** Today in `timeZone`, `YYYY-MM-DD`. */
+    date: z
+        .string()
+        .regex(/^\d{4}-\d{2}-\d{2}$/)
+        .optional(),
+    /** IANA name. */
+    timeZone: z.string().min(1).max(64).optional(),
+    /** The language of the person whose message started the run. */
+    locale: z.enum(RUN_CONTEXT_LOCALES).optional(),
+    /** Sub-agents only: who dispatched this conversation. */
+    dispatchedBy: z
+        .object({ agent: z.string().min(1).max(130), person: z.string().min(1).max(80) })
+        .optional(),
+});
 const ev = (type, payload) => z.object({ type: z.literal(type), payload });
 /**
  * 会话事件（`type` + `payload`）的判别联合。事件日志只追加，写入前用它校验 payload；
@@ -193,6 +224,20 @@ export const ConversationEventSchema = z.discriminatedUnion("type", [
             .array(z.object({ appId: z.string(), appName: z.string(), uri: z.string(), name: z.string() }))
             .optional(),
         authorAccountId: z.string(),
+        /**
+         * Who wrote the message, at send time (run context spec §3.2): display name and org role
+         * only (never email or ids). Absent in older logs, on a sub-agent's task or `SendMessage`
+         * message. Model-visible only through the sender line, written when the sender changes
+         * (`senderLines`, runtime/context/run-context.ts).
+         */
+        sender: MessageSenderSchema.optional(),
+        /**
+         * The sender's time zone (IANA) and language at send time (run context spec §3.4): the
+         * account setting, else the browser's, else the org defaults. Not model-visible: the next
+         * run's `run_context` is derived from them.
+         */
+        timeZone: z.string().min(1).max(64).optional(),
+        locale: z.enum(RUN_CONTEXT_LOCALES).optional(),
         clientMessageId: z.string().optional(),
         /**
          * A retry after a failed run (UI refresh B): the seq of the message it repeats. Display only
@@ -232,13 +277,16 @@ export const ConversationEventSchema = z.discriminatedUnion("type", [
              */
             kind: z.enum(["task", "message"]).optional(),
             /**
-             * A follow-up (`resume`, final review I1): the frozen tools and org skills intersected
-             * with the current version (`narrowFollowUp`); the child's run uses these instead of
-             * the frozen ones. Absent on a first dispatch and in older logs.
+             * A follow-up (`resume`, final review I1): the frozen and the current version's
+             * turned-off tools together, and the frozen org skills intersected with the current
+             * ones (`narrowFollowUp`); the child's run uses these instead of the frozen ones.
+             * Absent on a first dispatch and in older logs; logs from before tools were on by
+             * default carry an enabled `tools` list instead of `disabledTools` (read as no tool
+             * narrowing).
              */
             narrowed: z
                 .object({
-                tools: z.array(AgentToolRef),
+                disabledTools: z.array(DisabledToolRef).optional(),
                 skills: z
                     .object({ orgSkills: z.array(z.string()), pinned: z.array(z.string()).optional() })
                     .optional(),
@@ -380,6 +428,13 @@ export const ConversationEventSchema = z.discriminatedUnion("type", [
         callId: z.string().optional(),
     })),
     ev("reminder", z.object({ step: count, text: z.string() })),
+    /**
+     * Who the agent is and the facts of the day (run context spec §3.1), written at run start
+     * (`RunContextService.record`): the conversation's first one holds every field that applies, a
+     * later one only the fields that changed. **Model-visible**: rendered at its position as a
+     * system message (`runContextText`); a summary covering it restores the current values.
+     */
+    ev("run_context", RunContextSchema),
     /**
      * The step's resolved tool set differs from the one the conversation's previous model request
      * offered (`toolSetChange`): tool names as the model sees them, sorted. Written before that

package/dist/conversations/message-context.d.ts

@@ -0,0 +1,28 @@
+import type { KernelSchemaDb } from "../db/kernel-schema.js";
+import type { EventPayload } from "./events.js";
+/** The name of an anonymous IM guest whose IM profile gives none. */
+export declare const ANONYMOUS_SENDER_NAME = "Anonymous guest";
+/** What the browser sent with a message (run context spec §3.4); both optional. */
+export interface BrowserContext {
+    timeZone?: string | undefined;
+    locale?: "zh" | "en" | undefined;
+}
+/** The `user_message` fields {@link readMessageContext} fills. */
+export type MessageContext = Pick<EventPayload<"user_message">, "sender" | "timeZone" | "locale">;
+/**
+ * Who wrote a message and in which time zone and language (run context spec §3.2, §3.4), read in
+ * the message's transaction (`t`):
+ * - `sender`: the account's display name and org role at send time; the org's anonymous guest
+ *   account (`org_anonymous_accounts`) is `{ name: <senderName, else "Anonymous guest">, role:
+ *   "guest", anonymous: true }`. Names are sanitised; an empty one leaves `sender` out.
+ * - `timeZone`: the account's setting, else the browser's (when valid), else the org default, else
+ *   UTC. The anonymous guest account has no setting of its own, so it gets the org default.
+ * - `locale`: the browser's UI language, else the org's `locale`.
+ */
+export declare function readMessageContext(t: KernelSchemaDb, input: {
+    orgId: string;
+    accountId: string;
+    /** An anonymous IM guest's IM profile name. */
+    senderName?: string | undefined;
+    browser?: BrowserContext | undefined;
+}): Promise<MessageContext>;

package/dist/conversations/message-context.js

@@ -0,0 +1,56 @@
+import { readOrgSettings } from "../orgs/settings.service.js";
+import { sanitizeSenderName } from "../runtime/context/run-context.js";
+import { isTimeZone } from "../time-zone.js";
+/** The name of an anonymous IM guest whose IM profile gives none. */
+export const ANONYMOUS_SENDER_NAME = "Anonymous guest";
+/**
+ * Who wrote a message and in which time zone and language (run context spec §3.2, §3.4), read in
+ * the message's transaction (`t`):
+ * - `sender`: the account's display name and org role at send time; the org's anonymous guest
+ *   account (`org_anonymous_accounts`) is `{ name: <senderName, else "Anonymous guest">, role:
+ *   "guest", anonymous: true }`. Names are sanitised; an empty one leaves `sender` out.
+ * - `timeZone`: the account's setting, else the browser's (when valid), else the org default, else
+ *   UTC. The anonymous guest account has no setting of its own, so it gets the org default.
+ * - `locale`: the browser's UI language, else the org's `locale`.
+ */
+export async function readMessageContext(t, input) {
+    const row = await t
+        .selectFrom("accounts")
+        .leftJoin("memberships", (j) => j
+        .onRef("memberships.account_id", "=", "accounts.id")
+        .on("memberships.org_id", "=", input.orgId))
+        .leftJoin("org_anonymous_accounts as anon", (j) => j.onRef("anon.account_id", "=", "accounts.id").on("anon.org_id", "=", input.orgId))
+        .select([
+        "accounts.display_name",
+        "accounts.time_zone",
+        "memberships.role",
+        "anon.account_id as anonymous",
+    ])
+        .where("accounts.id", "=", input.accountId)
+        .executeTakeFirst();
+    const org = await readOrgSettings(t, input.orgId);
+    const anonymous = row?.anonymous !== null && row?.anonymous !== undefined;
+    let sender;
+    if (row !== undefined) {
+        const name = anonymous
+            ? sanitizeSenderName(input.senderName ?? "") || ANONYMOUS_SENDER_NAME
+            : sanitizeSenderName(row.display_name);
+        if (name !== "") {
+            sender = anonymous
+                ? { name, role: "guest", anonymous: true }
+                : { name, ...(row.role !== null && { role: row.role }) };
+        }
+    }
+    const own = row?.time_zone ?? null;
+    const browser = input.browser?.timeZone;
+    const timeZone = own !== null && isTimeZone(own)
+        ? own
+        : browser !== undefined && isTimeZone(browser)
+            ? browser
+            : (org.timeZone ?? "UTC");
+    return {
+        ...(sender !== undefined && { sender }),
+        timeZone,
+        locale: input.browser?.locale ?? org.locale,
+    };
+}

package/dist/conversations/queue.d.ts

@@ -5,6 +5,7 @@ import { type InvocationRecord, type RenderedInvocation } from "../skills/invoke
 import type { AttachmentRef } from "./conversations.service.js";
 import { type AppendEvent, type EventLog } from "./event-log.js";
 import type { ConversationEvent, LogContentBlock } from "./events.js";
+import { type MessageContext } from "./message-context.js";
 /**
  * Queued messages (UI refresh B, spec §5.7): messages a person queued while a run was going. They
  * are conversation state in PG, not events: the model has not seen them, so they enter the log only
@@ -113,7 +114,7 @@ export declare function storedSkill(invokedAs: string, invoked: RenderedInvocati
     first: LogContentBlock;
 };
 /** The `user_message` a queued item becomes, as `postUserMessage` would have written it. */
-export declare function queuedUserMessage(r: QueueRow): AppendEvent;
+export declare function queuedUserMessage(r: QueueRow, context?: MessageContext): AppendEvent;
 /**
  * Appends a queued item inside `t` (the caller holds the conversation row lock): its pick, re-planned
  * against the selection in effect now, becomes a `model_switched` before the `user_message`, as a

package/dist/conversations/queue.js

@@ -4,6 +4,7 @@ import { ApiError } from "../errors.js";
 import { recordedSkillBlocked, } from "../skills/invoke.js";
 import { payloadJson } from "./event-log.js";
 import { userMessageIdemKey } from "./idem-keys.js";
+import { readMessageContext } from "./message-context.js";
 import { planSelection, readSelection } from "./selection.js";
 /**
  * Queued messages (UI refresh B, spec §5.7): messages a person queued while a run was going. They
@@ -77,7 +78,7 @@ export function storedSkill(invokedAs, invoked) {
     return { skill: payloadJson(skill), first: { type: "text", text: invoked.text } };
 }
 /** The `user_message` a queued item becomes, as `postUserMessage` would have written it. */
-export function queuedUserMessage(r) {
+export function queuedUserMessage(r, context = {}) {
     const attachments = r.attachments;
     const skill = r.skill;
     return {
@@ -91,6 +92,7 @@ export function queuedUserMessage(r) {
             ],
             ...(attachments.length > 0 && { attachments }),
             authorAccountId: r.account_id,
+            ...context,
             clientMessageId: r.client_message_id,
             ...(skill !== null && { skill: skill.record }),
         },
@@ -120,7 +122,14 @@ export async function appendQueuedIn(t, eventLog, conversationId, r) {
             payload: { ...next, byAccountId: r.account_id, reason: "user" },
         });
     }
-    events.push(queuedUserMessage(r));
+    // run context spec §3.4: no browser values were stored with a leftover row
+    const org = await t
+        .selectFrom("conversations")
+        .select("org_id")
+        .where("id", "=", conversationId)
+        .executeTakeFirstOrThrow();
+    const context = await readMessageContext(t, { orgId: org.org_id, accountId: r.account_id });
+    events.push(queuedUserMessage(r, context));
     const written = await eventLog.appendIn(conversationId, events);
     if (next !== null) {
         await t

package/dist/db/kernel-schema.d.ts

@@ -16,6 +16,25 @@ export interface AccountsTable {
     updated_at: Ts;
     /** 0064: the org the account last chose as current; a new session starts in it. */
     last_org_id: ColumnType<string | null, string | null | undefined, string | null>;
+    /** 0091: the person's time zone (IANA); null follows the browser (run context spec §3.4). */
+    time_zone: ColumnType<string | null, string | null | undefined, string | null>;
+    /** 0090: the account must set its own password first (a generated initial password). */
+    must_change_password: Generated<boolean>;
+}
+/**
+ * 0090: a generated initial password sealed for the person who approved the account's creation,
+ * read once on the web (Platform tool spec §14.5 item 2).
+ */
+export interface AccountInitialPasswordsTable {
+    account_id: string;
+    recipient_account_id: string;
+    conversation_id: string;
+    run_id: string;
+    call_id: string;
+    master_key_id: string;
+    ciphertext: Buffer;
+    expires_at: Date | string;
+    created_at: Ts;
 }
 export interface IdentitiesTable {
     source: string;
@@ -1036,6 +1055,7 @@ export interface ModelUsageTable {
 }
 export interface KernelDatabase {
     accounts: AccountsTable;
+    account_initial_passwords: AccountInitialPasswordsTable;
     identities: IdentitiesTable;
     local_passwords: LocalPasswordsTable;
     orgs: OrgsTable;

package/dist/environments/environments.schemas.d.ts

@@ -0,0 +1,3 @@
+import type { RouteSchemas } from "../platform/route-schemas.js";
+/** The environments routes the Platform operations mirror (`check:platform-ops` keys). */
+export declare const ENVIRONMENT_ROUTES: readonly RouteSchemas[];

package/dist/environments/environments.schemas.js

@@ -0,0 +1,14 @@
+import { EnvironmentNameBody, EnvironmentParams } from "./dto.js";
+/** The environments routes the Platform operations mirror (`check:platform-ops` keys). */
+export const ENVIRONMENT_ROUTES = [
+    { route: "GET /api/v1/orgs/:orgId/environments" },
+    { route: "POST /api/v1/orgs/:orgId/environments", body: EnvironmentNameBody },
+    { route: "GET /api/v1/orgs/:orgId/environments/:id", params: EnvironmentParams },
+    {
+        route: "PATCH /api/v1/orgs/:orgId/environments/:id",
+        params: EnvironmentParams,
+        body: EnvironmentNameBody,
+    },
+    { route: "DELETE /api/v1/orgs/:orgId/environments/:id", params: EnvironmentParams },
+    { route: "POST /api/v1/orgs/:orgId/environments/:id/files/reset", params: EnvironmentParams },
+];

package/dist/environments/environments.service.d.ts

@@ -72,10 +72,22 @@ export declare class EnvironmentsService {
      */
     create(orgId: string, accountId: string, input: {
         name: string;
-    }, actorTokenId?: string): Promise<EnvironmentView>;
+    }, actorTokenId?: string, auditDetail?: Record<string, unknown>): Promise<EnvironmentView>;
     private insert;
+    /**
+     * The refusals {@link create} would raise, read without locks or writes (a precheck before a
+     * confirmation card): no sandbox provider, the person's limit, a name already taken. Throws the
+     * same {@link ApiError}s; a race still ends in `create`'s own refusal.
+     */
+    checkCreate(orgId: string, accountId: string, name: string): Promise<void>;
+    /** How many of the person's conversations work in the environment (read only). */
+    boundConversations(orgId: string, accountId: string, id: string): Promise<number>;
+    /** The refusals {@link resetFiles} would raise (not found, its provider not current), read only. */
+    checkReset(orgId: string, accountId: string, id: string): Promise<void>;
+    /** The refusals {@link rename} would raise, read without locks (see {@link checkCreate}). */
+    checkRename(orgId: string, accountId: string, id: string, name: string): Promise<void>;
     /** Renames one of the person's live environments (the default too); see {@link create}. */
-    rename(orgId: string, accountId: string, id: string, name: string, actorTokenId?: string): Promise<EnvironmentView>;
+    rename(orgId: string, accountId: string, id: string, name: string, actorTokenId?: string, auditDetail?: Record<string, unknown>): Promise<EnvironmentView>;
     private renameIn;
     /**
      * Deletes one of the person's live environments: soft delete, its IM default row cleared, and
@@ -83,7 +95,7 @@ export declare class EnvironmentsService {
      * destroys the instance and the files). Conversations bound to it keep pointing at it; their
      * sandbox tools then fail with `environment.not_found`.
      */
-    remove(orgId: string, accountId: string, id: string, actorTokenId?: string): Promise<void>;
+    remove(orgId: string, accountId: string, id: string, actorTokenId?: string, auditDetail?: Record<string, unknown>): Promise<void>;
     /**
      * Starts one of the person's environments over with empty files (after
      * `environment.files_lost`): records the request (audit), then, after the commit, enqueues the
@@ -92,7 +104,7 @@ export declare class EnvironmentsService {
      * provider must be the current one (`environment.unavailable`). An enqueue failure is thrown
      * (the request can be repeated: the reset is idempotent).
      */
-    resetFiles(orgId: string, accountId: string, id: string, actorTokenId?: string): Promise<void>;
+    resetFiles(orgId: string, accountId: string, id: string, actorTokenId?: string, auditDetail?: Record<string, unknown>): Promise<void>;
     /** The check and audit row of {@link resetFiles}, committed before the job is enqueued. */
     private recordReset;
     /**

package/dist/environments/environments.service.js

@@ -94,11 +94,11 @@ let EnvironmentsService = class EnvironmentsService {
      * (case-insensitive) → `environment.name_taken`; `environments.maxPersonal` live ones (the
      * default counts) → `environment.limit_reached`. Serialized per person by their membership row.
      */
-    async create(orgId, accountId, input, actorTokenId) {
-        const id = await this.insert(orgId, accountId, input.name, actorTokenId);
+    async create(orgId, accountId, input, actorTokenId, auditDetail) {
+        const id = await this.insert(orgId, accountId, input.name, actorTokenId, auditDetail);
         return this.get(orgId, accountId, id);
     }
-    async insert(orgId, accountId, name, actorTokenId) {
+    async insert(orgId, accountId, name, actorTokenId, auditDetail) {
         const current = this.providers.current();
         if (!current)
             throw environmentUnavailable(null);
@@ -142,16 +142,60 @@ let EnvironmentsService = class EnvironmentsService {
             orgId,
             action: "environment.created",
             target: id,
-            detail: { name },
+            detail: { name, ...auditDetail },
         });
         return id;
     }
+    /**
+     * The refusals {@link create} would raise, read without locks or writes (a precheck before a
+     * confirmation card): no sandbox provider, the person's limit, a name already taken. Throws the
+     * same {@link ApiError}s; a race still ends in `create`'s own refusal.
+     */
+    async checkCreate(orgId, accountId, name) {
+        if (!this.providers.current())
+            throw environmentUnavailable(null);
+        const { n } = await this.db
+            .selectFrom("environments")
+            .select((eb) => eb.fn.countAll().as("n"))
+            .where("org_id", "=", orgId)
+            .where("owner_kind", "=", "personal")
+            .where("owner_account_id", "=", accountId)
+            .where("deleted_at", "is", null)
+            .executeTakeFirstOrThrow();
+        const max = this.config.get().environments.maxPersonal;
+        if (Number(n) >= max) {
+            throw new ApiError("environment.limit_reached", `You already have ${max} environments in this organization; delete one to create another`);
+        }
+        await this.assertNameFree(orgId, accountId, name);
+    }
+    /** How many of the person's conversations work in the environment (read only). */
+    async boundConversations(orgId, accountId, id) {
+        const { n } = await this.db
+            .selectFrom("conversations")
+            .select((eb) => eb.fn.countAll().as("n"))
+            .where("org_id", "=", orgId)
+            .where("account_id", "=", accountId)
+            .where("environment_id", "=", id)
+            .executeTakeFirstOrThrow();
+        return Number(n);
+    }
+    /** The refusals {@link resetFiles} would raise (not found, its provider not current), read only. */
+    async checkReset(orgId, accountId, id) {
+        await this.access.usable(orgId, accountId, id);
+    }
+    /** The refusals {@link rename} would raise, read without locks (see {@link checkCreate}). */
+    async checkRename(orgId, accountId, id, name) {
+        const before = await this.get(orgId, accountId, id);
+        if (before.name?.toLowerCase() !== name.toLowerCase()) {
+            await this.assertNameFree(orgId, accountId, name);
+        }
+    }
     /** Renames one of the person's live environments (the default too); see {@link create}. */
-    async rename(orgId, accountId, id, name, actorTokenId) {
-        await this.renameIn(orgId, accountId, id, name, actorTokenId);
+    async rename(orgId, accountId, id, name, actorTokenId, auditDetail) {
+        await this.renameIn(orgId, accountId, id, name, actorTokenId, auditDetail);
         return this.get(orgId, accountId, id);
     }
-    async renameIn(orgId, accountId, id, name, actorTokenId) {
+    async renameIn(orgId, accountId, id, name, actorTokenId, auditDetail) {
         const before = await this.lockOwn(orgId, accountId, id);
         if (before.name === name)
             return;
@@ -177,7 +221,7 @@ let EnvironmentsService = class EnvironmentsService {
             orgId,
             action: "environment.renamed",
             target: id,
-            detail: { from: before.name, to: name },
+            detail: { from: before.name, to: name, ...auditDetail },
         });
     }
     /**
@@ -186,7 +230,7 @@ let EnvironmentsService = class EnvironmentsService {
      * destroys the instance and the files). Conversations bound to it keep pointing at it; their
      * sandbox tools then fail with `environment.not_found`.
      */
-    async remove(orgId, accountId, id, actorTokenId) {
+    async remove(orgId, accountId, id, actorTokenId, auditDetail) {
         const before = await this.lockOwn(orgId, accountId, id);
         await this.db
             .updateTable("environments")
@@ -205,7 +249,7 @@ let EnvironmentsService = class EnvironmentsService {
             orgId,
             action: "environment.deleted",
             target: id,
-            detail: { name: before.name, isDefault: before.is_default },
+            detail: { name: before.name, isDefault: before.is_default, ...auditDetail },
         });
         afterCommit(async () => {
             try {
@@ -225,12 +269,12 @@ let EnvironmentsService = class EnvironmentsService {
      * provider must be the current one (`environment.unavailable`). An enqueue failure is thrown
      * (the request can be repeated: the reset is idempotent).
      */
-    async resetFiles(orgId, accountId, id, actorTokenId) {
-        await this.recordReset(orgId, accountId, id, actorTokenId);
+    async resetFiles(orgId, accountId, id, actorTokenId, auditDetail) {
+        await this.recordReset(orgId, accountId, id, actorTokenId, auditDetail);
         await this.sandboxJobs.resetFiles(id);
     }
     /** The check and audit row of {@link resetFiles}, committed before the job is enqueued. */
-    async recordReset(orgId, accountId, id, actorTokenId) {
+    async recordReset(orgId, accountId, id, actorTokenId, auditDetail) {
         await this.access.usable(orgId, accountId, id);
         await audit(this.db.db, {
             actorAccountId: accountId,
@@ -238,6 +282,7 @@ let EnvironmentsService = class EnvironmentsService {
             orgId,
             action: "environment.files_reset",
             target: id,
+            ...(auditDetail !== undefined && { detail: auditDetail }),
         });
     }
     /**

package/dist/errors.d.ts

@@ -15,6 +15,8 @@ export declare const ERROR_CODES: {
     readonly "account.login_taken": 409;
     readonly "account.not_found": 404;
     readonly "account.last_super_admin": 409;
+    readonly "account.initial_password_unavailable": 404;
+    readonly "account.create_needs_approval": 409;
     readonly "auth.account_disabled": 403;
     readonly "auth.required": 401;
     readonly "auth.token_expired": 401;
@@ -25,6 +27,7 @@ export declare const ERROR_CODES: {
     readonly "auth.csrf": 403;
     readonly "auth.rate_limited": 429;
     readonly "auth.session_required": 403;
+    readonly "auth.password_change_required": 403;
     readonly "token.not_found": 404;
     readonly "org.not_found": 404;
     readonly "org.creation_disabled": 403;

package/dist/errors.js

@@ -15,6 +15,8 @@ export const ERROR_CODES = {
     "account.login_taken": 409,
     "account.not_found": 404,
     "account.last_super_admin": 409,
+    "account.initial_password_unavailable": 404,
+    "account.create_needs_approval": 409,
     "auth.account_disabled": 403,
     "auth.required": 401,
     "auth.token_expired": 401,
@@ -25,6 +27,7 @@ export const ERROR_CODES = {
     "auth.csrf": 403,
     "auth.rate_limited": 429,
     "auth.session_required": 403,
+    "auth.password_change_required": 403,
     "token.not_found": 404,
     "org.not_found": 404,
     "org.creation_disabled": 403,

package/dist/evals/evals.schemas.d.ts

@@ -0,0 +1,110 @@
+import { z } from "zod";
+import type { RouteSchemas } from "../platform/route-schemas.js";
+export declare const EvalSetCreateBody: z.ZodObject<{
+    agentId: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    rubric: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const EvalSetPatchBody: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    rubric: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export declare const EvalAddCaseBody: z.ZodObject<{
+    conversationId: z.ZodString;
+    runId: z.ZodString;
+}, z.core.$strict>;
+export declare const EvalSampleBody: z.ZodObject<{
+    from: z.ZodOptional<z.ZodISODateTime>;
+    to: z.ZodOptional<z.ZodISODateTime>;
+    count: z.ZodNumber;
+    status: z.ZodOptional<z.ZodEnum<{
+        any: "any";
+        completed: "completed";
+        failed: "failed";
+    }>>;
+    minToolCalls: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const EvalCandidateSchema: z.ZodObject<{
+    agentVersion: z.ZodOptional<z.ZodNumber>;
+    model: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodString;
+    }, z.core.$strict>>;
+    modelParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+    instructions: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/** `tokenCap` is only type-checked here; the service judges the range (`eval.token_cap_invalid`). */
+export declare const EvalRunEstimateBody: z.ZodObject<{
+    mode: z.ZodEnum<{
+        run: "run";
+        step: "step";
+    }>;
+    candidate: z.ZodObject<{
+        agentVersion: z.ZodOptional<z.ZodNumber>;
+        model: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodString;
+        }, z.core.$strict>>;
+        modelParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+        instructions: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    judge: z.ZodDefault<z.ZodBoolean>;
+    tokenCap: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const EvalRunStartBody: z.ZodObject<{
+    mode: z.ZodEnum<{
+        run: "run";
+        step: "step";
+    }>;
+    candidate: z.ZodObject<{
+        agentVersion: z.ZodOptional<z.ZodNumber>;
+        model: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodString;
+        }, z.core.$strict>>;
+        modelParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+        instructions: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    judge: z.ZodDefault<z.ZodBoolean>;
+    tokenCap: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+/**
+ * `view=light`: no content blocks (result tables and polling; the response carries `asOf`);
+ * default `full`. `updatedSince` (ISO time) takes only what changed after it.
+ */
+export declare const EvalRunResultsQuery: z.ZodObject<{
+    after: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    view: z.ZodDefault<z.ZodEnum<{
+        full: "full";
+        light: "light";
+    }>>;
+    updatedSince: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const EvalLabelBody: z.ZodObject<{
+    label: z.ZodNullable<z.ZodEnum<{
+        fail: "fail";
+        pass: "pass";
+    }>>;
+    note: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const EvalSetParams: z.ZodObject<{
+    setId: z.ZodString;
+}, z.core.$strip>;
+export declare const EvalCaseParams: z.ZodObject<{
+    setId: z.ZodString;
+    caseId: z.ZodString;
+}, z.core.$strip>;
+export declare const EvalRunParams: z.ZodObject<{
+    runId: z.ZodString;
+}, z.core.$strip>;
+export declare const EvalResultParams: z.ZodObject<{
+    runId: z.ZodString;
+    resultId: z.ZodString;
+}, z.core.$strip>;
+export declare const EvalLabelParams: z.ZodObject<{
+    resultId: z.ZodString;
+}, z.core.$strip>;
+export declare const EVAL_ROUTES: readonly RouteSchemas[];