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

package/dist/agents/from-template.service.d.ts

@@ -0,0 +1,72 @@
+import { ExtensionHost } from "../extensions/host.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import type { KernelLogger } from "../log.js";
+import { ModelPurposesService } from "../models/purposes.js";
+import { ProviderRegistry } from "../runtime/providers.js";
+import { AgentsService, type AgentView, type AgentVisibility } from "./agents.service.js";
+import type { ModelRef } from "./definition.js";
+import { type ModelSource, type PlanItem } from "./from-template.js";
+import { PendingConnectorRequests } from "./pending-connector-requests.js";
+import type { ProfileInput } from "./profile.js";
+/** The preview of creating an agent from a template (`POST …/agents/from-template/preview`). */
+export interface TemplatePreview {
+    items: PlanItem[];
+    /** The automatic choice the dialog preselects (P4-4); null when the org has no usable model. */
+    model: (ModelRef & {
+        source: ModelSource;
+    }) | null;
+    dropped: string[];
+    previewHash: string;
+}
+export interface CreateFromTemplateRequest {
+    templateId: string;
+    name: string;
+    visibility?: AgentVisibility;
+    members?: string[];
+    model?: ModelRef;
+    avatar?: ProfileInput["avatar"];
+    previewHash: string;
+}
+/**
+ * Creating agents from templates (rulings P4-3…P4-8): the preview and the create both resolve the
+ * template with {@link planFromTemplate}; the create refuses a plan whose hash differs from the
+ * preview's (409 `agent.template_preview_stale`: the base part, and the automatic model's part when
+ * no model is chosen), writes the agent through
+ * {@link AgentsService.createFromTemplate}, and after the commit opens the pending connector request
+ * when the creator cannot configure connectors.
+ */
+export declare class AgentsFromTemplate {
+    private readonly db;
+    private readonly agents;
+    /** Extension tools loaded here and the org's enabled extensions. */
+    private readonly host;
+    private readonly providers;
+    /** The tier's purpose mapping (`subagent_<tier>`, P4-4). */
+    private readonly purposes;
+    private readonly requests;
+    private readonly log;
+    constructor(db: KernelDb, agents: AgentsService, 
+    /** Extension tools loaded here and the org's enabled extensions. */
+    host: Pick<ExtensionHost, "tools" | "enabledPlugins">, providers: Pick<ProviderRegistry, "resolve" | "list">, 
+    /** The tier's purpose mapping (`subagent_<tier>`, P4-4). */
+    purposes: Pick<ModelPurposesService, "resolve">, requests: PendingConnectorRequests, log: Pick<KernelLogger, "warn">);
+    /** The template, when usable in the org (P4-3); otherwise 404 `component.not_found`. */
+    private template;
+    private plan;
+    preview(orgId: string, templateId: string): Promise<TemplatePreview>;
+    /**
+     * The template and the plan of a create, read only: 404 `component.not_found` for a template
+     * not usable here, 409 `agent.template_preview_stale` for a hash that no longer matches, and
+     * `agent.model_unavailable` when no model resolves.
+     */
+    private checked;
+    /**
+     * The read-only checks of {@link create}, for the `Platform` tool's precheck (before the card):
+     * throws the `ApiError` the create would for an unknown template, a stale preview hash or no
+     * model.
+     */
+    check(orgId: string, req: Pick<CreateFromTemplateRequest, "templateId" | "previewHash" | "model">): Promise<void>;
+    create(orgId: string, actorAccountId: string, req: CreateFromTemplateRequest, actorTokenId?: string, auditDetail?: Record<string, unknown>): Promise<{
+        agent: AgentView;
+    }>;
+}

package/dist/agents/from-template.service.js

@@ -0,0 +1,178 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Inject, Injectable } from "@nestjs/common";
+import { ApiError } from "../errors.js";
+import { ExtensionHost } from "../extensions/host.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { KERNEL_LOGGER } from "../infra/tokens.js";
+import { ModelPurposesService } from "../models/purposes.js";
+import { can } from "../orgs/roles.js";
+import { ProviderRegistry } from "../runtime/providers.js";
+import { AgentsService } from "./agents.service.js";
+import { planFromTemplate, } from "./from-template.js";
+import { PendingConnectorRequests } from "./pending-connector-requests.js";
+import { loadTemplates } from "./templates.js";
+/**
+ * Creating agents from templates (rulings P4-3…P4-8): the preview and the create both resolve the
+ * template with {@link planFromTemplate}; the create refuses a plan whose hash differs from the
+ * preview's (409 `agent.template_preview_stale`: the base part, and the automatic model's part when
+ * no model is chosen), writes the agent through
+ * {@link AgentsService.createFromTemplate}, and after the commit opens the pending connector request
+ * when the creator cannot configure connectors.
+ */
+let AgentsFromTemplate = class AgentsFromTemplate {
+    db;
+    agents;
+    host;
+    providers;
+    purposes;
+    requests;
+    log;
+    constructor(db, agents, 
+    /** Extension tools loaded here and the org's enabled extensions. */
+    host, providers, 
+    /** The tier's purpose mapping (`subagent_<tier>`, P4-4). */
+    purposes, requests, log) {
+        this.db = db;
+        this.agents = agents;
+        this.host = host;
+        this.providers = providers;
+        this.purposes = purposes;
+        this.requests = requests;
+        this.log = log;
+    }
+    /** The template, when usable in the org (P4-3); otherwise 404 `component.not_found`. */
+    async template(orgId, templateId) {
+        const row = (await loadTemplates(this.db.db, orgId, [templateId])).get(templateId);
+        if (!row) {
+            throw new ApiError("component.not_found", "The agent template does not exist or is not available in this organization");
+        }
+        return row;
+    }
+    async plan(orgId, row, model) {
+        const opts = {
+            pluginTools: this.host.tools().map((t) => ({ plugin: t.plugin, name: t.spec.name })),
+            enabledPlugins: await this.host.enabledPlugins(orgId),
+            resolveModel: async (ref) => {
+                try {
+                    return (await this.providers.resolve(orgId, ref)).info.parameters;
+                }
+                catch {
+                    return null;
+                }
+            },
+            purpose: async (purpose) => {
+                try {
+                    return await this.purposes.resolve(orgId, purpose);
+                }
+                catch (e) {
+                    if (e instanceof ApiError)
+                        return null;
+                    throw e;
+                }
+            },
+            defaultModel: async () => {
+                for (const p of await this.providers.list(orgId)) {
+                    const m = p.models.find((x) => x.kind === "chat");
+                    if (m)
+                        return { provider: p.provider, model: m.id };
+                }
+                return null;
+            },
+            ...(model !== undefined && { model }),
+        };
+        return planFromTemplate(this.db.db, orgId, row, opts);
+    }
+    async preview(orgId, templateId) {
+        const plan = await this.plan(orgId, await this.template(orgId, templateId));
+        return {
+            items: plan.items,
+            model: plan.auto === null ? null : { ...plan.auto.ref, source: plan.auto.source },
+            dropped: plan.dropped,
+            previewHash: plan.hash,
+        };
+    }
+    /**
+     * The template and the plan of a create, read only: 404 `component.not_found` for a template
+     * not usable here, 409 `agent.template_preview_stale` for a hash that no longer matches, and
+     * `agent.model_unavailable` when no model resolves.
+     */
+    async checked(orgId, req) {
+        const row = await this.template(orgId, req.templateId);
+        const plan = await this.plan(orgId, row, req.model);
+        // the base part always; the automatic model's part only when the person chose none, so a
+        // silently changed choice is stale while an explicit one never is
+        const [base, auto] = req.previewHash.split(".");
+        if (base !== plan.baseHash || (req.model === undefined && auto !== plan.modelHash)) {
+            throw new ApiError("agent.template_preview_stale", "The template or the organization changed since the preview; preview it again");
+        }
+        if (plan.model === null) {
+            throw new ApiError("agent.model_unavailable", "No model is available for the new agent");
+        }
+        return { row, plan, model: plan.model };
+    }
+    /**
+     * The read-only checks of {@link create}, for the `Platform` tool's precheck (before the card):
+     * throws the `ApiError` the create would for an unknown template, a stale preview hash or no
+     * model.
+     */
+    async check(orgId, req) {
+        await this.checked(orgId, req);
+    }
+    async create(orgId, actorAccountId, req, actorTokenId, auditDetail) {
+        const { row, plan, model } = await this.checked(orgId, req);
+        const { agent, role } = await this.agents.createFromTemplate(orgId, actorAccountId, {
+            definition: {
+                ...plan.definition,
+                name: req.name,
+                model: model.ref,
+                modelParams: model.params,
+            },
+            visibility: req.visibility ?? "private",
+            ...(req.members !== undefined && { memberIds: req.members }),
+            profile: {
+                description: plan.profile.description,
+                quickActions: plan.profile.quickActions,
+                ...(req.avatar != null && { avatar: req.avatar }),
+            },
+        }, { id: req.templateId, version: row.version, name: row.name }, actorTokenId, auditDetail);
+        const keys = (agent.definition.pendingConnectors ?? []).map((c) => c.key);
+        if (keys.length > 0 && !can(role, "connectors.manage")) {
+            try {
+                await this.requests.openFor({
+                    orgId,
+                    agentId: agent.id,
+                    ownerAccountId: agent.ownerAccountId,
+                    keys,
+                });
+            }
+            catch (err) {
+                // the agent stands; its 待配置 notice offers the request again (ruling P4-7)
+                this.log.warn("cannot open the pending connector request of a new agent", {
+                    orgId,
+                    agentId: agent.id,
+                    err,
+                });
+            }
+        }
+        return { agent };
+    }
+};
+AgentsFromTemplate = __decorate([
+    Injectable(),
+    __param(0, Inject(KernelDb)),
+    __param(1, Inject(AgentsService)),
+    __param(2, Inject(ExtensionHost)),
+    __param(3, Inject(ProviderRegistry)),
+    __param(4, Inject(ModelPurposesService)),
+    __param(5, Inject(PendingConnectorRequests)),
+    __param(6, Inject(KERNEL_LOGGER))
+], AgentsFromTemplate);
+export { AgentsFromTemplate };

package/dist/agents/instruction-files.d.ts

@@ -0,0 +1,60 @@
+import { z } from "zod";
+import type { AgentDefinition } from "./definition.js";
+/**
+ * Prompt files (spec 2026-11-04 §3.3): the authoring form of an agent's system prompt. The kernel
+ * joins them into `instructions` on save, and `instructions` stays the one model-visible field
+ * (build.ts, the sub-agent copy, eval candidates and replay keep reading it), so no log event
+ * changes shape and replay needs no new `DriftReason`.
+ */
+export type InstructionFile = {
+    name: string;
+    content: string;
+};
+/** The default and first file. */
+export declare const AGENTS_MD = "AGENTS.md";
+export declare const INSTRUCTION_FILE_LIMITS: {
+    /** At most this many files, at least one. */
+    readonly count: 20;
+    /** The joined text, the same bound as `instructions`. */
+    readonly joinedChars: 100000;
+};
+/** A file name: 1–64 characters without `/` or `\`, then `.md`. */
+export declare const INSTRUCTION_FILE_NAME_RE: RegExp;
+/**
+ * The starter prompt of a new agent created without one (model-visible once saved; English like
+ * every model-facing text).
+ */
+export declare const AGENTS_MD_STARTER: string;
+/**
+ * The model-visible join: one file gives exactly its content (so an old agent edited without
+ * adding files sends the same text as before); several files give `# <name>\n\n<content>` each,
+ * in order, joined by `\n\n`.
+ */
+export declare function joinInstructionFiles(files: readonly InstructionFile[]): string;
+/** The files of a definition; a definition without them (every old version) is one `AGENTS.md`. */
+export declare function readInstructionFiles(def: Pick<AgentDefinition, "instructions" | "instructionFiles">): InstructionFile[];
+export declare const InstructionFileSchema: z.ZodObject<{
+    name: z.ZodString;
+    content: z.ZodString;
+}, z.core.$strict>;
+/**
+ * 1–20 files, names unique ignoring case (`AGENTS.md` and `agents.md` would collide on a
+ * case-insensitive file system), a joined total of at most 100 000 characters.
+ */
+export declare const InstructionFilesSchema: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    content: z.ZodString;
+}, z.core.$strict>>;
+/** A definition as a save request gives it: `instructions` may be left out. */
+export type AgentDefinitionInput = Omit<AgentDefinition, "instructions"> & {
+    instructions?: string | undefined;
+};
+/**
+ * Derives the stored definition of a save. With `instructionFiles`, `instructions` is their join
+ * (a differing `instructions` given with them → 400 `agent.instructions_mismatch`). With only
+ * `instructions` (old clients) the current files are kept while it equals their join, else the
+ * definition is stored as given, without files. Given neither,
+ * an update keeps the `current` version's prompt, and a new agent (`current` null) gets the
+ * `AGENTS.md` starter.
+ */
+export declare function deriveInstructions(def: AgentDefinitionInput, current: Pick<AgentDefinition, "instructions" | "instructionFiles"> | null): AgentDefinition;

package/dist/agents/instruction-files.js

@@ -0,0 +1,111 @@
+import { z } from "zod";
+import { ApiError } from "../errors.js";
+import { CONTROL_OR_HIDDEN_RE } from "../text.js";
+/** The default and first file. */
+export const AGENTS_MD = "AGENTS.md";
+export const INSTRUCTION_FILE_LIMITS = {
+    /** At most this many files, at least one. */
+    count: 20,
+    /** The joined text, the same bound as `instructions`. */
+    joinedChars: 100_000,
+};
+/** A file name: 1–64 characters without `/` or `\`, then `.md`. */
+export const INSTRUCTION_FILE_NAME_RE = /^[^/\\]{1,64}\.md$/;
+/**
+ * The starter prompt of a new agent created without one (model-visible once saved; English like
+ * every model-facing text).
+ */
+export const AGENTS_MD_STARTER = [
+    "You are an assistant for this team. Help people get their work done accurately and efficiently.",
+    "",
+    "- Tone: clear, friendly and concise. Use plain language, keep answers short, and add detail when asked.",
+    "- When a request is unclear or missing key details, ask one short clarifying question before acting.",
+    "  If you go ahead anyway, say what you assumed.",
+    "- If you don't know something or can't do it, say so instead of guessing.",
+].join("\n");
+/**
+ * The model-visible join: one file gives exactly its content (so an old agent edited without
+ * adding files sends the same text as before); several files give `# <name>\n\n<content>` each,
+ * in order, joined by `\n\n`.
+ */
+export function joinInstructionFiles(files) {
+    if (files.length === 1)
+        return files[0]?.content ?? "";
+    return files.map((f) => `# ${f.name}\n\n${f.content}`).join("\n\n");
+}
+/** The files of a definition; a definition without them (every old version) is one `AGENTS.md`. */
+export function readInstructionFiles(def) {
+    return def.instructionFiles ?? [{ name: AGENTS_MD, content: def.instructions }];
+}
+export const InstructionFileSchema = z
+    .object({
+    name: z
+        .string()
+        .regex(INSTRUCTION_FILE_NAME_RE, "a file name is 1–64 characters without / or \\, then .md")
+        .refine((n) => !CONTROL_OR_HIDDEN_RE.test(n), "a file name must not contain control or format characters"),
+    content: z.string().max(INSTRUCTION_FILE_LIMITS.joinedChars),
+})
+    .strict();
+/**
+ * 1–20 files, names unique ignoring case (`AGENTS.md` and `agents.md` would collide on a
+ * case-insensitive file system), a joined total of at most 100 000 characters.
+ */
+export const InstructionFilesSchema = z
+    .array(InstructionFileSchema)
+    .min(1)
+    .max(INSTRUCTION_FILE_LIMITS.count)
+    .superRefine((files, ctx) => {
+    const seen = new Set();
+    files.forEach((f, i) => {
+        const key = f.name.toLowerCase();
+        if (seen.has(key)) {
+            ctx.addIssue({ code: "custom", path: [i, "name"], message: `duplicate file ${f.name}` });
+        }
+        seen.add(key);
+    });
+    const joined = joinInstructionFiles(files).length;
+    if (joined > INSTRUCTION_FILE_LIMITS.joinedChars) {
+        ctx.addIssue({
+            code: "custom",
+            message: `the joined files are ${joined} characters, more than ${INSTRUCTION_FILE_LIMITS.joinedChars}`,
+        });
+    }
+});
+/**
+ * Derives the stored definition of a save. With `instructionFiles`, `instructions` is their join
+ * (a differing `instructions` given with them → 400 `agent.instructions_mismatch`). With only
+ * `instructions` (old clients) the current files are kept while it equals their join, else the
+ * definition is stored as given, without files. Given neither,
+ * an update keeps the `current` version's prompt, and a new agent (`current` null) gets the
+ * `AGENTS.md` starter.
+ */
+export function deriveInstructions(def, current) {
+    const { instructions, instructionFiles, ...rest } = def;
+    if (instructionFiles !== undefined) {
+        const joined = joinInstructionFiles(instructionFiles);
+        if (instructions !== undefined && instructions !== joined) {
+            throw new ApiError("agent.instructions_mismatch", "instructions differs from the join of instructionFiles; send only instructionFiles");
+        }
+        return { ...rest, instructions: joined, instructionFiles };
+    }
+    if (instructions !== undefined) {
+        // an old client re-sending the same joined text (an unrelated edit) keeps the files
+        const files = current?.instructionFiles;
+        if (files !== undefined && instructions === joinInstructionFiles(files)) {
+            return { ...rest, instructions, instructionFiles: files };
+        }
+        return { ...rest, instructions };
+    }
+    if (current !== null) {
+        return {
+            ...rest,
+            instructions: current.instructions,
+            ...(current.instructionFiles !== undefined && { instructionFiles: current.instructionFiles }),
+        };
+    }
+    return {
+        ...rest,
+        instructions: AGENTS_MD_STARTER,
+        instructionFiles: [{ name: AGENTS_MD, content: AGENTS_MD_STARTER }],
+    };
+}

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

@@ -1,13 +1,51 @@
-import type { ModelInfo } from "@capybara-hq/plugin-sdk";
-import type { ProviderRegistry } from "../runtime/providers.js";
-/** 可选模型（`/api/v1/orgs/:orgId/models`）：已安装的模型供应商及其模型，列表缓存在 Redis。 */
+import type { LocalizedName } from "@capybara-hq/plugin-sdk";
+import { z } from "zod";
+import { ExtensionDisplayNames } from "../extensions/display-name.js";
+import { PluginIcons } from "../extensions/plugin-icons.js";
+import { type Principal } from "../identity/principal.js";
+import { type OrgContext } from "../orgs/org.guard.js";
+import { type KernelModelInfo, ProviderRegistry, type ProviderStatus } from "../runtime/providers.js";
+export declare const ModelsQuery: z.ZodObject<{
+    kind: z.ZodOptional<z.ZodEnum<{
+        chat: "chat";
+        embedding: "embedding";
+        image_generation: "image_generation";
+        other: "other";
+        rerank: "rerank";
+        speech_to_text: "speech_to_text";
+        text_to_speech: "text_to_speech";
+        video_generation: "video_generation";
+    }>>;
+}, z.core.$strip>;
+/**
+ * 可选模型（`/api/v1/orgs/:orgId/models`）：已安装的模型供应商及其模型，列表缓存在 Redis。Each provider
+ * carries its extension's display name (null when it has none). Listed for the org (its effective
+ * provider config: a provider needing configuration there is absent); only enabled models (neither
+ * the platform nor the org disabled them, spec B §5.3), optionally of one `?kind=`; every model
+ * carries its normalised `kind` (`other` for a kind this kernel does not know).
+ */
 export declare class ModelsController {
     private readonly registry;
-    constructor(registry: ProviderRegistry);
-    list(): Promise<{
+    private readonly displayNames;
+    private readonly icons;
+    constructor(registry: ProviderRegistry, displayNames: ExtensionDisplayNames, icons: PluginIcons);
+    list(org: OrgContext, q: z.infer<typeof ModelsQuery>): Promise<{
         providers: {
             provider: string;
-            models: ModelInfo[];
+            displayName: LocalizedName | null;
+            icon: string | null;
+            models: KernelModelInfo[];
         }[];
     }>;
+    /**
+     * The org's model catalog (the settings page; `org.models.manage`, people only): every provider
+     * with its status for the org and every model the platform left on, each with `disabled` for the
+     * org's own list.
+     */
+    catalog(principal: Principal, org: OrgContext): Promise<{
+        providers: (ProviderStatus & {
+            displayName: LocalizedName | null;
+            icon: string | null;
+        })[];
+    }>;
 }

package/dist/agents/models.controller.js

@@ -8,24 +8,100 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { Controller, Get, Inject } from "@nestjs/common";
-import { PROVIDER_REGISTRY } from "../http/tokens.js";
-import { OrgAction } from "../orgs/org.guard.js";
-/** 可选模型（`/api/v1/orgs/:orgId/models`）：已安装的模型供应商及其模型，列表缓存在 Redis。 */
+import { z } from "zod";
+import { ExtensionDisplayNames } from "../extensions/display-name.js";
+import { orgIconScope, PluginIcons } from "../extensions/plugin-icons.js";
+import { CurrentPrincipal, requireUser } from "../identity/principal.js";
+import { createZodDto } from "../infra/validation/create-zod-dto.js";
+import { ZQuery } from "../infra/validation/zod-params.js";
+import { CurrentOrg, OrgAction } from "../orgs/org.guard.js";
+import { ProviderRegistry, } from "../runtime/providers.js";
+export const ModelsQuery = z.object({
+    kind: z
+        .enum([
+        "chat",
+        "embedding",
+        "rerank",
+        "image_generation",
+        "video_generation",
+        "speech_to_text",
+        "text_to_speech",
+        "other",
+    ])
+        .optional(),
+});
+class ModelsQueryDto extends createZodDto(ModelsQuery, "ModelsQuery") {
+}
+/**
+ * 可选模型（`/api/v1/orgs/:orgId/models`）：已安装的模型供应商及其模型，列表缓存在 Redis。Each provider
+ * carries its extension's display name (null when it has none). Listed for the org (its effective
+ * provider config: a provider needing configuration there is absent); only enabled models (neither
+ * the platform nor the org disabled them, spec B §5.3), optionally of one `?kind=`; every model
+ * carries its normalised `kind` (`other` for a kind this kernel does not know).
+ */
 let ModelsController = class ModelsController {
     registry;
-    constructor(registry) {
+    displayNames;
+    icons;
+    constructor(registry, displayNames, icons) {
         this.registry = registry;
+        this.displayNames = displayNames;
+        this.icons = icons;
     }
-    async list() {
-        return { providers: await this.registry.list() };
+    async list(org, q) {
+        const providers = await this.registry.list(org.orgId, q.kind === undefined ? {} : { kind: q.kind });
+        const plugins = providers.map((p) => p.provider);
+        const [names, icons] = await Promise.all([
+            this.displayNames.many(plugins),
+            this.icons.many(plugins, orgIconScope(org)),
+        ]);
+        return {
+            providers: providers.map((p) => ({
+                provider: p.provider,
+                displayName: names.get(p.provider) ?? null,
+                icon: icons.get(p.provider) ?? null,
+                models: p.models,
+            })),
+        };
+    }
+    /**
+     * The org's model catalog (the settings page; `org.models.manage`, people only): every provider
+     * with its status for the org and every model the platform left on, each with `disabled` for the
+     * org's own list.
+     */
+    async catalog(principal, org) {
+        requireUser(principal);
+        const providers = await this.registry.catalog(org.orgId);
+        const plugins = providers.map((p) => p.plugin);
+        const [names, icons] = await Promise.all([
+            this.displayNames.many(plugins),
+            this.icons.many(plugins, orgIconScope(org)),
+        ]);
+        return {
+            providers: providers.map((p) => ({
+                ...p,
+                displayName: names.get(p.plugin) ?? null,
+                icon: icons.get(p.plugin) ?? null,
+            })),
+        };
     }
 };
 __decorate([
     Get(),
-    OrgAction("agents.use")
+    OrgAction("agents.use"),
+    __param(0, CurrentOrg()),
+    __param(1, ZQuery(ModelsQueryDto))
 ], ModelsController.prototype, "list", null);
+__decorate([
+    Get("catalog"),
+    OrgAction("org.models.manage"),
+    __param(0, CurrentPrincipal()),
+    __param(1, CurrentOrg())
+], ModelsController.prototype, "catalog", null);
 ModelsController = __decorate([
     Controller("api/v1/orgs/:orgId/models"),
-    __param(0, Inject(PROVIDER_REGISTRY))
+    __param(0, Inject(ProviderRegistry)),
+    __param(1, Inject(ExtensionDisplayNames)),
+    __param(2, Inject(PluginIcons))
 ], ModelsController);
 export { ModelsController };