@capybara-hq/kernel 0.1.0-rc.1 → 0.1.0-rc.11

package/dist/models/prices.js

@@ -1,7 +1,20 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Inject, Injectable } from "@nestjs/common";
 import { z } from "zod";
 import { ApiError } from "../errors.js";
 import { audit } from "../identity/audit.js";
-import { lockEnterpriseAdminsAndAuthorize } from "../identity/enterprise-admin.js";
+import { SuperAdminLock } from "../identity/super-admin.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { TransactionHost } from "../infra/database/transaction-host.js";
+import { Transactional } from "../infra/database/transactional.decorator.js";
 /** 价格表的键。供应商名与模型 id 不含换行，拼接不会撞键。 */
 export const priceKey = (provider, model) => `${provider}\n${model}`;
 /** 一次调用的估算成本；没有价格 → null。用量的四项互不重叠（见 plugin-sdk `ModelUsage`）。 */
@@ -36,10 +49,14 @@ export const MODEL_PRICE_PUT = z.union([
 const num = (v) => Number(v);
 const numOrNull = (v) => (v === null ? null : Number(v));
 /** 模型价格（PG `model_prices`）：每次读都查库，不在进程内缓存（多副本下改价立刻生效）。 */
-export class PricesService {
+let PricesService = class PricesService {
     db;
-    constructor(db) {
+    txHost;
+    adminLock;
+    constructor(db, txHost, adminLock) {
         this.db = db;
+        this.txHost = txHost;
+        this.adminLock = adminLock;
     }
     /** 全部价格，按 provider、model 排序。 */
     async list() {
@@ -70,52 +87,65 @@ export class PricesService {
         return new Map((await this.list()).map((p) => [priceKey(p.provider, p.model), p]));
     }
     /**
-     * 设置或删除（`price: null`）一个模型的价格：事务内取企业管理员锁并复核发起人仍是活跃企业管理员
+     * 设置或删除（`price: null`）一个模型的价格：事务内取超级管理员锁并复核发起人仍是活跃超级管理员
      * （否则 `forbidden`），写审计 `model_price.updated` / `model_price.deleted`。
      */
-    async put(input, actorAccountId, actorTokenId) {
+    async put(input, actorAccountId, actorTokenId, 
+    /** Merged into the audit detail (the Platform tool's `via: "agent"`). */
+    auditDetail) {
         const check = MODEL_PRICE_PUT.safeParse(input);
         if (!check.success) {
             throw new ApiError("validation_failed", "Invalid model price", check.error.issues.map((i) => ({ path: i.path.join("."), message: i.message })));
         }
-        const v = check.data;
-        await this.db.transaction().execute(async (trx) => {
-            await lockEnterpriseAdminsAndAuthorize(trx, actorAccountId);
-            const target = `${v.provider}/${v.model}`;
-            if ("price" in v) {
-                await trx
-                    .deleteFrom("model_prices")
-                    .where("provider", "=", v.provider)
-                    .where("model", "=", v.model)
-                    .execute();
-                await audit(trx, {
-                    actorAccountId,
-                    ...(actorTokenId !== undefined && { actorTokenId }),
-                    action: "model_price.deleted",
-                    target,
-                    detail: { provider: v.provider, model: v.model },
-                });
-                return;
-            }
-            const values = {
-                input_per_mtok: v.inputPerMTok,
-                output_per_mtok: v.outputPerMTok,
-                cache_read_per_mtok: v.cacheReadPerMTok,
-                cache_write_per_mtok: v.cacheWritePerMTok,
-                updated_by: actorAccountId,
-            };
-            await trx
-                .insertInto("model_prices")
-                .values({ provider: v.provider, model: v.model, ...values })
-                .onConflict((oc) => oc.columns(["provider", "model"]).doUpdateSet({ ...values, updated_at: new Date() }))
+        await this.write(check.data, actorAccountId, actorTokenId, auditDetail);
+    }
+    /** The write of {@link put}, under the super admin lock. */
+    async write(v, actorAccountId, actorTokenId, auditDetail) {
+        await this.adminLock.lockAndAuthorize(actorAccountId);
+        const target = `${v.provider}/${v.model}`;
+        if ("price" in v) {
+            await this.db
+                .deleteFrom("model_prices")
+                .where("provider", "=", v.provider)
+                .where("model", "=", v.model)
                 .execute();
-            await audit(trx, {
+            await audit(this.db.db, {
                 actorAccountId,
                 ...(actorTokenId !== undefined && { actorTokenId }),
-                action: "model_price.updated",
+                action: "model_price.deleted",
                 target,
-                detail: { ...v },
+                detail: { provider: v.provider, model: v.model, ...auditDetail },
             });
+            return;
+        }
+        const values = {
+            input_per_mtok: v.inputPerMTok,
+            output_per_mtok: v.outputPerMTok,
+            cache_read_per_mtok: v.cacheReadPerMTok,
+            cache_write_per_mtok: v.cacheWritePerMTok,
+            updated_by: actorAccountId,
+        };
+        await this.db
+            .insertInto("model_prices")
+            .values({ provider: v.provider, model: v.model, ...values })
+            .onConflict((oc) => oc.columns(["provider", "model"]).doUpdateSet({ ...values, updated_at: new Date() }))
+            .execute();
+        await audit(this.db.db, {
+            actorAccountId,
+            ...(actorTokenId !== undefined && { actorTokenId }),
+            action: "model_price.updated",
+            target,
+            detail: { ...v, ...auditDetail },
         });
     }
-}
+};
+__decorate([
+    Transactional()
+], PricesService.prototype, "write", null);
+PricesService = __decorate([
+    Injectable(),
+    __param(0, Inject(KernelDb)),
+    __param(1, Inject(TransactionHost)),
+    __param(2, Inject(SuperAdminLock))
+], PricesService);
+export { PricesService };

package/dist/models/purposes.controller.d.ts

@@ -1,6 +1,7 @@
+import { ExtensionDisplayNames } from "../extensions/display-name.js";
 import { type Principal } from "../identity/principal.js";
 import { type OrgContext } from "../orgs/org.guard.js";
-import { type ModelPurposesService, type PurposePut, type PurposeTarget, type PurposeView } from "./purposes.js";
+import { ModelPurposesService, type PurposeListing, type PurposePut, type PurposeTarget } from "./purposes.js";
 /** body 的目标（参数缺省为 `{}`）。 */
 export declare const purposeTargetOf: (b: PurposePut) => PurposeTarget | null;
 /**
@@ -9,11 +10,12 @@ export declare const purposeTargetOf: (b: PurposePut) => PurposeTarget | null;
  */
 export declare class ModelPurposesController {
     private readonly purposes;
-    constructor(purposes: ModelPurposesService);
+    private readonly displayNames;
+    constructor(purposes: ModelPurposesService, displayNames: ExtensionDisplayNames);
     list(principal: Principal, org: OrgContext): Promise<{
-        purposes: PurposeView[];
+        purposes: PurposeListing[];
     }>;
     put(principal: Principal, org: OrgContext, purpose: string, body: PurposePut): Promise<{
-        purpose: PurposeView;
+        purpose: PurposeListing;
     }>;
 }

package/dist/models/purposes.controller.js

@@ -7,12 +7,12 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-import { Body, Controller, Get, Inject, Param, Put } from "@nestjs/common";
-import { MODEL_PURPOSES } from "../http/tokens.js";
-import { ZodPipe } from "../http/zod.pipe.js";
+import { Controller, Get, Inject, Param, Put } from "@nestjs/common";
+import { ExtensionDisplayNames } from "../extensions/display-name.js";
 import { CurrentPrincipal, patTokenId, requireUser, } from "../identity/principal.js";
+import { ZBody } from "../infra/validation/zod-params.js";
 import { CurrentOrg, OrgAction } from "../orgs/org.guard.js";
-import { PURPOSE_PUT, } from "./purposes.js";
+import { ModelPurposesService, PurposePutDto, withDeclaredByNames, } from "./purposes.js";
 /** body 的目标（参数缺省为 `{}`）。 */
 export const purposeTargetOf = (b) => b.target === null ? null : { model: b.target.model, params: b.target.params ?? {} };
 /**
@@ -21,18 +21,22 @@ export const purposeTargetOf = (b) => b.target === null ? null : { model: b.targ
  */
 let ModelPurposesController = class ModelPurposesController {
     purposes;
-    constructor(purposes) {
+    displayNames;
+    constructor(purposes, displayNames) {
         this.purposes = purposes;
+        this.displayNames = displayNames;
     }
     async list(principal, org) {
         requireUser(principal);
-        return { purposes: await this.purposes.list(org.orgId) };
+        return {
+            purposes: await withDeclaredByNames(await this.purposes.list(org.orgId), this.displayNames),
+        };
     }
     async put(principal, org, purpose, body) {
         const p = requireUser(principal);
-        return {
-            purpose: await this.purposes.setOrg(org.orgId, purpose, purposeTargetOf(body), p.account.id, patTokenId(p)),
-        };
+        const view = await this.purposes.setOrg(org.orgId, purpose, purposeTargetOf(body), p.account.id, patTokenId(p));
+        const [listing] = await withDeclaredByNames([view], this.displayNames);
+        return { purpose: listing };
     }
 };
 __decorate([
@@ -47,10 +51,11 @@ __decorate([
     __param(0, CurrentPrincipal()),
     __param(1, CurrentOrg()),
     __param(2, Param("purpose")),
-    __param(3, Body(new ZodPipe(PURPOSE_PUT)))
+    __param(3, ZBody(PurposePutDto))
 ], ModelPurposesController.prototype, "put", null);
 ModelPurposesController = __decorate([
     Controller("api/v1/orgs/:orgId/model-purposes"),
-    __param(0, Inject(MODEL_PURPOSES))
+    __param(0, Inject(ModelPurposesService)),
+    __param(1, Inject(ExtensionDisplayNames))
 ], ModelPurposesController);
 export { ModelPurposesController };

package/dist/models/purposes.d.ts

@@ -1,15 +1,21 @@
-import { type ContentBlock, type ExtensionManifest, type ModelRequest, type ModelUsage, type ParamValue, type StopReason } from "@capybara-hq/plugin-sdk";
+import { type ContentBlock, type LocalizedName, type ModelRequest, type ModelUsage, type ParamValue, type StopReason } from "@capybara-hq/plugin-sdk";
 import { z } from "zod";
 import { ModelRef } from "../agents/definition.js";
-import type { KernelConfig } from "../config/schema.js";
-import type { KernelDb } from "../db/kernel-schema.js";
-import { type ProviderRegistry } from "../runtime/providers.js";
+import { ExtensionRegistry } from "../extensions/registry.js";
+import { SuperAdminLock } from "../identity/super-admin.js";
+import { KernelConfigService } from "../infra/config/kernel-config.service.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { TransactionHost } from "../infra/database/transaction-host.js";
+import { OrgLock } from "../orgs/org-lock.js";
+import { ProviderRegistry } from "../runtime/providers.js";
 /**
  * 模型用途映射（C9）：内核与插件按「用途」取模型，不在代码里写死模型。
  * - 用途 = 内核用途 {@link KERNEL_PURPOSES}（目前只有评委 `eval`），或已加载插件 `permissions.models` 声明的；
- * - 映射 = 部署默认（`org_id` 为 null，企业管理员设）+ 组织覆盖（组织管理员设，`org.models.manage`）；
+ * - 映射 = 部署默认（`org_id` 为 null，超级管理员设）+ 组织覆盖（组织管理员设，`org.models.manage`）；
  *   生效的映射先取组织覆盖、再取部署默认，都没有 → `model.unconfigured`；
- * - 目标模型按部署范围解析（与运行时一致），参数按目标模型自己的声明严格校验；不做模型白名单；
+ * - a target's kind must equal the purpose's kind; an org's override must be enabled in the org on
+ *   save (a deployment default: not disabled on the platform), and an effective target disabled in
+ *   the org (by either layer) counts as unconfigured there (spec B §5.3)；参数按目标模型自己的声明严格校验；
  * - 每次都查 PG，不在进程内缓存（多副本下改映射立即生效）。`ctx.models` 仍预留，插件暂不能调用。
  */
 /**
@@ -31,25 +37,32 @@ export declare const KERNEL_PURPOSES: readonly [{
         readonly zh: "会话标题";
         readonly en: "Conversation titles";
     };
+}, {
+    readonly purpose: "web_fetch";
+    readonly kind: "chat";
+    readonly label: {
+        readonly zh: "网页提取";
+        readonly en: "Web page extraction";
+    };
 }, {
     readonly purpose: "subagent_fast";
     readonly kind: "chat";
     readonly label: {
-        readonly zh: "子代理：快速";
+        readonly zh: "子智能体：快速";
         readonly en: "Sub-agent: fast";
     };
 }, {
     readonly purpose: "subagent_standard";
     readonly kind: "chat";
     readonly label: {
-        readonly zh: "子代理：标准";
+        readonly zh: "子智能体：标准";
         readonly en: "Sub-agent: standard";
     };
 }, {
     readonly purpose: "subagent_capable";
     readonly kind: "chat";
     readonly label: {
-        readonly zh: "子代理：最强";
+        readonly zh: "子智能体：最强";
         readonly en: "Sub-agent: capable";
     };
 }];
@@ -71,6 +84,17 @@ export interface PurposeView {
     override: PurposeTarget | null;
     effective: PurposeTarget | null;
 }
+/**
+ * A purpose as the purpose APIs return it: the view plus the declaring extension's display name
+ * (`null` for a kernel purpose, or an extension without one), so a page names the extension.
+ */
+export interface PurposeListing extends PurposeView {
+    declaredByName: LocalizedName | null;
+}
+/** {@link PurposeListing}s of `views`, the display names read in one call. */
+export declare function withDeclaredByNames(views: PurposeView[], names: {
+    many(names: string[]): Promise<Map<string, LocalizedName | null>>;
+}): Promise<PurposeListing[]>;
 /** `PUT …/model-purposes/:purpose` 的 body：设映射，或 `target: null` 清除。 */
 export declare const PURPOSE_PUT: z.ZodObject<{
     target: z.ZodNullable<z.ZodObject<{
@@ -82,6 +106,18 @@ export declare const PURPOSE_PUT: z.ZodObject<{
     }, z.core.$strict>>;
 }, z.core.$strict>;
 export type PurposePut = z.infer<typeof PURPOSE_PUT>;
+declare const PurposePutDto_base: import("../infra/validation/create-zod-dto.js").ZodDtoClass<z.ZodObject<{
+    target: z.ZodNullable<z.ZodObject<{
+        model: z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodString;
+        }, z.core.$strict>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>>;
+/** {@link PURPOSE_PUT} as a DTO (`@ZBody(PurposePutDto)`). */
+export declare class PurposePutDto extends PurposePutDto_base {
+}
 /**
  * 用途请求已经发出、但没有正常收完（出错、超时、中止）：`tokens` 是应计入预算的估算用量（输入估算 + 已流出字符 / 4，
  * 与评测回放一致），`cause` 是原始错误。请求发出之前的失败（未映射、模型不可用）原样抛出。
@@ -93,16 +129,19 @@ export declare class PurposeAttemptError extends Error {
     readonly model: string;
     constructor(cause: unknown, tokens: number, provider: string, model: string);
 }
-export interface ModelPurposesDeps {
-    db: KernelDb;
-    registry: Pick<ProviderRegistry, "resolve">;
-    config: () => KernelConfig;
-    /** 已加载插件的清单（取 `permissions.models`）。 */
-    manifests: () => readonly ExtensionManifest[];
-}
+/**
+ * The model purposes (one provider). Extension-declared purposes come from the manifests in the
+ * {@link ExtensionRegistry}; targets resolve through the model provider registry.
+ */
 export declare class ModelPurposesService {
-    private readonly d;
-    constructor(d: ModelPurposesDeps);
+    private readonly db;
+    private readonly extensions;
+    private readonly config;
+    private readonly providers;
+    readonly txHost: TransactionHost;
+    private readonly adminLock;
+    private readonly orgLock;
+    constructor(db: KernelDb, extensions: ExtensionRegistry, config: KernelConfigService, providers: Pick<ProviderRegistry, "resolve" | "platformInfo">, txHost: TransactionHost, adminLock: SuperAdminLock, orgLock: OrgLock);
     /** 全部已声明的用途：内核的在前，其后按插件加载顺序。 */
     private declared;
     private find;
@@ -110,15 +149,52 @@ export declare class ModelPurposesService {
     private views;
     /** 全部用途与映射；不给 `orgId` = 部署级视图（`override` 一律为 null）。 */
     list(orgId?: string): Promise<PurposeView[]>;
-    /** 校验目标：模型可解析（部署范围）、参数按它的声明严格通过。 */
+    /**
+     * 校验目标：模型可解析且启用（an org's override for the org, a deployment default in the
+     * platform view）、its kind is the purpose's `kind`、参数按它的声明严格通过。
+     */
     private check;
     private set;
-    /** 设置（或 `null` 清除）部署默认；只有企业管理员（事务内复核）。 */
-    setDefault(purpose: string, target: PurposeTarget | null, actor: string, actorTokenId?: string): Promise<PurposeView>;
+    /**
+     * The checks {@link set} runs before writing, nothing written: an unknown purpose, and a target
+     * model the scope cannot use, of another kind, or with invalid params (the Platform tool's
+     * precheck, so a known failure never reaches the confirmation card).
+     */
+    validate(orgId: string | null, purpose: string, target: PurposeTarget | null): Promise<void>;
+    /** The mapping write of {@link set}, under the super admin or org lock. */
+    private write;
+    /** 设置（或 `null` 清除）部署默认；只有超级管理员（事务内复核）。 */
+    setDefault(purpose: string, target: PurposeTarget | null, actor: string, actorTokenId?: string, 
+    /** Merged into the audit detail (a write made through the Platform tool). */
+    auditDetail?: Record<string, unknown>): Promise<PurposeView>;
     /** 设置（或 `null` 清除）组织覆盖；事务内锁组织并复核 `org.models.manage`。 */
-    setOrg(orgId: string, purpose: string, target: PurposeTarget | null, actor: string, actorTokenId?: string): Promise<PurposeView>;
-    /** 生效的映射：组织覆盖，否则部署默认；都没有 → `model.unconfigured`；用途未声明 → `model.purpose_unknown`。 */
+    setOrg(orgId: string, purpose: string, target: PurposeTarget | null, actor: string, actorTokenId?: string, 
+    /** Merged into the audit detail (a write made through the Platform tool). */
+    auditDetail?: Record<string, unknown>): Promise<PurposeView>;
+    /**
+     * 生效的映射：组织覆盖，否则部署默认；都没有 → `model.unconfigured`；用途未声明 → `model.purpose_unknown`。
+     * An effective target the org cannot use counts as unconfigured there (spec B §5.3): checked in
+     * the registry's org view, so a model the platform or the org disabled, a provider off or needing
+     * configuration in the org, a model gone from the org's list or of another kind than the purpose
+     * all give `model.unconfigured`. A provider whose list fails (`ProviderListError`) keeps the
+     * mapping: the call that follows resolves the model again and fails there, retryably, so paths
+     * that only read the mapping (sub-agent tiers, eval start, `ctx.models.describe`) do not fail on
+     * a transient list error.
+     */
     resolve(orgId: string, purpose: string): Promise<PurposeTarget>;
+    /** The target a {@link chat} call on `purpose` uses: the mapping, else `fallback` when unmapped. */
+    private chatTarget;
+    /**
+     * The limits of the model a {@link chat} call on `purpose` would use now (the same mapping and
+     * `fallback` rule): its context window and output cap, so a caller can size its request (e.g.
+     * the `WebFetch` page) before the call. Fails as `chat` does before sending.
+     */
+    chatLimits(orgId: string, purpose: string, opts?: {
+        fallback?: PurposeTarget;
+    }): Promise<{
+        contextWindow: number;
+        maxOutputTokens: number;
+    }>;
     /**
      * 按用途发一次对话请求：解析映射、按目标模型的声明宽松处理参数（补默认值，与运行时一致），用 `consumeModelStream`
      * 收完（只有流空闲看门狗）。输出上限取 `min(req.maxOutputTokens, 目标模型的 maxOutputTokens)`。
@@ -126,10 +202,13 @@ export declare class ModelPurposesService {
      * `opts.fallback`: the target used when the purpose is not mapped (`model.unconfigured`).
      * `opts.beforeSend`: called with the resolved target and the final request just before sending;
      * what it throws is thrown as is (a pre-send failure, e.g. a denied `model.request` hook).
+     * `opts.paramDefaults`: values for parameters the target does not set, kept only where the
+     * target model declares the key and the value fits it (e.g. `thinking: "off"` for a short call).
      */
     chat(orgId: string, purpose: string, req: Omit<ModelRequest, "model" | "params">, signal: AbortSignal, opts?: {
         fallback?: PurposeTarget;
         beforeSend?: (target: ModelRef, request: ModelRequest) => Promise<void>;
+        paramDefaults?: Record<string, ParamValue>;
     }): Promise<{
         content: ContentBlock[];
         stopReason: StopReason;
@@ -138,3 +217,4 @@ export declare class ModelPurposesService {
         model: string;
     }>;
 }
+export {};