@nylorun/runtime 0.24.0-beta → 0.26.0-beta

package/dist/mcp/connect.d.ts

@@ -202,7 +202,6 @@ export declare function serverInstructions(text: unknown, secrets: readonly stri
  * collides gets the hash suffix first.
  */
 export declare function listMcpTools(client: McpClient, input: {
-    capabilityId: string;
     serverName: string;
     taken: Set<string>;
     signal?: AbortSignal;
@@ -224,4 +223,4 @@ export declare function listMcpTools(client: McpClient, input: {
  * unknown.
  */
 export declare function callMcpTool(client: McpClient, serverToolName: string, args: unknown, options?: McpCallOptions): Promise<McpToolOutcome>;
-export declare function diagnosticFromError(capabilityId: string, serverName: string, error: unknown): McpDiagnostic;
+export declare function diagnosticFromError(serverName: string, error: unknown): McpDiagnostic;

package/dist/mcp/connect.js

@@ -285,7 +285,6 @@ export async function listMcpTools(client, input) {
         const { tool, inputSchema } = candidate;
         const outputSchema = tool.outputSchema ? usableSchema(tool.outputSchema) : undefined;
         tools.push({
-            capabilityId: input.capabilityId,
             serverName: input.serverName,
             serverToolName: tool.name,
             name,
@@ -353,14 +352,13 @@ function onlyText(content) {
     return (Array.isArray(content) &&
         content.every((part) => !!part && typeof part === "object" && part.type === "text"));
 }
-export function diagnosticFromError(capabilityId, serverName, error) {
+export function diagnosticFromError(serverName, error) {
     const credentialIds = error && typeof error === "object" && "credentialIds" in error
         ? error.credentialIds
         : undefined;
     const refused = error instanceof Error && error.message.startsWith("MCP authorization refused");
     if (refused) {
         return {
-            capabilityId,
             serverName,
             outcome: "refused",
             message: error.message,
@@ -374,7 +372,6 @@ export function diagnosticFromError(capabilityId, serverName, error) {
         code === 401 ||
         (error instanceof Error && /\b401\b/.test(error.message));
     return {
-        capabilityId,
         serverName,
         outcome: "failed",
         message: unauthorized

package/dist/mcp/pool.d.ts

@@ -51,7 +51,6 @@ export declare class McpPool {
     call(input: {
         sessionId: string;
         agentId?: string;
-        capabilityId: string;
         serverName: string;
         serverToolName: string;
         args: unknown;
@@ -85,7 +84,6 @@ export interface McpServerRef {
     readonly sessionId: string;
     /** The agent used as a tool that declares the server; absent for the session's root agent. */
     readonly agentId?: string;
-    readonly capabilityId: string;
     readonly serverName: string;
 }
 export interface DeclaredServer {
@@ -93,9 +91,8 @@ export interface DeclaredServer {
     readonly agentId?: string;
     /** The manifest of the agent that declares the server. */
     readonly manifest: AgentManifest;
-    readonly capabilityId: string;
     readonly server: McpServerManifest;
 }
 /** Servers of the root agent, then of each agent it uses as a tool. */
 export declare function serversOf(manifest: AgentManifest): DeclaredServer[];
-export declare function findServer(manifest: AgentManifest, agentId: string | undefined, capabilityId: string, serverName: string): DeclaredServer | undefined;
+export declare function findServer(manifest: AgentManifest, agentId: string | undefined, serverName: string): DeclaredServer | undefined;

package/dist/mcp/pool.js

@@ -34,7 +34,6 @@ export class McpPool {
                 if (!taken.has(declared.agentId))
                     taken.set(declared.agentId, declaredToolNames(declared.manifest));
                 const listed = await listMcpTools(opened.connection.client, {
-                    capabilityId: declared.capabilityId,
                     serverName: declared.server.name,
                     taken: taken.get(declared.agentId),
                     server: declared.server,
@@ -43,13 +42,11 @@ export class McpPool {
                 tools.push(...listed.tools.map((tool) => owned(declared, tool)));
                 if (opened.connection.instructions)
                     notes.push(owned(declared, {
-                        capabilityId: declared.capabilityId,
                         serverName: declared.server.name,
                         instructions: opened.connection.instructions,
                     }));
                 diagnostics.push({
                     ...ownerOf(declared),
-                    capabilityId: declared.capabilityId,
                     serverName: declared.server.name,
                     outcome: "connected",
                     message: [
@@ -67,7 +64,7 @@ export class McpPool {
             }
             catch (error) {
                 await opened.connection.close().catch(() => { });
-                diagnostics.push(owned(declared, diagnosticFromError(declared.capabilityId, declared.server.name, error)));
+                diagnostics.push(owned(declared, diagnosticFromError(declared.server.name, error)));
             }
         }
         return {
@@ -84,7 +81,7 @@ export class McpPool {
         const diagnostics = [];
         const seen = new Set();
         for (const tool of input.tools) {
-            const key = this.liveKey(input.sessionId, tool.agentId, tool.capabilityId, tool.serverName);
+            const key = this.liveKey(input.sessionId, tool.agentId, tool.serverName);
             if (seen.has(key))
                 continue;
             seen.add(key);
@@ -95,11 +92,10 @@ export class McpPool {
                 continue;
             }
             input.signal?.throwIfAborted();
-            const declared = findServer(input.manifest, tool.agentId, tool.capabilityId, tool.serverName);
+            const declared = findServer(input.manifest, tool.agentId, tool.serverName);
             if (!declared) {
                 diagnostics.push({
                     ...(tool.agentId === undefined ? {} : { agentId: tool.agentId }),
-                    capabilityId: tool.capabilityId,
                     serverName: tool.serverName,
                     outcome: "failed",
                     message: "Declared MCP server is missing from the pinned manifest",
@@ -116,7 +112,7 @@ export class McpPool {
         return diagnostics;
     }
     async call(input) {
-        const key = this.liveKey(input.sessionId, input.agentId, input.capabilityId, input.serverName);
+        const key = this.liveKey(input.sessionId, input.agentId, input.serverName);
         for (let attempt = 0;; attempt += 1) {
             const live = await this.liveFor(input, key);
             // No connection, so no call was sent: the model sees why, a 401 included (R2b C1, C7).
@@ -152,7 +148,7 @@ export class McpPool {
         const live = this.live.get(key);
         if (live)
             return live;
-        const declared = findServer(input.manifest, input.agentId, input.capabilityId, input.serverName);
+        const declared = findServer(input.manifest, input.agentId, input.serverName);
         if (!declared)
             throw new Error(`MCP server '${input.serverName}' is not declared`);
         let opening = this.opening.get(key);
@@ -196,7 +192,7 @@ export class McpPool {
     }
     /** Keeps the connection, or closes it when the server is already connected for the session. */
     remember(sessionId, declared, connection) {
-        const key = this.liveKey(sessionId, declared.agentId, declared.capabilityId, declared.server.name);
+        const key = this.liveKey(sessionId, declared.agentId, declared.server.name);
         const existing = this.live.get(key);
         if (existing) {
             if (existing.connection !== connection)
@@ -204,7 +200,6 @@ export class McpPool {
             return existing;
         }
         const live = {
-            capabilityId: declared.capabilityId,
             serverName: declared.server.name,
             connection,
             lastUsedAt: this.now(),
@@ -213,8 +208,8 @@ export class McpPool {
         this.live.set(key, live);
         return live;
     }
-    liveKey(sessionId, agentId, capabilityId, serverName) {
-        return JSON.stringify([sessionId, agentId ?? null, capabilityId, serverName]);
+    liveKey(sessionId, agentId, serverName) {
+        return JSON.stringify([sessionId, agentId ?? null, serverName]);
     }
     async connectDeclared(input, declared) {
         try {
@@ -222,7 +217,6 @@ export class McpPool {
                 const connection = await this.options.openRemote({
                     sessionId: input.sessionId,
                     ...ownerOf(declared),
-                    capabilityId: declared.capabilityId,
                     serverName: declared.server.name,
                 });
                 return { ok: true, connection };
@@ -242,7 +236,7 @@ export class McpPool {
             return {
                 ok: false,
                 error,
-                diagnostic: owned(declared, diagnosticFromError(declared.capabilityId, declared.server.name, error)),
+                diagnostic: owned(declared, diagnosticFromError(declared.server.name, error)),
             };
         }
     }
@@ -251,24 +245,16 @@ export class McpPool {
 export function serversOf(manifest) {
     const servers = [];
     const add = (agent, agentId) => {
-        for (const capability of agent.capabilities)
-            for (const server of Object.values(capability.mcpServers ?? {}))
-                servers.push({
-                    ...(agentId === undefined ? {} : { agentId }),
-                    manifest: agent,
-                    capabilityId: capability.id,
-                    server,
-                });
+        for (const server of Object.values(agent.mcpServers ?? {}))
+            servers.push({ ...(agentId === undefined ? {} : { agentId }), manifest: agent, server });
     };
     add(manifest);
     for (const child of delegatesOf(manifest))
         add(child.manifest, child.manifest.id);
     return servers;
 }
-export function findServer(manifest, agentId, capabilityId, serverName) {
-    return serversOf(manifest).find((item) => item.agentId === agentId &&
-        item.capabilityId === capabilityId &&
-        item.server.name === serverName);
+export function findServer(manifest, agentId, serverName) {
+    return serversOf(manifest).find((item) => item.agentId === agentId && item.server.name === serverName);
 }
 function ownerOf(declared) {
     return declared.agentId === undefined ? {} : { agentId: declared.agentId };

package/dist/mcp/preview.d.ts

@@ -1,6 +1,6 @@
 /**
  * A remote MCP server's tools before an agent names it (R2b C12, `POST /v1/tenant/mcp/preview`,
- * `nylorun mcp inspect`, an Environment's Secrets tab in Studio). It runs where plaintext credentials live:
+ * `nylorun tenant mcp inspect`, an Environment's Secrets tab in Studio). It runs where plaintext credentials live:
  * the keys service (`keys/keys.ts`, `previewMcp`), in the gateway or in process.
  *
  * One connection: `initialize` and `tools/list` with the Environment's credential for the

package/dist/mcp/preview.js

@@ -1,6 +1,6 @@
 /**
  * A remote MCP server's tools before an agent names it (R2b C12, `POST /v1/tenant/mcp/preview`,
- * `nylorun mcp inspect`, an Environment's Secrets tab in Studio). It runs where plaintext credentials live:
+ * `nylorun tenant mcp inspect`, an Environment's Secrets tab in Studio). It runs where plaintext credentials live:
  * the keys service (`keys/keys.ts`, `previewMcp`), in the gateway or in process.
  *
  * One connection: `initialize` and `tools/list` with the Environment's credential for the
@@ -72,7 +72,6 @@ export async function previewMcpServer(body, options) {
             callTool: () => Promise.reject(new Error("A preview never calls a tool")),
         };
         const listed = await listMcpTools(listing, {
-            capabilityId: "preview",
             serverName: name,
             taken: new Set(),
             signal,

package/dist/mcp/snapshot.d.ts

@@ -5,7 +5,6 @@ import type { DurableSessionTool, HostEffect } from "@nylorun/harness/run";
 export interface McpToolRecord {
     /** The agent used as a tool that declares the server; absent for the session's root agent. */
     readonly agentId?: string;
-    readonly capabilityId: string;
     readonly serverName: string;
     /** The tool's name on its server, which the call sends. */
     readonly serverToolName: string;
@@ -23,7 +22,6 @@ export interface McpToolRecord {
 /** A server's own instructions (MCP `initialize`), for the note on its deferred tools (R2b C10). */
 export interface McpServerNote {
     readonly agentId?: string;
-    readonly capabilityId: string;
     readonly serverName: string;
     /** Cut to `SERVER_INSTRUCTIONS_MAX_CHARS`. */
     readonly instructions: string;
@@ -38,7 +36,6 @@ export interface McpSnapshot {
 export interface McpDiagnostic {
     /** The agent used as a tool that declares the server; absent for the session's root agent. */
     readonly agentId?: string;
-    readonly capabilityId: string;
     readonly serverName: string;
     readonly outcome: "connected" | "refused" | "failed";
     readonly message: string;
@@ -55,8 +52,11 @@ export interface McpRenamedTool {
     readonly serverToolName: string;
     readonly name: string;
 }
-/** The `mcp.discovered` payload: each server's outcome, with the tools it added to the snapshot. */
-export declare function mcpDiscovered(snapshot: McpSnapshot, diagnostics: readonly McpDiagnostic[]): EventPayload<"mcp.discovered">;
+/**
+ * The `mcp.discovered` payload: each server's outcome, with the tools it added to the snapshot,
+ * and the Agent Plugin that brought the server (from `manifest`, the session's pinned one).
+ */
+export declare function mcpDiscovered(snapshot: McpSnapshot, diagnostics: readonly McpDiagnostic[], manifest?: AgentManifest): EventPayload<"mcp.discovered">;
 /** The longest tool name every model provider accepts (R2b C6, Q14). */
 export declare const MODEL_TOOL_NAME_MAX = 64;
 /**
@@ -69,6 +69,7 @@ export declare const MODEL_TOOL_NAME_MAX = 64;
 export declare function normalizeToolName(serverName: string, serverToolName: string, options?: {
     readonly suffixed?: boolean;
 }): string;
+/** The names of the agent's tools: its own and those the Runtime pinned. */
 export declare function declaredToolNames(manifest: AgentManifest): Set<string>;
 /** The tool's settings in `manifest` (R2b C9); the defaults when its server is not there. */
 export declare function mcpToolSettingsIn(manifest: AgentManifest, tool: McpToolRecord): ResolvedMcpToolSettings;
@@ -78,10 +79,9 @@ export declare function mcpToolSettingsIn(manifest: AgentManifest, tool: McpTool
  *
  * - a tool its settings disable is left out (R2b C9); the Tool Gate holds a call its approval
  *   or the Tenant's tool policy asks a person about (R5 step 2);
- * - a deferred tool (R2b C10) is marked so, out of the model's list, and its agent gets
- *   `tool_search`, with the note on the servers it holds deferred tools of, and `tool_call` in
- *   its `nylorun.tools` capability. An agent whose turn has no such capability keeps its tools in
- *   its list.
+ * - a deferred tool (R2b C10) is marked so, out of the model's list, and its agent gets the
+ *   session tools `tool_search`, with the note on the servers it holds deferred tools of, and
+ *   `tool_call`. Their names are reserved: no tool of the agent's own takes them.
  *
  * Nothing here changes between the steps of a turn, so neither does the model's tool list.
  */
@@ -94,16 +94,14 @@ export declare const CHARS_PER_TOKEN = 4;
  * The snapshot with its deferred tools marked (R2b C10, Q21), decided once for the session when
  * core records it. A tool's own setting, then `"*"`'s, then its server's, decides; a tool none
  * sets is deferred when the JSON of its agent's MCP tools that would be listed passes a tenth of
- * the model's context window (`contextWindow` tokens, at 4 characters a token). An agent without
- * the `nylorun.tools` capability (its definition names a tool `tool_search` or `tool_call`, or the
- * session was opened before it existed) defers nothing.
+ * the model's context window (`contextWindow` tokens, at 4 characters a token).
  */
 export declare function pinDeferral(snapshot: McpSnapshot, manifest: AgentManifest, contextWindow: number): McpSnapshot;
 /**
  * The snapshot's record of an MCP tool call, or undefined when the call is not an MCP tool. With
  * the turn's `manifest`, a tool its settings disable is not one either (R2b C9).
  */
-export declare function mcpToolOf(snapshot: McpSnapshot | undefined, request: Pick<HostEffect, "agent" | "capabilityId" | "toolName">, manifest?: AgentManifest): McpToolRecord | undefined;
+export declare function mcpToolOf(snapshot: McpSnapshot | undefined, request: Pick<HostEffect, "agent" | "toolName">, manifest?: AgentManifest): McpToolRecord | undefined;
 /** True when the tool's settings in `manifest` leave it enabled (R2b C9). */
 export declare function isEnabledIn(manifest: AgentManifest, tool: McpToolRecord): boolean;
 /** The manifest of the agent an effect belongs to: the root, or an agent it uses as a tool. */

package/dist/mcp/snapshot.js

@@ -1,8 +1,14 @@
 import { createHash } from "node:crypto";
-import { TOOLS_CAPABILITY_ID, deferredToolsInstructions, deferredToolsTools, delegateManifest, mcpToolSettings, } from "@nylorun/core/define";
-/** The `mcp.discovered` payload: each server's outcome, with the tools it added to the snapshot. */
-export function mcpDiscovered(snapshot, diagnostics) {
-    const key = (item) => JSON.stringify([item.agentId ?? null, item.capabilityId, item.serverName]);
+import { delegatesOf, pluginOf, deferredToolsInstructions, deferredToolsTools, delegateManifest, mcpToolSettings, } from "@nylorun/core/define";
+/**
+ * The `mcp.discovered` payload: each server's outcome, with the tools it added to the snapshot,
+ * and the Agent Plugin that brought the server (from `manifest`, the session's pinned one).
+ */
+export function mcpDiscovered(snapshot, diagnostics, manifest) {
+    const agents = new Map(manifest === undefined
+        ? []
+        : [[undefined, manifest], ...delegatesOf(manifest).map(({ manifest: child }) => [child.id, child])]);
+    const key = (item) => JSON.stringify([item.agentId ?? null, item.serverName]);
     const tools = new Map();
     const deferred = new Map();
     for (const tool of snapshot.mcpTools) {
@@ -13,8 +19,8 @@ export function mcpDiscovered(snapshot, diagnostics) {
     return {
         servers: diagnostics.map((item) => ({
             ...(item.agentId === undefined ? {} : { agentId: item.agentId }),
-            capabilityId: item.capabilityId,
             serverName: item.serverName,
+            ...withPlugin(pluginOf(agents.get(item.agentId), { server: item.serverName })),
             outcome: item.outcome,
             message: item.message,
             tools: tools.get(key(item)) ?? 0,
@@ -26,6 +32,9 @@ export function mcpDiscovered(snapshot, diagnostics) {
         })),
     };
 }
+function withPlugin(plugin) {
+    return plugin === undefined ? {} : { plugin };
+}
 /** The longest tool name every model provider accepts (R2b C6, Q14). */
 export const MODEL_TOOL_NAME_MAX = 64;
 /**
@@ -45,38 +54,29 @@ export function normalizeToolName(serverName, serverToolName, options = {}) {
         .slice(0, 8);
     return `${name.slice(0, MODEL_TOOL_NAME_MAX - 9)}_${hash}`;
 }
+/** The names of the agent's tools: its own and those the Runtime pinned. */
 export function declaredToolNames(manifest) {
-    const names = new Set();
-    for (const capability of manifest.capabilities)
-        for (const tool of capability.tools ?? [])
-            names.add(tool.name);
-    return names;
+    return new Set([...(manifest.tools ?? []), ...(manifest.runtime?.tools ?? [])].map((tool) => tool.name));
 }
 /** The declaration of the server a tool of the snapshot comes from, in `manifest`. */
 function serverOf(manifest, tool) {
     const agent = tool.agentId === undefined ? manifest : delegateManifest(manifest, tool.agentId);
-    return agent?.capabilities.find((item) => item.id === tool.capabilityId)?.mcpServers?.[tool.serverName];
+    return agent?.mcpServers?.[tool.serverName];
 }
 /** The tool's settings in `manifest` (R2b C9); the defaults when its server is not there. */
 export function mcpToolSettingsIn(manifest, tool) {
     const server = serverOf(manifest, tool);
     return server ? mcpToolSettings(server, tool.serverToolName) : { enabled: true, approval: "never" };
 }
-/** True when the agent the tool belongs to has `tool_search` and `tool_call` (`nylorun.tools`). */
-function reachesDeferred(manifest, agentId) {
-    const agent = agentId === undefined ? manifest : delegateManifest(manifest, agentId);
-    return agent?.capabilities.some((capability) => capability.id === TOOLS_CAPABILITY_ID) === true;
-}
 /**
  * The tools of a snapshot, as the engine gets them for a turn whose manifest is `manifest` (the
  * session's pin, or a turn variant that tightened its MCP servers' tools):
  *
  * - a tool its settings disable is left out (R2b C9); the Tool Gate holds a call its approval
  *   or the Tenant's tool policy asks a person about (R5 step 2);
- * - a deferred tool (R2b C10) is marked so, out of the model's list, and its agent gets
- *   `tool_search`, with the note on the servers it holds deferred tools of, and `tool_call` in
- *   its `nylorun.tools` capability. An agent whose turn has no such capability keeps its tools in
- *   its list.
+ * - a deferred tool (R2b C10) is marked so, out of the model's list, and its agent gets the
+ *   session tools `tool_search`, with the note on the servers it holds deferred tools of, and
+ *   `tool_call`. Their names are reserved: no tool of the agent's own takes them.
  *
  * Nothing here changes between the steps of a turn, so neither does the model's tool list.
  */
@@ -90,10 +90,9 @@ export function sessionToolsOf(snapshot, manifest) {
         const settings = mcpToolSettingsIn(manifest, tool);
         if (!settings.enabled)
             continue;
-        const defer = tool.deferred === true && reachesDeferred(manifest, tool.agentId);
+        const defer = tool.deferred === true;
         const entry = {
             ...(tool.agentId === undefined ? {} : { agentId: tool.agentId }),
-            capabilityId: tool.capabilityId,
             name: tool.name,
             ...(tool.description === undefined ? {} : { description: tool.description }),
             inputSchema: tool.inputSchema,
@@ -109,7 +108,7 @@ export function sessionToolsOf(snapshot, manifest) {
         servers.set(tool.serverName, (servers.get(tool.serverName) ?? 0) + 1);
         notes.set(tool.agentId, servers);
     }
-    const platform = [];
+    const session = [];
     for (const [agentId, tools] of deferred) {
         const servers = [...notes.get(agentId)].map(([serverName, count]) => {
             const instructions = snapshot.servers?.find((item) => item.agentId === agentId && item.serverName === serverName)?.instructions;
@@ -120,14 +119,10 @@ export function sessionToolsOf(snapshot, manifest) {
             { ...search, instructions: [deferredToolsInstructions(servers)] },
             call,
         ])
-            platform.push({
-                ...(agentId === undefined ? {} : { agentId }),
-                capabilityId: TOOLS_CAPABILITY_ID,
-                ...tool,
-            });
-        platform.push(...tools);
+            session.push({ ...(agentId === undefined ? {} : { agentId }), ...tool });
+        session.push(...tools);
     }
-    return [...inline, ...platform];
+    return [...inline, ...session];
 }
 /** The share of the model's context window past which an agent's MCP tools are deferred (Q21). */
 export const DEFER_CONTEXT_SHARE = 0.1;
@@ -137,9 +132,7 @@ export const CHARS_PER_TOKEN = 4;
  * The snapshot with its deferred tools marked (R2b C10, Q21), decided once for the session when
  * core records it. A tool's own setting, then `"*"`'s, then its server's, decides; a tool none
  * sets is deferred when the JSON of its agent's MCP tools that would be listed passes a tenth of
- * the model's context window (`contextWindow` tokens, at 4 characters a token). An agent without
- * the `nylorun.tools` capability (its definition names a tool `tool_search` or `tool_call`, or the
- * session was opened before it existed) defers nothing.
+ * the model's context window (`contextWindow` tokens, at 4 characters a token).
  */
 export function pinDeferral(snapshot, manifest, contextWindow) {
     const limit = contextWindow * CHARS_PER_TOKEN * DEFER_CONTEXT_SHARE;
@@ -153,8 +146,6 @@ export function pinDeferral(snapshot, manifest, contextWindow) {
     });
     const mcpTools = snapshot.mcpTools.map((tool, i) => {
         const { deferred: _, ...rest } = tool;
-        if (!reachesDeferred(manifest, tool.agentId))
-            return rest;
         const defer = set[i] ?? (listed.get(tool.agentId) ?? 0) > limit;
         return defer ? { ...rest, deferred: true } : rest;
     });
@@ -165,9 +156,7 @@ export function pinDeferral(snapshot, manifest, contextWindow) {
  * the turn's `manifest`, a tool its settings disable is not one either (R2b C9).
  */
 export function mcpToolOf(snapshot, request, manifest) {
-    const tool = snapshot?.mcpTools.find((tool) => tool.agentId === request.agent?.id &&
-        tool.capabilityId === request.capabilityId &&
-        tool.name === request.toolName);
+    const tool = snapshot?.mcpTools.find((tool) => tool.agentId === request.agent?.id && tool.name === request.toolName);
     if (tool && manifest && !isEnabledIn(manifest, tool))
         return undefined;
     return tool;

package/dist/model/capabilities.d.ts

@@ -0,0 +1,26 @@
+/**
+ * What a model reads (protocol 12): its pi-ai catalog's `input` (text, image) and what the
+ * operator added. One function, `capabilitiesOf`, serves the catalog, the accept check, the Model
+ * Gate and `read_artifact`.
+ *
+ * The operator may add only an input our provider path sends natively for the model's API
+ * (`NATIVE_INPUTS`): an image on every API; a PDF on the APIs below; Office documents on the
+ * OpenAI Responses APIs; audio and video on Google's APIs and OpenAI-compatible completions.
+ */
+import type { Api, Model } from "@earendil-works/pi-ai";
+import { type ModelInput } from "@nylorun/core/contracts";
+/** What `capabilitiesOf` reads of a pi-ai model. */
+export type ModelShape = Pick<Model<Api>, "api" | "input">;
+/** The inputs each API carries natively, beyond text. Any other API: images only. */
+export declare const NATIVE_INPUTS: Readonly<Record<string, readonly ModelInput[]>>;
+/** What the operator may add to `model`: the inputs its API carries that its catalog lacks. */
+export declare function addableInputs(model: ModelShape): ModelInput[];
+/**
+ * What `model` reads: text, its catalog's inputs and those of `added` its API carries, in
+ * `MODEL_INPUTS` order.
+ */
+export declare function capabilitiesOf(model: ModelShape, added?: readonly ModelInput[]): {
+    readonly inputs: ModelInput[];
+};
+/** Why `inputs` cannot be set for `model`, or undefined when they can. */
+export declare function inputsError(model: ModelShape, inputs: readonly ModelInput[]): string | undefined;

package/dist/model/capabilities.js

@@ -0,0 +1,44 @@
+import { MODEL_INPUTS } from "@nylorun/core/contracts";
+/** The inputs each API carries natively, beyond text. Any other API: images only. */
+export const NATIVE_INPUTS = {
+    "anthropic-messages": ["image", "pdf"],
+    "openai-responses": ["image", "pdf", "office"],
+    "azure-openai-responses": ["image", "pdf", "office"],
+    "openai-completions": ["image", "pdf", "audio", "video"],
+    "google-generative-ai": ["image", "pdf", "audio", "video"],
+    "google-vertex": ["image", "pdf", "audio", "video"],
+};
+function nativeInputs(model) {
+    return NATIVE_INPUTS[model.api] ?? ["image"];
+}
+function ordered(inputs) {
+    const set = new Set(inputs);
+    return MODEL_INPUTS.filter((input) => set.has(input));
+}
+/** What the operator may add to `model`: the inputs its API carries that its catalog lacks. */
+export function addableInputs(model) {
+    const own = model.input;
+    return ordered(nativeInputs(model).filter((input) => !own.includes(input)));
+}
+/**
+ * What `model` reads: text, its catalog's inputs and those of `added` its API carries, in
+ * `MODEL_INPUTS` order.
+ */
+export function capabilitiesOf(model, added = []) {
+    const native = nativeInputs(model);
+    return {
+        inputs: ordered([
+            "text",
+            ...model.input,
+            ...added.filter((input) => native.includes(input)),
+        ]),
+    };
+}
+/** Why `inputs` cannot be set for `model`, or undefined when they can. */
+export function inputsError(model, inputs) {
+    const allowed = new Set(["text", ...model.input, ...nativeInputs(model)]);
+    const refused = ordered(inputs.filter((input) => !allowed.has(input)));
+    if (refused.length === 0)
+        return undefined;
+    return `This model's API (${model.api}) cannot carry ${refused.join(", ")}; it can read ${ordered(allowed).join(", ")}.`;
+}

package/dist/model/catalog.d.ts

@@ -1,4 +1,6 @@
-import type { HostModelCatalog } from "@nylorun/core/contracts";
+import type { Api, Model } from "@earendil-works/pi-ai";
+import type { HostModelCatalog, HostModelView, ModelInput } from "@nylorun/core/contracts";
+import type { SessionStore } from "../store/types.js";
 export type { HostModelCatalog };
 /**
  * The context window, in tokens, of the Tenant's model (`GET /v1/tenant/model`'s view): the
@@ -14,5 +16,34 @@ export declare function contextWindowOf(view: {
         contextWindow?: number;
     };
 }): number;
-/** Public provider and model names. No credentials. */
-export declare function hostModelCatalog(): HostModelCatalog;
+/**
+ * Public provider and model names, and what each model reads with the operator's additions
+ * (`added`, by `<provider>/<model>`) and what may be added (protocol 12). No credentials.
+ */
+export declare function hostModelCatalog(added?: Readonly<Record<string, readonly ModelInput[]>>): HostModelCatalog;
+/** A catalog model, by provider and id; undefined for one the catalog does not know. */
+export declare function catalogModel(provider: string, model: string): Model<Api> | undefined;
+/**
+ * What a configured model reads (protocol 12): a custom endpoint's `settings.inputs` (text only
+ * by default), else its catalog's inputs and the operator's additions (`added`). Undefined for no
+ * model, or one the catalog does not know.
+ */
+export declare function inputsOfHostModel(view: {
+    configured: boolean;
+    provider?: string;
+    model?: string;
+    baseUrl?: string;
+    settings?: {
+        inputs?: readonly ModelInput[];
+    };
+}, added?: Readonly<Record<string, readonly ModelInput[]>>): ModelInput[] | undefined;
+/**
+ * What the Tenant's model reads now, for the accept check and `read_artifact`: undefined when no
+ * model is in the vault (a test's fake provider, say), and the check is skipped.
+ */
+export declare function currentModelInputs(ctx: {
+    readonly store: SessionStore;
+    readonly vault: {
+        getHostModel(): Promise<HostModelView>;
+    };
+}): Promise<ModelInput[] | undefined>;

package/dist/model/catalog.js

@@ -1,3 +1,5 @@
+import { readAddedInputs } from "../tenant/model-setting.js";
+import { addableInputs, capabilitiesOf } from "./capabilities.js";
 import { CUSTOM_CONTEXT_WINDOW, modelsFor } from "./models.js";
 const emptyStore = {
     async read() {
@@ -24,8 +26,11 @@ export function contextWindowOf(view) {
     const models = modelsFor({ provider: "", model: "" }, emptyStore, { environment: false });
     return models.getModel(view.provider, view.model)?.contextWindow ?? CUSTOM_CONTEXT_WINDOW;
 }
-/** Public provider and model names. No credentials. */
-export function hostModelCatalog() {
+/**
+ * Public provider and model names, and what each model reads with the operator's additions
+ * (`added`, by `<provider>/<model>`) and what may be added (protocol 12). No credentials.
+ */
+export function hostModelCatalog(added = {}) {
     const models = modelsFor({ provider: "", model: "" }, emptyStore, {
         environment: false,
     });
@@ -36,7 +41,38 @@ export function hostModelCatalog() {
             models: models.getModels(provider.id).map((model) => ({
                 id: model.id,
                 name: model.name,
+                inputs: capabilitiesOf(model, added[`${provider.id}/${model.id}`]).inputs,
+                addableInputs: addableInputs(model),
             })),
         })),
     };
 }
+/** A catalog model, by provider and id; undefined for one the catalog does not know. */
+export function catalogModel(provider, model) {
+    return modelsFor({ provider: "", model: "" }, emptyStore, { environment: false }).getModel(provider, model);
+}
+/**
+ * What a configured model reads (protocol 12): a custom endpoint's `settings.inputs` (text only
+ * by default), else its catalog's inputs and the operator's additions (`added`). Undefined for no
+ * model, or one the catalog does not know.
+ */
+export function inputsOfHostModel(view, added = {}) {
+    if (!view.configured || !view.provider || !view.model)
+        return undefined;
+    if (view.baseUrl) {
+        const inputs = view.settings?.inputs ?? [];
+        return capabilitiesOf({ api: "openai-completions", input: inputs.includes("image") ? ["text", "image"] : ["text"] }, inputs).inputs;
+    }
+    const model = catalogModel(view.provider, view.model);
+    return model && capabilitiesOf(model, added[`${view.provider}/${view.model}`]).inputs;
+}
+/**
+ * What the Tenant's model reads now, for the accept check and `read_artifact`: undefined when no
+ * model is in the vault (a test's fake provider, say), and the check is skipped.
+ */
+export async function currentModelInputs(ctx) {
+    const view = await ctx.vault.getHostModel();
+    if (!view.configured)
+        return undefined;
+    return inputsOfHostModel(view, await ctx.store.tx((t) => readAddedInputs(t)));
+}