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

package/dist/catalog/unshare.js

@@ -0,0 +1,118 @@
+// Turning 可共享 off on an org-owned item (ruling P3-25): an `optional` / `all` scope is narrowed, in
+// the caller's transaction, to `named` = the owner plus every live org where the item is on right
+// now, so the orgs already associated keep it and no new org can see, switch on or request it
+// (§14.1 item 3). A `named` scope is left as it is: the gate in `requestable` and the writers
+// already holds back new orgs there.
+import { sql } from "kysely";
+import { audit } from "../identity/audit.js";
+import { componentOn, listedIn, loadScopeState, pluginFactsOf, switchOf, } from "./component-state.js";
+const LIVE_INSTALL = ["installing", "installed", "upgrading"];
+async function liveOrgIds(db) {
+    const rows = await db.selectFrom("orgs").select("id").where("deleted_at", "is", null).execute();
+    return rows.map((r) => r.id);
+}
+/**
+ * Narrows an org-owned plugin (row locked by the caller) whose scope is `optional` / `all` to
+ * `named` = owner + the live orgs with a live install or a switch on. Bumps `scope_version` and
+ * audits `catalog.scope_changed`; returns whether the scope changed (the caller enqueues the item's
+ * scope sync after the commit).
+ */
+export async function narrowItemOnUnshare(db, actor, item) {
+    if (item.owner_org_id === null || item.scope === "named")
+        return false;
+    const live = new Set(await liveOrgIds(db));
+    const installs = await db
+        .selectFrom("plugin_installs")
+        .select("org_id")
+        .where("item_id", "=", item.id)
+        .where("status", "in", [...LIVE_INSTALL])
+        .execute();
+    const switches = await db
+        .selectFrom("catalog_item_org_switches")
+        .select("org_id")
+        .where("item_id", "=", item.id)
+        .where("enabled", "=", true)
+        .execute();
+    const orgs = [
+        ...new Set([
+            item.owner_org_id,
+            ...[...installs, ...switches].map((r) => r.org_id).filter((o) => live.has(o)),
+        ]),
+    ].sort();
+    await db
+        .updateTable("catalog_items")
+        .set({
+        scope: "named",
+        scope_version: sql `scope_version + 1`,
+        updated_at: sql `now()`,
+    })
+        .where("id", "=", item.id)
+        .execute();
+    await db.deleteFrom("catalog_item_scope_orgs").where("item_id", "=", item.id).execute();
+    await db
+        .insertInto("catalog_item_scope_orgs")
+        .values(orgs.map((org_id) => ({ item_id: item.id, org_id })))
+        .execute();
+    await audit(db, {
+        ...(actor !== null && { actorAccountId: actor }),
+        action: "catalog.scope_changed",
+        target: item.id,
+        detail: {
+            name: item.name,
+            from: { scope: item.scope, orgs: [] },
+            to: { scope: "named", orgs },
+            reason: "unshared",
+        },
+    });
+    return true;
+}
+/**
+ * Narrows an org-owned component with its own `optional` / `all` scope (row locked by the caller)
+ * to `named` = owner + the live orgs where it is on now ({@link componentOn}). A component that
+ * follows its plugin is narrowed with the plugin. Bumps `scope_version`, audits
+ * `component.scope_changed`.
+ */
+export async function narrowComponentOnUnshare(db, actor, c) {
+    if (c.ownerOrgId === null || c.scopeMode !== "own" || c.scope === "named")
+        return false;
+    const st = await loadScopeState(db, c.kind, [c]);
+    const on = (await liveOrgIds(db)).filter((o) => componentOn(c, pluginFactsOf(st, c.itemId, o), listedIn(st, c.id, o), switchOf(st, c.id, o)));
+    const orgs = [...new Set([c.ownerOrgId, ...on])].sort();
+    await db
+        .updateTable(TABLE[c.kind])
+        .set({
+        scope: "named",
+        scope_version: sql `scope_version + 1`,
+        updated_at: sql `now()`,
+    })
+        .where("id", "=", c.id)
+        .execute();
+    await db
+        .deleteFrom("component_scope_orgs")
+        .where("kind", "=", c.kind)
+        .where("component_id", "=", c.id)
+        .execute();
+    await db
+        .insertInto("component_scope_orgs")
+        .values(orgs.map((org_id) => ({ kind: c.kind, component_id: c.id, org_id })))
+        .execute();
+    await audit(db, {
+        ...(actor !== null && { actorAccountId: actor }),
+        action: "component.scope_changed",
+        target: c.id,
+        detail: {
+            kind: c.kind,
+            name: c.name,
+            plugin: c.plugin,
+            from: { scopeMode: "own", scope: c.scope, orgs: [] },
+            to: { scopeMode: "own", scope: "named", orgs },
+            reason: "unshared",
+        },
+    });
+    return true;
+}
+const TABLE = {
+    skill: "platform_skills",
+    agent_template: "platform_agent_templates",
+    connector_template: "platform_connector_templates",
+};

package/dist/channels/actions.js

@@ -11,6 +11,7 @@ const REPLY_FOR = {
     "approval.already_decided": "alreadyHandled",
     "question.already_answered": "alreadyHandled",
     validation_failed: "invalidAction",
+    "approval.scope_not_allowed": "invalidAction",
 };
 /**
  * IM 卡片上的按钮操作（Review Focus 2）：点击者按入站同样的规则映射到账号（未绑定 → 私聊回绑定卡片、群里只提示去私聊），

package/dist/channels/cards.js

@@ -76,6 +76,18 @@ export function inputPreview(input, redact = (s) => s) {
     }
     return s.length <= INPUT_PREVIEW_MAX ? s : `${s.slice(0, INPUT_PREVIEW_MAX - 1)}…`;
 }
+/**
+ * The card's input line: the kernel-rendered summary of the call (Platform operations) in the
+ * card's language first, then the params; the card has no separate summary field.
+ */
+function previewWithSummary(v, locale, redact) {
+    const params = inputPreview(v.input, redact);
+    if (v.summary === null)
+        return params;
+    const text = redact ? redact(v.summary[locale]) : v.summary[locale];
+    const summary = text.length <= INPUT_PREVIEW_MAX ? text : `${text.slice(0, INPUT_PREVIEW_MAX - 1)}…`;
+    return `${summary}\n${params}`;
+}
 /** 去掉末尾斜杠的 `http.publicUrl`；未配置返回 undefined。 */
 export function webBase(publicUrl) {
     return publicUrl ? publicUrl.replace(/\/+$/, "") : undefined;
@@ -84,12 +96,17 @@ export function webBase(publicUrl) {
 export const conversationUrl = (base, conversationId) => `${base}/chat/${conversationId}`;
 /** 个人连接页里某个连接器的位置（与网页 ConnectCard 的链接一致）。 */
 export const connectUrl = (base, connectorId) => `${base}/account/connections#connector-${encodeURIComponent(connectorId)}`;
+const PLATFORM_KEY_PREFIX = "Platform:";
 /**
  * The tool as the card names it (tool naming spec §7): a builtin by its name; a connector or
  * extension tool as `<display name> [<tool>]` (the connector's name, the plugin's display name in
  * the card's language), the way the web labels it.
  */
 export function approvalToolName(v, locale) {
+    // a Platform call is keyed `Platform:<operation>`: the label names the operation
+    if (v.toolKey.startsWith(PLATFORM_KEY_PREFIX)) {
+        return `Platform [${v.toolKey.slice(PLATFORM_KEY_PREFIX.length)}]`;
+    }
     // `toolName` is already the connector's own name for its tool
     if (v.connector)
         return `${v.connector.name} [${v.toolName}]`;
@@ -126,8 +143,9 @@ export async function approvalCard(d, approvalId, base, locale, redact) {
         // the label carries the source, so no separate appName (renderers would repeat it)
         toolName: approvalToolName(v, locale),
         agentName: v.agent.name || "Agent",
-        inputPreview: inputPreview(v.input, redact),
-        scopes: v.requestedFor === null ? ["once"] : ["once", "session", "always"],
+        inputPreview: previewWithSummary(v, locale, redact),
+        // the scopes the approval allows (the kernel stores them for per-call policies)
+        scopes: v.scopes,
         expiresAt: v.expiresAt,
         state: v.status,
         ...(decidedBy !== undefined && { decidedBy }),

package/dist/channels/channels.module.js

@@ -12,6 +12,7 @@ import { OnWorkerEvent, WorkerHost } from "@nestjs/bullmq";
 import { Inject, Injectable, Module } from "@nestjs/common";
 import { ConversationsModule } from "../conversations/conversations.module.js";
 import { EventLogModule } from "../conversations/event-log.js";
+import { EnvironmentsModule } from "../environments/environments.module.js";
 import { ExtensionsModule } from "../extensions/extensions.module.js";
 import { IdentityModule } from "../identity/identity.module.js";
 import { configuredProcessor, } from "../infra/queue/configured-processor.js";
@@ -38,6 +39,7 @@ let ChannelsModule = class ChannelsModule {
 ChannelsModule = __decorate([
     Module({
         imports: [
+            EnvironmentsModule,
             EventLogModule,
             ExtensionsModule,
             IdentityModule,

package/dist/channels/inbound.d.ts

@@ -1,6 +1,7 @@
 import type { ChannelCard, InboundEvent, InboundSender, Logger } from "@capybara-hq/plugin-sdk";
 import type { Redis } from "ioredis";
 import { ConversationsService } from "../conversations/conversations.service.js";
+import { EnvironmentsService } from "../environments/environments.service.js";
 import { IdentityBinding } from "../identity/binding.js";
 import { ExternalIdentities } from "../identity/external.js";
 import { KernelDb } from "../infra/database/kernel-db.js";
@@ -62,6 +63,7 @@ export declare class ChannelInbound {
     /** The channel queue: inbound jobs (`onEvent` only dedupes and enqueues) and deliveries. */
     private readonly jobs;
     private readonly guests;
+    private readonly environments;
     private readonly log;
     private readonly actions;
     constructor(kdb: KernelDb, redis: Pick<Redis, "set">, 
@@ -72,7 +74,7 @@ export declare class ChannelInbound {
     /** The channel queue: inbound jobs (`onEvent` only dedupes and enqueues) and deliveries. */
     jobs: Pick<ChannelJobs, "enqueue" | "enqueueInbound">, 
     /** 卡片操作：审批决定与提问回答（授权由这两个服务按点击者映射到的账号判定）。 */
-    approvals: Pick<ApprovalsService, "decide">, questions: Pick<QuestionsService, "answer">, guests: Pick<AnonymousGuests, "ensure">, log: Pick<Logger, "warn" | "info">);
+    approvals: Pick<ApprovalsService, "decide">, questions: Pick<QuestionsService, "answer">, guests: Pick<AnonymousGuests, "ensure">, environments: Pick<EnvironmentsService, "list" | "imDefault" | "setImDefault">, log: Pick<Logger, "warn" | "info">);
     /**
      * 插件 `onEvent`：去重并入队后返回（见类注释）。返回后插件才向平台确认；抛错时插件不确认。
      */
@@ -92,6 +94,12 @@ export declare class ChannelInbound {
     /** 入站任务的处理（worker 上执行；失败抛错由队列重试）。 */
     handle(connectionId: string, e: InboundEvent): Promise<void>;
     private message;
+    /**
+     * Direct-message `/env` (environments spec §4.2 item 8): lists the person's usable environments,
+     * or with a name sets the IM default their next new conversation is bound to. The name matches
+     * case-insensitively; the default environment (no name) answers to 个人环境 / Personal.
+     */
+    private envCommand;
     /**
      * Posts the person's message: `/name args` as a skill invocation when the kernel accepts it, else
      * as typed (phase D spec §9). A retry of the job finds the first write by `clientMessageId`

package/dist/channels/inbound.js

@@ -10,6 +10,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 import { randomUUID } from "node:crypto";
 import { Inject, Injectable } from "@nestjs/common";
 import { ConversationsService } from "../conversations/conversations.service.js";
+import { EnvironmentsService } from "../environments/environments.service.js";
 import { ApiError } from "../errors.js";
 import { IdentityBinding } from "../identity/binding.js";
 import { ExternalIdentities } from "../identity/external.js";
@@ -73,6 +74,7 @@ let ChannelInbound = class ChannelInbound {
     directorySync;
     jobs;
     guests;
+    environments;
     log;
     actions;
     constructor(kdb, redis, 
@@ -83,7 +85,7 @@ let ChannelInbound = class ChannelInbound {
     /** The channel queue: inbound jobs (`onEvent` only dedupes and enqueues) and deliveries. */
     jobs, 
     /** 卡片操作：审批决定与提问回答（授权由这两个服务按点击者映射到的账号判定）。 */
-    approvals, questions, guests, log) {
+    approvals, questions, guests, environments, log) {
         this.kdb = kdb;
         this.redis = redis;
         this.locks = locks;
@@ -94,6 +96,7 @@ let ChannelInbound = class ChannelInbound {
         this.directorySync = directorySync;
         this.jobs = jobs;
         this.guests = guests;
+        this.environments = environments;
         this.log = log;
         this.actions = new ChannelCardActions({
             get db() {
@@ -185,9 +188,10 @@ let ChannelInbound = class ChannelInbound {
         const { locale } = await readOrgSettings(db, row.orgId);
         // 回复带幂等键：任务重试时平台不会重复显示（一条消息至多一句回复）
         const replyKey = idempotencyKey(`${connectionId}-${e.messageId}-reply`);
-        const reply = async (key, cards) => {
-            await connections.send(connectionId, replyTarget, { text: phrase(key, locale), ...(cards !== undefined && { cards }) }, replyKey);
+        const replyText = async (text, cards) => {
+            await connections.send(connectionId, replyTarget, { text, ...(cards !== undefined && { cards }) }, replyKey);
         };
+        const reply = (key, cards) => replyText(phrase(key, locale), cards);
         const speaker = await this.resolveSpeaker(connectionId, row, e.sender, isGroup, locale, reply);
         if (speaker === undefined)
             return;
@@ -203,11 +207,19 @@ let ChannelInbound = class ChannelInbound {
             await reply("newConversation");
             return;
         }
+        const envCommand = !isGroup && threadAccount !== null ? parseEnvCommand(e.text) : null;
+        if (envCommand !== null) {
+            await this.envCommand(row.orgId, accountId, envCommand.name, locale, replyText);
+            return;
+        }
         let conversationId = await findThread(db, k);
         if (conversationId === undefined) {
             let created;
             try {
-                created = (await this.conversations.create(row.orgId, accountId, row.agentId)).id;
+                // bound to the person's IM default environment, else their default (environments spec
+                // §4.2 item 8); an anonymous sender's stays unbound (no sandbox)
+                created = (await this.conversations.create(row.orgId, accountId, row.agentId, { im: true }))
+                    .id;
             }
             catch (err) {
                 if (err instanceof ApiError && err.code === "agent.not_found") {
@@ -267,6 +279,47 @@ let ChannelInbound = class ChannelInbound {
             .execute();
         await this.jobs.enqueue(conversationId);
     }
+    /**
+     * Direct-message `/env` (environments spec §4.2 item 8): lists the person's usable environments,
+     * or with a name sets the IM default their next new conversation is bound to. The name matches
+     * case-insensitively; the default environment (no name) answers to 个人环境 / Personal.
+     */
+    async envCommand(orgId, accountId, name, locale, replyText) {
+        const { items, defaultId } = await this.environments.list(orgId, accountId);
+        const usable = items.filter((v) => v.available);
+        const labelOf = (v) => v.name ?? phrase("envPersonal", locale);
+        const current = (await this.environments.imDefault(orgId, accountId)) ?? defaultId;
+        const list = usable
+            .map((v) => `- ${labelOf(v)}${v.id === current ? phrase("envCurrent", locale) : ""}`)
+            .join("\n");
+        const fill = (key, vars) => phrase(key, locale).replace(/\{(\w+)\}/g, (m, k) => vars[k] ?? m);
+        if (usable.length === 0)
+            return replyText(phrase("envNone", locale));
+        if (name === null)
+            return replyText(fill("envList", { list }));
+        const wanted = name.toLowerCase();
+        // an environment the person named "Personal" wins over the default's alias
+        const hit = usable.find((v) => v.name !== null && v.name.toLowerCase() === wanted) ??
+            usable.find((v) => v.name === null && (wanted === "personal" || wanted === "个人环境"));
+        if (hit === undefined) {
+            const unavailable = items.find((v) => !v.available && v.name !== null && v.name.toLowerCase() === wanted);
+            if (unavailable !== undefined) {
+                return replyText(fill("envUnavailable", { name: unavailable.name, list }));
+            }
+            return replyText(fill("envUnknown", { name, list }));
+        }
+        try {
+            await this.environments.setImDefault(orgId, accountId, hit.id);
+        }
+        catch (err) {
+            // deleted or made unusable since the list was read
+            if (err instanceof ApiError && err.code.startsWith("environment.")) {
+                return replyText(fill("envUnknown", { name, list }));
+            }
+            throw err;
+        }
+        return replyText(fill("envSwitched", { name: labelOf(hit) }));
+    }
     /**
      * Posts the person's message: `/name args` as a skill invocation when the kernel accepts it, else
      * as typed (phase D spec §9). A retry of the job finds the first write by `clientMessageId`
@@ -393,6 +446,15 @@ ChannelInbound = __decorate([
     __param(9, Inject(ApprovalsService)),
     __param(10, Inject(QuestionsService)),
     __param(11, Inject(AnonymousGuests)),
-    __param(12, Inject(KERNEL_LOGGER))
+    __param(12, Inject(EnvironmentsService)),
+    __param(13, Inject(KERNEL_LOGGER))
 ], ChannelInbound);
 export { ChannelInbound };
+/** `/env` or `/env <name>` (the exact command word, case-insensitive); anything else is null. */
+function parseEnvCommand(text) {
+    const m = /^\/env(?:\s+([\s\S]*))?$/i.exec(text.trim());
+    if (m === null)
+        return null;
+    const name = m[1]?.trim();
+    return { name: name ? name : null };
+}

package/dist/channels/phrases.d.ts

@@ -10,6 +10,41 @@ export declare const CHANNEL_PHRASES: {
         readonly zh: "已开始新对话";
         readonly en: "Started a new conversation.";
     };
+    /** 私聊 `/env`：列出可用环境（`{list}` 每行一个，当前的带标记）。 */
+    readonly envList: {
+        readonly zh: "你的环境：\n{list}\n发送 /env <名称> 选择下一个新对话使用的环境。";
+        readonly en: "Your environments:\n{list}\nSend /env <name> to choose the one your next new conversation uses.";
+    };
+    /** 私聊 `/env <名称>` 之后（`{name}` 是环境名）。 */
+    readonly envSwitched: {
+        readonly zh: "下一个新对话将使用环境「{name}」，发送 /new 开始。";
+        readonly en: "Your next new conversation will use the environment “{name}”; send /new to start one.";
+    };
+    /** 私聊 `/env <名称>` 没有匹配的可用环境（`{list}` 同 envList）。 */
+    readonly envUnknown: {
+        readonly zh: "没有找到名为「{name}」的环境。你的环境：\n{list}";
+        readonly en: "No environment named “{name}”. Your environments:\n{list}";
+    };
+    /** `/env <name>` names an existing environment that is unavailable now (`{list}` as in envList). */
+    readonly envUnavailable: {
+        readonly zh: "环境「{name}」当前不可用（它的文件由未启用的沙箱提供方保存）。你的环境：\n{list}";
+        readonly en: "The environment “{name}” is unavailable: its files are kept by a sandbox provider that is not active. Your environments:\n{list}";
+    };
+    /** 私聊 `/env` 时此人没有可用环境（部署没有云沙箱）。 */
+    readonly envNone: {
+        readonly zh: "你目前没有可用的环境。";
+        readonly en: "You have no usable environments.";
+    };
+    /** 环境列表里默认环境的名字。 */
+    readonly envPersonal: {
+        readonly zh: "个人环境";
+        readonly en: "Personal";
+    };
+    /** 环境列表里当前 IM 默认环境的标记。 */
+    readonly envCurrent: {
+        readonly zh: "（当前）";
+        readonly en: " (current)";
+    };
     /** 未绑定的人在私聊里发消息：附绑定卡片。 */
     readonly bindPrompt: {
         readonly zh: "请先绑定你的 Capybara 账号，再与我对话。";

package/dist/channels/phrases.js

@@ -5,6 +5,35 @@
 export const CHANNEL_PHRASES = {
     /** 私聊 `/new` 之后。 */
     newConversation: { zh: "已开始新对话", en: "Started a new conversation." },
+    /** 私聊 `/env`：列出可用环境（`{list}` 每行一个，当前的带标记）。 */
+    envList: {
+        zh: "你的环境：\n{list}\n发送 /env <名称> 选择下一个新对话使用的环境。",
+        en: "Your environments:\n{list}\nSend /env <name> to choose the one your next new conversation uses.",
+    },
+    /** 私聊 `/env <名称>` 之后（`{name}` 是环境名）。 */
+    envSwitched: {
+        zh: "下一个新对话将使用环境「{name}」，发送 /new 开始。",
+        en: "Your next new conversation will use the environment \u201c{name}\u201d; send /new to start one.",
+    },
+    /** 私聊 `/env <名称>` 没有匹配的可用环境（`{list}` 同 envList）。 */
+    envUnknown: {
+        zh: "没有找到名为「{name}」的环境。你的环境：\n{list}",
+        en: "No environment named \u201c{name}\u201d. Your environments:\n{list}",
+    },
+    /** `/env <name>` names an existing environment that is unavailable now (`{list}` as in envList). */
+    envUnavailable: {
+        zh: "环境「{name}」当前不可用（它的文件由未启用的沙箱提供方保存）。你的环境：\n{list}",
+        en: "The environment \u201c{name}\u201d is unavailable: its files are kept by a sandbox provider that is not active. Your environments:\n{list}",
+    },
+    /** 私聊 `/env` 时此人没有可用环境（部署没有云沙箱）。 */
+    envNone: {
+        zh: "你目前没有可用的环境。",
+        en: "You have no usable environments.",
+    },
+    /** 环境列表里默认环境的名字。 */
+    envPersonal: { zh: "个人环境", en: "Personal" },
+    /** 环境列表里当前 IM 默认环境的标记。 */
+    envCurrent: { zh: "（当前）", en: " (current)" },
     /** 未绑定的人在私聊里发消息：附绑定卡片。 */
     bindPrompt: {
         zh: "请先绑定你的 Capybara 账号，再与我对话。",

package/dist/config/docs.js

@@ -63,6 +63,7 @@ export function renderConfigDocs(schema) {
         // body and package upload limits), apps/web/server.mjs (PORT / CAPYBARA_WEB_HOST) and
         // apps/web/src/dev/catalog/routes.tsx (CAPYBARA_DEV_UI); change this text together with them.
         // CAPYBARA_WEB_TRUST_PROXY: apps/web/src/lib/peer.ts; CAPYBARA_WEB_SHUTDOWN_GRACE_MS: apps/web/server.mjs.
+        // CAPYBARA_WEB_KEEP_ALIVE_TIMEOUT_MS: apps/web/src/lib/keep-alive.ts.
         // CAPYBARA_WEB_OBJECT_STORE_*: apps/web/src/lib/object-store-proxy.ts.
         "## Web tier (apps/web) environment variables",
         "",
@@ -74,8 +75,9 @@ export function renderConfigDocs(schema) {
         "| `PORT` / `CAPYBARA_WEB_HOST` | The web tier's listen port (default 3000) and address |",
         "| `CAPYBARA_WEB_TRUST_PROXY` | Proxies in front of the web tier (TLS proxy, load balancer) trusted to report the client address in `X-Forwarded-For`: a hop count (`1` = the nearest proxy) or a list of IPs / CIDRs, comma-separated or a JSON array, in the grammar of `http.trustProxy` (dotted netmasks, `loopback` / `linklocal` / `uniquelocal`; a range that trusts every address such as `/0` is refused; no `true` / `false`). Unset (default) trusts nothing: the socket peer is the client, so behind a proxy every user shares the proxy's address for login rate limiting. A hop count is only safe when the web tier is reachable solely through exactly that many proxies. Either way the kernel receives one sanitized client address; a malformed value stops the web tier at startup |",
         "| `CAPYBARA_WEB_SHUTDOWN_GRACE_MS` | Production only: after SIGTERM / SIGINT, how long in-flight requests (including SSE streams) may run before the process exits; default 5000 |",
+        "| `CAPYBARA_WEB_KEEP_ALIVE_TIMEOUT_MS` | How long an idle HTTP keep-alive connection to the web tier stays open, in milliseconds; default 65000. Keep it above the idle timeout of any load balancer or proxy in front of the web tier (often 60 s): otherwise the web tier may close a connection just as the proxy reuses it, and that request fails (a 502 at the proxy). A value that is not a positive integer stops the web tier at startup |",
         "| `CAPYBARA_WEB_MAX_BODY_BYTES` | Request body limit of the `/api/*` proxy, default 1 MiB (matches the kernel's bodyLimit) |",
-        "| `CAPYBARA_WEB_MAX_PACKAGE_BYTES` | Request body limit for extension package and plugin uploads (`/api/v1/admin/extensions/packages/file`, `/api/v1/admin/catalog/import/file`), default 50 MiB, forwarded while being read. This is the web tier's limit; the kernel additionally rejects by `packages.maxBytes`. Raise both together, otherwise a large package uploaded through the web is first rejected by the web tier with a 413 |",
+        "| `CAPYBARA_WEB_MAX_PACKAGE_BYTES` | Request body limit for extension package and plugin uploads (`/api/v1/admin/extensions/packages/file`, `/api/v1/admin/catalog/import/file`, `/api/v1/orgs/:orgId/catalog/uploads/file`), default 50 MiB, forwarded while being read. This is the web tier's limit; the kernel additionally rejects by `packages.maxBytes`. Raise both together, otherwise a large package uploaded through the web is first rejected by the web tier with a 413 |",
         "| `CAPYBARA_WEB_OBJECT_STORE_URL` | Object storage on the web origin: the object store's address as web reaches it (e.g. `http://seaweedfs-s3:8333`). When set, web proxies `/<bucket>/**` (and `/<bucket>` itself for POST only) there, so browsers upload attachments (presigned POST) and download attachments and artifacts (presigned GET) through web; set the object-store extension's `publicEndpoint` to the web origin with `forcePathStyle: true`. Only GET, HEAD and POST; the path is forwarded unchanged; cookies and authorization are not forwarded; responses carry `X-Content-Type-Options: nosniff` and `Content-Security-Policy: sandbox`; uploads are capped at `CAPYBARA_WEB_MAX_PACKAGE_BYTES`. Unset (default): off |",
         "| `CAPYBARA_WEB_OBJECT_STORE_BUCKET` | With `CAPYBARA_WEB_OBJECT_STORE_URL`: the bucket, equal to the object-store extension's `bucket` (it is the first path segment web proxies) |",
         "| `CAPYBARA_WEB_OBJECT_STORE_PUBLIC_HOST` | With `CAPYBARA_WEB_OBJECT_STORE_URL`: the host of the extension's `publicEndpoint` (a host such as `capybara.example.com`, or that URL). Sent upstream as `Host` instead of the incoming one, because presigned URLs sign the host they were issued for and front proxies rewrite it |",

package/dist/config/schema.d.ts

@@ -177,7 +177,8 @@ export declare const KernelConfigSchema: z.ZodObject<{
         requestMediaBytes: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>>;
     subagents: z.ZodPrefault<z.ZodObject<{
-        maxConcurrentPerRun: z.ZodDefault<z.ZodNumber>;
+        maxDepth: z.ZodDefault<z.ZodNumber>;
+        maxConcurrentPerConversation: z.ZodDefault<z.ZodNumber>;
         maxDispatchesPerRun: z.ZodDefault<z.ZodNumber>;
         maxTokensPerRun: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>>;
@@ -193,7 +194,7 @@ export declare const KernelConfigSchema: z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strip>>;
     sandbox: z.ZodPrefault<z.ZodObject<{
-        image: z.ZodDefault<z.ZodString>;
+        image: z.ZodOptional<z.ZodString>;
         lockWaitSeconds: z.ZodDefault<z.ZodNumber>;
         maxConcurrentCommands: z.ZodDefault<z.ZodNumber>;
         deliverMaxBytes: z.ZodDefault<z.ZodNumber>;
@@ -218,6 +219,9 @@ export declare const KernelConfigSchema: z.ZodObject<{
             allowHosts: z.ZodDefault<z.ZodArray<z.ZodString>>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
+    environments: z.ZodPrefault<z.ZodObject<{
+        maxPersonal: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
     evals: z.ZodPrefault<z.ZodObject<{
         orgConcurrency: z.ZodDefault<z.ZodNumber>;
         workerConcurrency: z.ZodDefault<z.ZodNumber>;
@@ -228,6 +232,10 @@ export declare const KernelConfigSchema: z.ZodObject<{
         judgeMaxOutputTokens: z.ZodDefault<z.ZodNumber>;
         maxConsecutiveErrors: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>>;
+    models: z.ZodPrefault<z.ZodObject<{
+        listTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        embedTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
     hooks: z.ZodPrefault<z.ZodObject<{
         timeoutMs: z.ZodDefault<z.ZodNumber>;
         usageReportConcurrency: z.ZodDefault<z.ZodNumber>;