@capybara-hq/kernel 0.1.0-rc.0 → 0.1.0-rc.10

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 {};

package/dist/models/purposes.js

@@ -1,20 +1,37 @@
+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 { sanitizeParams, } from "@capybara-hq/plugin-sdk";
+import { Inject, Injectable } from "@nestjs/common";
 import { z } from "zod";
-import { paramIssues } from "../agents/agents.service.js";
-import { ModelRef } from "../agents/definition.js";
+import { ModelRef, paramIssues } from "../agents/definition.js";
 import { ApiError } from "../errors.js";
+import { ExtensionRegistry } from "../extensions/registry.js";
 import { audit } from "../identity/audit.js";
-import { lockEnterpriseAdminsAndAuthorize } from "../identity/enterprise-admin.js";
-import { lockOrgAndAuthorize } from "../orgs/org-lock.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 { Transactional } from "../infra/database/transactional.decorator.js";
+import { createZodDto } from "../infra/validation/create-zod-dto.js";
+import { OrgLock } from "../orgs/org-lock.js";
 import { estimateTokens } from "../runtime/context/tokens.js";
 import { consumeModelStream } from "../runtime/model-call.js";
-import { ProviderListError } from "../runtime/providers.js";
+import { ProviderListError, 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` 仍预留，插件暂不能调用。
  */
 /**
@@ -26,22 +43,36 @@ export const KERNEL_PURPOSES = [
     { purpose: "eval", kind: "chat", label: { zh: "评测评委", en: "Eval judge" } },
     /** Conversation titles (UI refresh B); unmapped → the conversation's current chat model. */
     { purpose: "title", kind: "chat", label: { zh: "会话标题", en: "Conversation titles" } },
+    /**
+     * The `WebFetch` extraction call (web tools spec §5); unmapped → the calling conversation's
+     * current chat model (a sub-agent's call: the sub-agent's).
+     */
+    { purpose: "web_fetch", kind: "chat", label: { zh: "网页提取", en: "Web page extraction" } },
     {
         purpose: "subagent_fast",
         kind: "chat",
-        label: { zh: "子代理：快速", en: "Sub-agent: fast" },
+        label: { zh: "子智能体：快速", en: "Sub-agent: fast" },
     },
     {
         purpose: "subagent_standard",
         kind: "chat",
-        label: { zh: "子代理：标准", en: "Sub-agent: standard" },
+        label: { zh: "子智能体：标准", en: "Sub-agent: standard" },
     },
     {
         purpose: "subagent_capable",
         kind: "chat",
-        label: { zh: "子代理：最强", en: "Sub-agent: capable" },
+        label: { zh: "子智能体：最强", en: "Sub-agent: capable" },
     },
 ];
+/** {@link PurposeListing}s of `views`, the display names read in one call. */
+export async function withDeclaredByNames(views, names) {
+    const plugins = views.map((v) => v.declaredBy).filter((d) => d !== "kernel");
+    const found = await names.many(plugins);
+    return views.map((v) => ({
+        ...v,
+        declaredByName: v.declaredBy === "kernel" ? null : (found.get(v.declaredBy) ?? null),
+    }));
+}
 /** `PUT …/model-purposes/:purpose` 的 body：设映射，或 `target: null` 清除。 */
 export const PURPOSE_PUT = z
     .object({
@@ -54,6 +85,9 @@ export const PURPOSE_PUT = z
         .nullable(),
 })
     .strict();
+/** {@link PURPOSE_PUT} as a DTO (`@ZBody(PurposePutDto)`). */
+export class PurposePutDto extends createZodDto(PURPOSE_PUT, "ModelPurposePut") {
+}
 /**
  * 用途请求已经发出、但没有正常收完（出错、超时、中止）：`tokens` 是应计入预算的估算用量（输入估算 + 已流出字符 / 4，
  * 与评测回放一致），`cause` 是原始错误。请求发出之前的失败（未映射、模型不可用）原样抛出。
@@ -80,10 +114,26 @@ const targetOf = (r) => r === undefined
         model: { provider: r.provider, model: r.model },
         params: (r.params ?? {}),
     };
-export class ModelPurposesService {
-    d;
-    constructor(d) {
-        this.d = d;
+/**
+ * The model purposes (one provider). Extension-declared purposes come from the manifests in the
+ * {@link ExtensionRegistry}; targets resolve through the model provider registry.
+ */
+let ModelPurposesService = class ModelPurposesService {
+    db;
+    extensions;
+    config;
+    providers;
+    txHost;
+    adminLock;
+    orgLock;
+    constructor(db, extensions, config, providers, txHost, adminLock, orgLock) {
+        this.db = db;
+        this.extensions = extensions;
+        this.config = config;
+        this.providers = providers;
+        this.txHost = txHost;
+        this.adminLock = adminLock;
+        this.orgLock = orgLock;
     }
     /** 全部已声明的用途：内核的在前，其后按插件加载顺序。 */
     declared() {
@@ -94,7 +144,7 @@ export class ModelPurposesService {
             declaredBy: "kernel",
         }));
         const seen = new Set(out.map((p) => p.purpose));
-        for (const m of this.d.manifests()) {
+        for (const m of this.extensions.manifests()) {
             for (const p of m.permissions?.models ?? []) {
                 if (seen.has(p.purpose))
                     continue;
@@ -118,7 +168,7 @@ export class ModelPurposesService {
     async rows(purposes, orgId) {
         if (purposes.length === 0)
             return [];
-        return this.d.db
+        return this.db
             .selectFrom("model_purpose_mappings")
             .select(["org_id", "purpose", "provider", "model", "params"])
             .where("purpose", "in", purposes)
@@ -141,11 +191,17 @@ export class ModelPurposesService {
     async list(orgId) {
         return this.views(this.declared(), orgId);
     }
-    /** 校验目标：模型可解析（部署范围）、参数按它的声明严格通过。 */
-    async check(target) {
+    /**
+     * 校验目标：模型可解析且启用（an org's override for the org, a deployment default in the
+     * platform view）、its kind is the purpose's `kind`、参数按它的声明严格通过。
+     */
+    async check(orgId, target, kind) {
         let info;
         try {
-            ({ info } = await this.d.registry.resolve(target.model));
+            info =
+                orgId === null
+                    ? await this.providers.platformInfo(target.model, { kind: "callable" })
+                    : (await this.providers.resolve(orgId, target.model, { kind: "callable" })).info;
         }
         catch (e) {
             if (e instanceof ProviderListError)
@@ -155,69 +211,135 @@ export class ModelPurposesService {
             }
             throw e;
         }
+        if (info.kind !== kind) {
+            throw invalid([
+                {
+                    path: "target.model",
+                    message: `this purpose needs ${kind === "embedding" ? "an" : "a"} ${kind} model, not ${info.kind}`,
+                },
+            ]);
+        }
         const issues = paramIssues("target.params", info.parameters, target.params);
         if (issues.length > 0)
             throw invalid(issues);
     }
-    async set(orgId, purpose, target, actor, actorTokenId) {
+    async set(orgId, purpose, target, actor, actorTokenId, auditDetail) {
         const decl = this.find(purpose);
         if (target)
-            await this.check(target);
-        await this.d.db.transaction().execute(async (trx) => {
-            if (orgId === null)
-                await lockEnterpriseAdminsAndAuthorize(trx, actor);
-            else
-                await lockOrgAndAuthorize(trx, orgId, actor, "org.models.manage");
-            if (target === null) {
-                await trx
-                    .deleteFrom("model_purpose_mappings")
-                    .where("purpose", "=", purpose)
-                    .where((eb) => (orgId === null ? eb("org_id", "is", null) : eb("org_id", "=", orgId)))
-                    .execute();
-            }
-            else {
-                const values = {
-                    provider: target.model.provider,
-                    model: target.model.model,
-                    params: JSON.stringify(target.params),
-                    updated_by: actor,
-                };
-                await trx
-                    .insertInto("model_purpose_mappings")
-                    .values({ org_id: orgId, purpose, ...values })
-                    .onConflict((oc) => oc
-                    .constraint("model_purpose_mappings_scope_key")
-                    .doUpdateSet({ ...values, updated_at: new Date() }))
-                    .execute();
-            }
-            await audit(trx, {
-                actorAccountId: actor,
-                ...(actorTokenId !== undefined && { actorTokenId }),
-                ...(orgId !== null && { orgId }),
-                action: "model.purpose_mapped",
-                target: purpose,
-                detail: { scope: orgId === null ? "deployment" : "org", target },
-            });
-        });
+            await this.check(orgId, target, decl.kind);
+        await this.write(orgId, purpose, target, actor, actorTokenId, auditDetail);
         const [view] = await this.views([decl], orgId ?? undefined);
         return view;
     }
-    /** 设置（或 `null` 清除）部署默认；只有企业管理员（事务内复核）。 */
-    setDefault(purpose, target, actor, actorTokenId) {
-        return this.set(null, purpose, target, actor, actorTokenId);
+    /**
+     * 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).
+     */
+    async validate(orgId, purpose, target) {
+        const decl = this.find(purpose);
+        if (target)
+            await this.check(orgId, target, decl.kind);
+    }
+    /** The mapping write of {@link set}, under the super admin or org lock. */
+    async write(orgId, purpose, target, actor, actorTokenId, auditDetail) {
+        if (orgId === null)
+            await this.adminLock.lockAndAuthorize(actor);
+        else
+            await this.orgLock.lockAndAuthorize(orgId, actor, "org.models.manage");
+        if (target === null) {
+            await this.db
+                .deleteFrom("model_purpose_mappings")
+                .where("purpose", "=", purpose)
+                .where((eb) => (orgId === null ? eb("org_id", "is", null) : eb("org_id", "=", orgId)))
+                .execute();
+        }
+        else {
+            const values = {
+                provider: target.model.provider,
+                model: target.model.model,
+                params: JSON.stringify(target.params),
+                updated_by: actor,
+            };
+            await this.db
+                .insertInto("model_purpose_mappings")
+                .values({ org_id: orgId, purpose, ...values })
+                .onConflict((oc) => oc
+                .constraint("model_purpose_mappings_scope_key")
+                .doUpdateSet({ ...values, updated_at: new Date() }))
+                .execute();
+        }
+        await audit(this.db.db, {
+            actorAccountId: actor,
+            ...(actorTokenId !== undefined && { actorTokenId }),
+            ...(orgId !== null && { orgId }),
+            action: "model.purpose_mapped",
+            target: purpose,
+            detail: { scope: orgId === null ? "deployment" : "org", target, ...auditDetail },
+        });
+    }
+    /** 设置（或 `null` 清除）部署默认；只有超级管理员（事务内复核）。 */
+    setDefault(purpose, target, actor, actorTokenId, 
+    /** Merged into the audit detail (a write made through the Platform tool). */
+    auditDetail) {
+        return this.set(null, purpose, target, actor, actorTokenId, auditDetail);
     }
     /** 设置（或 `null` 清除）组织覆盖；事务内锁组织并复核 `org.models.manage`。 */
-    setOrg(orgId, purpose, target, actor, actorTokenId) {
-        return this.set(orgId, purpose, target, actor, actorTokenId);
+    setOrg(orgId, purpose, target, actor, actorTokenId, 
+    /** Merged into the audit detail (a write made through the Platform tool). */
+    auditDetail) {
+        return this.set(orgId, purpose, target, actor, actorTokenId, auditDetail);
     }
-    /** 生效的映射：组织覆盖，否则部署默认；都没有 → `model.unconfigured`；用途未声明 → `model.purpose_unknown`。 */
+    /**
+     * 生效的映射：组织覆盖，否则部署默认；都没有 → `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.
+     */
     async resolve(orgId, purpose) {
-        const [view] = await this.views([this.find(purpose)], orgId);
+        const decl = this.find(purpose);
+        const [view] = await this.views([decl], orgId);
         if (!view?.effective) {
             throw new ApiError("model.unconfigured", `No model is configured for the "${purpose}" purpose`);
         }
+        try {
+            await this.providers.resolve(orgId, view.effective.model, { kind: decl.kind });
+        }
+        catch (e) {
+            if (e instanceof ProviderListError)
+                return view.effective;
+            if (e instanceof ApiError && e.code === "agent.model_unavailable") {
+                throw new ApiError("model.unconfigured", `The model configured for the "${purpose}" purpose is not available in this organization`);
+            }
+            throw e;
+        }
         return view.effective;
     }
+    /** The target a {@link chat} call on `purpose` uses: the mapping, else `fallback` when unmapped. */
+    async chatTarget(orgId, purpose, fallback) {
+        try {
+            return await this.resolve(orgId, purpose);
+        }
+        catch (e) {
+            if (!(e instanceof ApiError && e.code === "model.unconfigured") || !fallback)
+                throw e;
+            return fallback;
+        }
+    }
+    /**
+     * 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.
+     */
+    async chatLimits(orgId, purpose, opts = {}) {
+        const target = await this.chatTarget(orgId, purpose, opts.fallback);
+        const { info } = await this.providers.resolve(orgId, target.model);
+        return { contextWindow: info.contextWindow, maxOutputTokens: info.maxOutputTokens };
+    }
     /**
      * 按用途发一次对话请求：解析映射、按目标模型的声明宽松处理参数（补默认值，与运行时一致），用 `consumeModelStream`
      * 收完（只有流空闲看门狗）。输出上限取 `min(req.maxOutputTokens, 目标模型的 maxOutputTokens)`。
@@ -225,26 +347,21 @@ export 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).
      */
     async chat(orgId, purpose, req, signal, opts = {}) {
-        let target;
-        try {
-            target = await this.resolve(orgId, purpose);
-        }
-        catch (e) {
-            if (!(e instanceof ApiError && e.code === "model.unconfigured") || !opts.fallback)
-                throw e;
-            target = opts.fallback;
-        }
-        const { provider, info } = await this.d.registry.resolve(target.model);
+        const target = await this.chatTarget(orgId, purpose, opts.fallback);
+        const { provider, info } = await this.providers.resolve(orgId, target.model);
         const request = {
             ...req,
             model: info.id,
-            params: sanitizeParams(info.parameters, target.params).value,
+            // undeclared or unfitting defaults are dropped like any other parameter
+            params: sanitizeParams(info.parameters, { ...opts.paramDefaults, ...target.params }).value,
             // 输出上限不超过目标模型自己的上限（与运行时 assembleModelRequest 一致）
             maxOutputTokens: Math.min(req.maxOutputTokens, info.maxOutputTokens),
         };
-        const idleMs = info.streamIdleTimeoutMs ?? this.d.config().runtime.streamIdleMs;
+        const idleMs = info.streamIdleTimeoutMs ?? this.config.get().runtime.streamIdleMs;
         await opts.beforeSend?.(target.model, request);
         let chars = 0;
         try {
@@ -264,4 +381,18 @@ export class ModelPurposesService {
             throw new PurposeAttemptError(err, tokens, target.model.provider, target.model.model);
         }
     }
-}
+};
+__decorate([
+    Transactional()
+], ModelPurposesService.prototype, "write", null);
+ModelPurposesService = __decorate([
+    Injectable(),
+    __param(0, Inject(KernelDb)),
+    __param(1, Inject(ExtensionRegistry)),
+    __param(2, Inject(KernelConfigService)),
+    __param(3, Inject(ProviderRegistry)),
+    __param(4, Inject(TransactionHost)),
+    __param(5, Inject(SuperAdminLock)),
+    __param(6, Inject(OrgLock))
+], ModelPurposesService);
+export { ModelPurposesService };

package/dist/net/public-address.js

@@ -6,8 +6,9 @@ import { BlockList, isIP } from "node:net";
  * checked addresses only (see `safe-fetch.ts`), so a DNS answer that changes between check and
  * connect (DNS rebinding, e.g. `10.0.0.1.nip.io`) cannot reach a private address.
  *
- * The blocked ranges are those of `plugins/sandbox-docker/egress-proxy/proxy.mjs`, ported here
- * because the kernel must not import from a plugin. IPv6 addresses that embed an IPv4 address
+ * The blocked ranges are those of the sandbox-docker plugin's egress proxy
+ * (`plugins/sandbox-docker/egress-proxy/proxy.mjs` in capybara-hq/plugins), ported here because the
+ * kernel must not import from a plugin. IPv6 addresses that embed an IPv4 address
  * (v4-mapped `::ffff:0:0/96`, v4-compatible `::/96`, NAT64 `64:ff9b::/96`, 6to4 `2002::/16`) are
  * judged by the embedded IPv4 address; anything unparseable is refused. One addition over proxy.mjs:
  * SIIT IPv4-translated addresses (`::ffff:0:a.b.c.d`, `::ffff:0:0:0/96`, RFC 2765) are also judged by

package/dist/orgs/directory-sync.controller.d.ts

@@ -1,5 +1,5 @@
 import { type Principal } from "../identity/principal.js";
-import type { DirectorySync } from "./directory-sync.js";
+import { DirectorySync } from "./directory-sync.js";
 import { type OrgContext } from "./org.guard.js";
 /**
  * Manual directory sync (`/api/v1/orgs/:orgId/extensions/:extension/directory/sync`): it adds and

package/dist/orgs/directory-sync.controller.js

@@ -8,8 +8,8 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { Controller, HttpCode, Inject, Param, Post } from "@nestjs/common";
-import { DIRECTORY_SYNC } from "../http/tokens.js";
 import { CurrentPrincipal, patTokenId, requireUser, } from "../identity/principal.js";
+import { DirectorySync } from "./directory-sync.js";
 import { CurrentOrg, OrgAction } from "./org.guard.js";
 /**
  * Manual directory sync (`/api/v1/orgs/:orgId/extensions/:extension/directory/sync`): it adds and
@@ -35,6 +35,6 @@ __decorate([
 ], DirectorySyncController.prototype, "sync", null);
 DirectorySyncController = __decorate([
     Controller("api/v1/orgs/:orgId/extensions/:extension/directory"),
-    __param(0, Inject(DIRECTORY_SYNC))
+    __param(0, Inject(DirectorySync))
 ], DirectorySyncController);
 export { DirectorySyncController };