@capybara-hq/kernel 0.1.0-rc.2 → 0.1.0-rc.4

package/dist/identity/settings.js

@@ -68,7 +68,7 @@ export const DEPLOYMENT_SETTINGS = z.object({
     /** 组织能否自建连接器（不经企业目录）。 */
     customConnectors: CustomPolicy.default("allow"),
     /**
-     * 组织能否自建技能（不经企业目录）：deny 时组织管理员不能上传技能包。agent 自写技能（`skill_write`，私有 agent 的
+     * 组织能否自建技能（不经企业目录）：deny 时组织管理员不能上传技能包。agent 自写技能（`SkillWrite`，私有 agent 的
      * agent 级技能与共享 agent 经负责人审批的变更）不受此开关约束——那是 agent 定义的一部分，由 R3 / R4 把关。
      */
     customSkills: CustomPolicy.default("allow"),

package/dist/index.d.ts

@@ -31,7 +31,7 @@ export { type ApprovalDecision, ExtensionApprovals, type PendingExtension, type
 export { blobKey, ExtensionBlobIntegrityError, type ExtensionBlobSource, ExtensionBlobs, } from "./extensions/blobs.js";
 export { BOOTSTRAP_MANIFEST_FILE, type BootstrapEntryResult, BootstrapFailedError, type BootstrapFailure, type BootstrapResolveOptions, type BootstrapResult, BootstrapService, bootstrapManifestSha256, readBootstrapManifest, resolveBootstrapPackages, } from "./extensions/bootstrap.js";
 export { type ExtensionCli, openExtensionCli } from "./extensions/cli.js";
-export { DEPLOYMENT_SECRETS_ORG, type DeploymentConfigField, type DeploymentConfigView, ExtensionDeploymentConfigService, mergeDeploymentConfig, PLUGIN_DEPLOYMENT_CONFIG_TOPIC, readStoredDeploymentConfig, } from "./extensions/deployment-config.js";
+export { DEPLOYMENT_SECRETS_ORG, type DeploymentConfigField, type DeploymentConfigView, ExtensionDeploymentConfigService, mergeDeploymentConfig, PLUGIN_DEPLOYMENT_CONFIG_TOPIC, readStoredDeploymentConfig, type SecretEntry, } from "./extensions/deployment-config.js";
 export { assertSecretsReachable, ExtensionHost, type ExtensionLoadPlan, type InspectedExtension, type InstalledExtensionLoader, type InstallFailureReason, } from "./extensions/host.js";
 export { ExtensionUnloadedError, type InflightEntry, InflightTracker, PLUGIN_UNLOADED_TOOL_ERROR, type TrackOptions, trackCalls, } from "./extensions/inflight.js";
 export { type DesiredExtension, type ExtensionInstallRow, ExtensionInstalls, type IngestSource, type PackageReview, } from "./extensions/installs.js";

package/dist/infra/config/kernel-config.service.js

@@ -34,6 +34,12 @@ const HOT_APPLIERS = {
     "subagents.maxConcurrentPerRun": () => { },
     "subagents.maxDispatchesPerRun": () => { },
     "subagents.maxTokensPerRun": () => { },
+    // The web tools read these limits through the config service on every call.
+    "web.search.maxResults": () => { },
+    "web.fetch.maxPageChars": () => { },
+    "web.fetch.maxAnswerTokens": () => { },
+    "web.fetch.cacheSeconds": () => { },
+    "web.fetch.timeoutMs": () => { },
 };
 const HOT_PATHS = configFields(KernelConfigSchema)
     .filter((f) => f.meta?.hot)

package/dist/infra/database/database.module.js

@@ -66,6 +66,7 @@ let DatabaseModule = class DatabaseModule {
                     const { db } = config.get();
                     return createDb(db.url, db.poolMax, (err) => log.error("pg idle client error", { err }), {
                         connectTimeoutMs: db.connectTimeoutMs,
+                        idleTimeoutMs: db.idleTimeoutMs,
                         onClientError: (err) => log.warn("pg client error", { err }),
                     });
                 },

package/dist/infra/events/kernel-events.d.ts

@@ -78,6 +78,14 @@ export interface KernelEventMap {
     "run.orphaned": {
         runId: string;
     };
+    /**
+     * A background task of the conversation finished (after the commit of its
+     * `background_task_finished` event). `BackgroundWake` asks the run queue for a wake run; a lost
+     * event is re-derived by the next `ensureRun` (a message, the end of a run, a page opening).
+     */
+    "background_task.finished": {
+        conversationId: string;
+    };
 }
 type Handler<K extends keyof KernelEventMap> = (payload: KernelEventMap[K]) => Promise<void> | void;
 /** Typed in-process event emitter; handlers run in order, a failing one is logged and skipped. */

package/dist/infra/lifecycle/process-guards.js

@@ -39,6 +39,10 @@ export function createFatalRecorder(deps) {
     let recent = [];
     let open = false;
     return (kind, err) => {
+        // Exiting already: log nothing more. A failing log write (EPIPE on a dead stdout) raises the
+        // next event itself; logging it again would keep the process busy forever and starve the exit.
+        if (open)
+            return;
         try {
             const t = now();
             recent = recent.filter((x) => t - x < GUARD_CIRCUIT_WINDOW_MS);

package/dist/infra/logging/logging.module.d.ts

@@ -6,8 +6,10 @@ export interface LoggingModuleOptions {
     logger?: KernelLogger;
 }
 /**
- * Provides the process logger as `KERNEL_LOGGER`. The logger is created before the Nest context
- * (it must exist for startup errors), so it is passed in or derived from the startup config here.
+ * Provides the process logger as `KERNEL_ROOT_LOGGER` and, as `KERNEL_LOGGER`, one child per injecting
+ * class with `context` = the class name (the `[context=…]` of the pretty output; octok's
+ * per-class Nest logger context). The logger is created before the Nest context (it must exist for
+ * startup errors), so it is passed in or derived from the startup config here.
  */
 export declare class LoggingModule {
     static forRoot(config: KernelConfig, opts?: LoggingModuleOptions): DynamicModule;

package/dist/infra/logging/logging.module.js

@@ -5,12 +5,15 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 var LoggingModule_1;
-import { Global, Module } from "@nestjs/common";
+import { Global, Module, Scope } from "@nestjs/common";
+import { INQUIRER } from "@nestjs/core";
 import { createConfiguredLogger } from "../../log-config.js";
-import { KERNEL_LOGGER } from "../tokens.js";
+import { KERNEL_LOGGER, KERNEL_ROOT_LOGGER } from "../tokens.js";
 /**
- * Provides the process logger as `KERNEL_LOGGER`. The logger is created before the Nest context
- * (it must exist for startup errors), so it is passed in or derived from the startup config here.
+ * Provides the process logger as `KERNEL_ROOT_LOGGER` and, as `KERNEL_LOGGER`, one child per injecting
+ * class with `context` = the class name (the `[context=…]` of the pretty output; octok's
+ * per-class Nest logger context). The logger is created before the Nest context (it must exist for
+ * startup errors), so it is passed in or derived from the startup config here.
  */
 let LoggingModule = LoggingModule_1 = class LoggingModule {
     static forRoot(config, opts = {}) {
@@ -21,8 +24,16 @@ let LoggingModule = LoggingModule_1 = class LoggingModule {
         return {
             module: LoggingModule_1,
             global: true,
-            providers: [{ provide: KERNEL_LOGGER, useValue: logger }],
-            exports: [KERNEL_LOGGER],
+            providers: [
+                { provide: KERNEL_ROOT_LOGGER, useValue: logger },
+                {
+                    provide: KERNEL_LOGGER,
+                    scope: Scope.TRANSIENT,
+                    inject: [KERNEL_ROOT_LOGGER, INQUIRER],
+                    useFactory: (root, inquirer) => contextLogger(root, inquirer),
+                },
+            ],
+            exports: [KERNEL_ROOT_LOGGER, KERNEL_LOGGER],
         };
     }
 };
@@ -32,3 +43,10 @@ LoggingModule = LoggingModule_1 = __decorate([
     // biome-ignore lint/complexity/noStaticOnlyClass: a Nest dynamic module
 ], LoggingModule);
 export { LoggingModule };
+/** The child of `root` for the class instance `inquirer`; `root` itself for a factory provider. */
+function contextLogger(root, inquirer) {
+    const name = inquirer?.constructor?.name;
+    return typeof name === "string" && name !== "" && name !== "Object"
+        ? root.child({ context: name })
+        : root;
+}

package/dist/infra/queue/redis-connection.d.ts

@@ -1,4 +1,10 @@
 import type { RedisOptions } from "bullmq";
+/**
+ * TCP keepalive of every long-lived kernel Redis connection: probes start after 10 s idle (the OS
+ * default is 2 hours), so a connection a dropped network left half-open is found and reconnected
+ * before a command waits on it, not at the next write (EPIPE).
+ */
+export declare const REDIS_KEEPALIVE_MS = 10000;
 /**
  * BullMQ connection options from the kernel's Redis URL, the same connection the hand-made
  * `new Redis(url, { maxRetriesPerRequest: null })` workers use: BullMQ requires

package/dist/infra/queue/redis-connection.js

@@ -1,3 +1,9 @@
+/**
+ * TCP keepalive of every long-lived kernel Redis connection: probes start after 10 s idle (the OS
+ * default is 2 hours), so a connection a dropped network left half-open is found and reconnected
+ * before a command waits on it, not at the next write (EPIPE).
+ */
+export const REDIS_KEEPALIVE_MS = 10_000;
 /**
  * BullMQ connection options from the kernel's Redis URL, the same connection the hand-made
  * `new Redis(url, { maxRetriesPerRequest: null })` workers use: BullMQ requires
@@ -14,5 +20,6 @@ export function bullConnectionOptions(url) {
         ...(db !== undefined && Number.isInteger(db) && { db }),
         ...(u.protocol === "rediss:" && { tls: {} }),
         maxRetriesPerRequest: null,
+        keepAlive: REDIS_KEEPALIVE_MS,
     };
 }

package/dist/infra/redis/redis.module.js

@@ -14,6 +14,7 @@ import { closeWithin } from "../close-within.js";
 import { KernelConfigService } from "../config/kernel-config.service.js";
 import { GracefulShutdownModule } from "../lifecycle/graceful-shutdown.module.js";
 import { GracefulShutdown } from "../lifecycle/graceful-shutdown.service.js";
+import { REDIS_KEEPALIVE_MS } from "../queue/redis-connection.js";
 import { KERNEL_BUS, KERNEL_LOGGER, REDIS, REDIS_SUBSCRIBER } from "../tokens.js";
 /**
  * Closes the bus subscriber, then the main connection, at the end of the shutdown
@@ -64,7 +65,10 @@ RedisModule = __decorate([
                 provide: REDIS,
                 inject: [KernelConfigService, KERNEL_LOGGER],
                 useFactory: (config, log) => {
-                    const redis = new Redis(config.get().redis.url, { lazyConnect: true });
+                    const redis = new Redis(config.get().redis.url, {
+                        lazyConnect: true,
+                        keepAlive: REDIS_KEEPALIVE_MS,
+                    });
                     redis.on("error", (err) => log.error("redis connection error", { err }));
                     return redis;
                 },
@@ -72,7 +76,7 @@ RedisModule = __decorate([
             {
                 provide: REDIS_SUBSCRIBER,
                 inject: [KernelConfigService, KERNEL_LOGGER],
-                useFactory: (config, log) => createBusSubscriber(() => new Redis(config.get().redis.url), log),
+                useFactory: (config, log) => createBusSubscriber(() => new Redis(config.get().redis.url, { keepAlive: REDIS_KEEPALIVE_MS }), log),
             },
             {
                 provide: KERNEL_BUS,

package/dist/infra/tokens.d.ts

@@ -1,6 +1,11 @@
 /** Injection tokens of the global infra modules. */
-/** The process logger (`KernelLogger`). */
+/**
+ * A class's logger (`KernelLogger`): the process logger with `context` set to the injecting class's
+ * name. Transient, so `app.get` cannot resolve it; use `KERNEL_ROOT_LOGGER` outside an injection.
+ */
 export declare const KERNEL_LOGGER: unique symbol;
+/** The process logger itself (`KernelLogger`), without a context. */
+export declare const KERNEL_ROOT_LOGGER: unique symbol;
 /** The startup input of `KernelConfigService`: `{ config, env }`. */
 export declare const KERNEL_CONFIG_INPUT: unique symbol;
 /** The Kysely pool, untyped (`Kysely<any>`); infra only, services inject `KernelDb`. */

package/dist/infra/tokens.js

@@ -1,6 +1,11 @@
 /** Injection tokens of the global infra modules. */
-/** The process logger (`KernelLogger`). */
+/**
+ * A class's logger (`KernelLogger`): the process logger with `context` set to the injecting class's
+ * name. Transient, so `app.get` cannot resolve it; use `KERNEL_ROOT_LOGGER` outside an injection.
+ */
 export const KERNEL_LOGGER = Symbol("KERNEL_LOGGER");
+/** The process logger itself (`KernelLogger`), without a context. */
+export const KERNEL_ROOT_LOGGER = Symbol("KERNEL_ROOT_LOGGER");
 /** The startup input of `KernelConfigService`: `{ config, env }`. */
 export const KERNEL_CONFIG_INPUT = Symbol("KERNEL_CONFIG_INPUT");
 /** The Kysely pool, untyped (`Kysely<any>`); infra only, services inject `KernelDb`. */

package/dist/lifecycle/kernel-lifecycle.js

@@ -36,6 +36,7 @@ import { GatewayRole } from "../roles/gateway-role.js";
 import { WorkerRole } from "../roles/worker-role.js";
 import { UsageReporter } from "../runtime/usage-report.js";
 import { sandboxConfigWarnings } from "../sandbox/sandbox.service.js";
+import { warnLegacyToolKeys } from "../tools/legacy-data.js";
 import { KERNEL_APP_OPTIONS } from "./tokens.js";
 /**
  * The stop phase budgets. Each phase waits `min(its budget, what is left of the total)`, where the
@@ -193,6 +194,10 @@ let KernelLifecycle = class KernelLifecycle {
         // In flight for the stop: aborted when the shutdown begins, which then waits for its session to end
         await this.shutdown.trackInFlight(migrate(config.db.url, { schema: KERNEL_SCHEMA, dir: KERNEL_MIGRATIONS_DIR }, { connectTimeoutMs: config.db.connectTimeoutMs, signal: this.shutdown.signal }));
         this.checkpoint();
+        // Rows still holding a release-candidate tool key that migration 0063 could not map: one
+        // read-only count, a WARN when there are any (tool naming spec §8.2); never blocks the start
+        await warnLegacyToolKeys(this.kdb.db, this.log).catch((e) => this.log.warn("tools.legacy_key_count_failed", { error: errMsg(e) }));
+        this.checkpoint();
         // official 清单来源按配置同步（幂等；每个副本启动时都做）
         await this.marketplaces.syncOfficialFromConfig();
         // The bootstrap plugins (spec §7), once per manifest across replicas (the Redis lock

package/dist/log.d.ts

@@ -30,6 +30,11 @@ export interface KernelLogger extends Logger {
     redact(text: string): string;
     /** Waits until buffered records reached every output (Loki); never rejects. Call before exit. */
     flush(): Promise<void>;
+    /**
+     * A logger that adds `fields` to every record (e.g. `{ context: "RunWorker" }`); call fields cannot
+     * overwrite them. It shares everything else with this logger: level, secrets, outputs.
+     */
+    child(fields: Record<string, string>): KernelLogger;
 }
 /**
  * 用与 logger 相同的匹配器打码任意文本（工具结果等不经过日志的内容用）：展开规则同 `addOrgSecrets`
@@ -37,13 +42,15 @@ export interface KernelLogger extends Logger {
  * 不得小于匹配器的分桶前缀长度 4）。没有可用的值时原样返回。
  */
 export declare function createRedactor(values: readonly unknown[], minLength?: number): (s: string) => string;
-/** Console format: `pretty` (pino-pretty, one line per record), `json`, or `auto` (pretty on a TTY). */
+/** Console format: `pretty` (pino-pretty), `json`, or `auto` (pretty on a TTY). */
 export declare const LOG_FORMATS: readonly ["auto", "pretty", "json"];
 /** Console format. */
 export type LogFormat = (typeof LOG_FORMATS)[number];
 /** A minimal writable the console output goes to (`process.stdout` by default). */
 export interface LogOutput {
     write(chunk: string): unknown;
+    /** A stream's `error` event (EPIPE when its reader is gone). */
+    on?(event: "error", listener: (err: unknown) => void): unknown;
 }
 /** Options of {@link createLogger}. */
 export interface LoggerOptions {
@@ -58,6 +65,11 @@ export interface LoggerOptions {
     out?: LogOutput;
     /** Whether the console is a terminal (picks `auto` and colors); default `process.stdout.isTTY`. */
     isTTY?: boolean;
+    /**
+     * Pretty output in colors; default: `FORCE_COLOR` (set and not `0`) turns them on, `NO_COLOR` off,
+     * else a TTY. `pnpm dev:kernel` forces them, since its output goes through `tee`.
+     */
+    colors?: boolean;
     /** Also push every record to Loki. */
     loki?: LokiOptions;
     /** Fields on every record (e.g. `role`); log calls cannot overwrite them. */

package/dist/log.js

@@ -105,15 +105,16 @@ function expandSecret(value) {
     }
     return out;
 }
-/** Console format: `pretty` (pino-pretty, one line per record), `json`, or `auto` (pretty on a TTY). */
+/** Console format: `pretty` (pino-pretty), `json`, or `auto` (pretty on a TTY). */
 export const LOG_FORMATS = ["auto", "pretty", "json"];
-/** Fields shown in the pretty prefix instead of the trailing object, in this order. */
-const PREFIX_FIELDS = ["reqId", "traceId", "jobId", "runId", "plugin"];
-/** pino-pretty's message format: `[role] [reqId=…] [plugin=…] msg`, each part only when present. */
+/** Fields shown in the pretty prefix instead of the lines below, in this order. */
+const PREFIX_FIELDS = ["traceId", "reqId", "queue", "jobId", "runId", "context", "plugin"];
+/**
+ * pino-pretty's message format, the octok layout:
+ * `[pid=…] - [traceId=…] [reqId=…] [context=…] msg`, each bracket only when present.
+ */
 function prettyMessage(log, messageKey) {
-    const parts = [];
-    if (typeof log.role === "string")
-        parts.push(`[${log.role}]`);
+    const parts = [`[pid=${process.pid}] -`];
     for (const k of PREFIX_FIELDS) {
         const v = log[k];
         if (typeof v === "string" || typeof v === "number")
@@ -122,6 +123,24 @@ function prettyMessage(log, messageKey) {
     parts.push(String(log[messageKey] ?? ""));
     return parts.join(" ");
 }
+/** The HTTP access record (`http/app.ts`) as one sentence: method, path, status and duration. */
+function foldAccessLine(log) {
+    if (log.msg !== "request" || typeof log.method !== "string" || typeof log.url !== "string") {
+        return log;
+    }
+    const { method, url, status, ms, ...rest } = log;
+    return { ...rest, msg: `${method} ${url} ${status} ${ms}ms` };
+}
+function colorsOn(opts, isTTY) {
+    if (opts.colors !== undefined)
+        return opts.colors;
+    const force = process.env.FORCE_COLOR;
+    if (force !== undefined && force !== "0")
+        return true;
+    if (process.env.NO_COLOR)
+        return false;
+    return isTTY;
+}
 function consoleStream(opts) {
     if (opts.write) {
         const write = opts.write;
@@ -132,23 +151,50 @@ function consoleStream(opts) {
     if (!LOG_FORMATS.includes(format)) {
         throw new Error(`invalid log.format "${format}" (expected ${LOG_FORMATS.join(", ")})`);
     }
-    const out = opts.out ?? process.stdout;
+    const target = opts.out ?? process.stdout;
+    // A console whose reader is gone (the `tee` of `pnpm dev:kernel` stopped by Ctrl-C, a closed
+    // pipe) fails every write with EPIPE. Unhandled, each failure is an uncaught exception the
+    // process guard logs, which writes again: an endless chain that starves the event loop. So the
+    // first stream error ends console output for good (Loki, when configured, still gets records).
+    let broken = false;
+    target.on?.("error", () => {
+        broken = true;
+    });
+    const out = {
+        write: (s) => {
+            if (!broken)
+                target.write(s);
+        },
+    };
     const isTTY = opts.isTTY ?? process.stdout.isTTY === true;
     const pretty = format === "pretty" || (format === "auto" && isTTY);
     if (!pretty)
         return { write: (s) => out.write(s) };
-    // In process (no worker thread): pino-pretty formats each line synchronously.
+    const colors = colorsOn(opts, isTTY);
+    // In process (no worker thread): pino-pretty formats each record synchronously. The layout follows
+    // octok's buildPinoPrettyOptions: full local time, colored level, the bracket prefix, and
+    // the remaining fields as indented `key: value` lines below the message (errors with their stack).
     const format_ = prettyFactory({
-        colorize: isTTY,
-        colorizeObjects: isTTY,
-        singleLine: true,
-        // errors stay inside the one-line object instead of a multi-line stack block
-        errorLikeObjectKeys: [],
-        translateTime: "SYS:HH:MM:ss.l",
+        colorize: colors,
+        colorizeObjects: colors,
+        singleLine: false,
+        translateTime: "SYS:standard",
         ignore: ["pid", "hostname", "role", "spanId", ...PREFIX_FIELDS].join(","),
         messageFormat: (log, messageKey) => prettyMessage(log, messageKey),
     });
-    return { write: (s) => out.write(format_(s)) };
+    return {
+        write: (s) => {
+            let record;
+            try {
+                record = JSON.parse(s);
+            }
+            catch {
+                out.write(s);
+                return;
+            }
+            out.write(format_(foldAccessLine(record)));
+        },
+    };
 }
 /**
  * Creates the kernel logger on pino. Each record is `{ time, level, msg, ...base, ...fields }` with
@@ -254,7 +300,7 @@ export function createLogger(level = "info", opts = {}) {
         }
         sink[lvl](obj, redactMsg(msg));
     };
-    return {
+    const root = {
         debug: (msg, fields) => emit("debug", msg, fields),
         info: (msg, fields) => emit("info", msg, fields),
         warn: (msg, fields) => emit("warn", msg, fields),
@@ -299,5 +345,35 @@ export function createLogger(level = "info", opts = {}) {
                 }
             }
         },
+        // a method, so a wrapper of this logger (a test proxy) is the parent its children forward to
+        child(fields) {
+            return childLogger(this, fields);
+        },
+    };
+    return root;
+}
+/**
+ * A logger that adds `bound` to every record and forwards it to `parent`'s public methods (so a spy
+ * on the parent sees its children's records); call fields cannot overwrite the bound ones.
+ */
+function childLogger(parent, bound) {
+    const merged = (fields) => ({ ...fields, ...bound });
+    const child = {
+        debug: (msg, fields) => parent.debug(msg, merged(fields)),
+        info: (msg, fields) => parent.info(msg, merged(fields)),
+        warn: (msg, fields) => parent.warn(msg, merged(fields)),
+        error: (msg, fields) => parent.error(msg, merged(fields)),
+        get level() {
+            return parent.level;
+        },
+        setLevel: (level) => parent.setLevel(level),
+        addSecrets: (values) => parent.addSecrets(values),
+        addOrgSecrets: (values) => parent.addOrgSecrets(values),
+        redact: (text) => parent.redact(text),
+        flush: () => parent.flush(),
+        child(fields) {
+            return childLogger(this, fields);
+        },
     };
+    return child;
 }

package/dist/models/purposes.d.ts

@@ -35,6 +35,13 @@ 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";
@@ -140,6 +147,19 @@ export declare class ModelPurposesService {
     setOrg(orgId: string, purpose: string, target: PurposeTarget | null, actor: string, actorTokenId?: string): Promise<PurposeView>;
     /** 生效的映射：组织覆盖，否则部署默认；都没有 → `model.unconfigured`；用途未声明 → `model.purpose_unknown`。 */
     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)`。
@@ -147,10 +167,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;

package/dist/models/purposes.js

@@ -41,6 +41,11 @@ 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",
@@ -254,6 +259,27 @@ let ModelPurposesService = class ModelPurposesService {
         }
         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(target.model);
+        return { contextWindow: info.contextWindow, maxOutputTokens: info.maxOutputTokens };
+    }
     /**
      * 按用途发一次对话请求：解析映射、按目标模型的声明宽松处理参数（补默认值，与运行时一致），用 `consumeModelStream`
      * 收完（只有流空闲看门狗）。输出上限取 `min(req.maxOutputTokens, 目标模型的 maxOutputTokens)`。
@@ -261,22 +287,17 @@ let ModelPurposesService = 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 target = await this.chatTarget(orgId, purpose, opts.fallback);
         const { provider, info } = await this.providers.resolve(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),
         };

package/dist/orgs/offboarding.d.ts

@@ -83,7 +83,9 @@ export declare class Offboarding {
      * In the caller's transaction (`mandatory`: the caller holds the org row lock, order org row →
      * membership, and did the "last owner" checks)：
      * 1. 删除成员关系（非成员 → `member.not_found`；删后组织没有 owner → `org.last_owner`），清空指向该组织的会话当前组织；
-     * 2. 吊销该账号**全部**会话与个人令牌（令牌与会话是账号级的，无法只吊销「该组织下」的，按保守处理）；
+     * 2. Removal and directory offboarding revoke **every** session and personal token of the
+     *    account (both are account-wide, so conservatively all); a person who leaves (`left`) keeps
+     *    them, and the session's current org is cleared (the membership check ends the access);
      * 3. 删除其在该组织所有连接器上的个人凭据；
      * 4. 取消其作为处理人的 pending 审批与提问（写 cancelled 事件），记下此人在该组织进行中的运行（提交后中止）；
      * 5. 其负责的该组织 agent 转给组织所有者（最早加入的 owner）并置 `needs_reassignment = true`；

package/dist/orgs/offboarding.js

@@ -83,7 +83,9 @@ let Offboarding = class Offboarding {
      * In the caller's transaction (`mandatory`: the caller holds the org row lock, order org row →
      * membership, and did the "last owner" checks)：
      * 1. 删除成员关系（非成员 → `member.not_found`；删后组织没有 owner → `org.last_owner`），清空指向该组织的会话当前组织；
-     * 2. 吊销该账号**全部**会话与个人令牌（令牌与会话是账号级的，无法只吊销「该组织下」的，按保守处理）；
+     * 2. Removal and directory offboarding revoke **every** session and personal token of the
+     *    account (both are account-wide, so conservatively all); a person who leaves (`left`) keeps
+     *    them, and the session's current org is cleared (the membership check ends the access);
      * 3. 删除其在该组织所有连接器上的个人凭据；
      * 4. 取消其作为处理人的 pending 审批与提问（写 cancelled 事件），记下此人在该组织进行中的运行（提交后中止）；
      * 5. 其负责的该组织 agent 转给组织所有者（最早加入的 owner）并置 `needs_reassignment = true`；
@@ -150,21 +152,29 @@ let Offboarding = class Offboarding {
             .where("account_id", "=", accountId)
             .where("current_org_id", "=", orgId)
             .execute();
-        const sessions = await this.db
-            .updateTable("sessions")
-            .set({ revoked_at: sql `now()` })
-            .where("account_id", "=", accountId)
-            .where("revoked_at", "is", null)
-            .returning("id")
-            .execute();
-        const tokens = await this.db
-            .updateTable("api_tokens")
-            .set({ revoked_at: sql `now()` })
-            .where("kind", "=", "personal")
-            .where("account_id", "=", accountId)
-            .where("revoked_at", "is", null)
-            .returning("id")
-            .execute();
+        // A person who leaves keeps their sign-in and personal tokens: the org guard reads the
+        // membership on every request, so access to this org ends with the row above, and their other
+        // orgs keep working. Removal and directory offboarding revoke both (account-wide, conservative).
+        const revoke = reason !== "left";
+        const sessions = revoke
+            ? await this.db
+                .updateTable("sessions")
+                .set({ revoked_at: sql `now()` })
+                .where("account_id", "=", accountId)
+                .where("revoked_at", "is", null)
+                .returning("id")
+                .execute()
+            : [];
+        const tokens = revoke
+            ? await this.db
+                .updateTable("api_tokens")
+                .set({ revoked_at: sql `now()` })
+                .where("kind", "=", "personal")
+                .where("account_id", "=", accountId)
+                .where("revoked_at", "is", null)
+                .returning("id")
+                .execute()
+            : [];
         // in this transaction (the approvals and questions services join it: `mandatory`)
         const credentials = await this.credentials.clearAccount(orgId, accountId);
         const approvals = await this.approvals.cancelPendingFor(orgId, accountId);