@nylorun/runtime 0.23.0-beta → 0.25.0-beta

package/dist/mcp/snapshot.d.ts

@@ -1,11 +1,10 @@
 import type { EventPayload } from "@nylorun/core/contracts";
 import type { JsonObject } from "@nylorun/core/define";
-import { type AgentManifest } from "@nylorun/core/define";
+import { type AgentManifest, type ResolvedMcpToolSettings } from "@nylorun/core/define";
 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;
@@ -14,14 +13,6 @@ export interface McpToolRecord {
     readonly description?: string;
     readonly inputSchema: JsonObject;
     readonly outputSchema?: JsonObject;
-    /**
-     * The server's hints that calling the tool again is safe (R2b C7, Q15): a call whose answer
-     * was lost after it was sent is then `mcp.lost` to the model, not `uncertain`.
-     */
-    readonly annotations?: {
-        readonly readOnlyHint?: boolean;
-        readonly idempotentHint?: boolean;
-    };
     /**
      * Out of the model's tool list for the session's life (R2b C10): core decides it once, when it
      * records the snapshot (`pinDeferral`), so every model call of the session lists the same tools.
@@ -31,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;
@@ -46,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;
@@ -63,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;
 /**
@@ -77,17 +69,19 @@ 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;
 /**
  * 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); one whose approval resolves to `always`
- *   waits for approval on each call;
- * - 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 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 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.
  */
@@ -100,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. */
-function settingsOf(manifest, tool) {
+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); one whose approval resolves to `always`
- *   waits for approval on each call;
- * - 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 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 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.
  */
@@ -87,18 +87,16 @@ export function sessionToolsOf(snapshot, manifest) {
     const deferred = new Map();
     const notes = new Map();
     for (const tool of snapshot.mcpTools) {
-        const settings = settingsOf(manifest, tool);
+        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,
             ...(tool.outputSchema === undefined ? {} : { outputSchema: tool.outputSchema }),
-            ...(settings.approval === "always" ? { approval: "always" } : {}),
             ...(defer ? { deferred: true } : {}),
         };
         if (!defer) {
@@ -110,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;
@@ -121,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;
@@ -138,14 +132,12 @@ 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;
     const listed = new Map();
-    const set = snapshot.mcpTools.map((tool) => settingsOf(manifest, tool).deferred);
+    const set = snapshot.mcpTools.map((tool) => mcpToolSettingsIn(manifest, tool).deferred);
     snapshot.mcpTools.forEach((tool, i) => {
         if (set[i] === true)
             return;
@@ -154,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;
     });
@@ -166,16 +156,14 @@ 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;
 }
 /** True when the tool's settings in `manifest` leave it enabled (R2b C9). */
 export function isEnabledIn(manifest, tool) {
-    return settingsOf(manifest, tool).enabled;
+    return mcpToolSettingsIn(manifest, tool).enabled;
 }
 /** The manifest of the agent an effect belongs to: the root, or an agent it uses as a tool. */
 export function manifestFor(manifest, agent) {

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)));
+}

package/dist/model/models.d.ts

@@ -8,6 +8,8 @@ export type Selection = Readonly<{
         contextWindow?: number;
         maxTokens?: number;
         reasoning?: boolean;
+        /** What the endpoint reads (protocol 12); text only unless it says so. */
+        inputs?: readonly string[];
         compat?: Readonly<Record<string, unknown>>;
     }>;
 }>;

package/dist/model/models.js

@@ -25,7 +25,7 @@ export function modelsFor(selection, credentials, options = {}) {
         provider: "custom",
         baseUrl: selection.custom.baseUrl,
         reasoning: selection.custom.reasoning ?? false,
-        input: ["text", "image"],
+        input: selection.custom.inputs?.includes("image") ? ["text", "image"] : ["text"],
         cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
         contextWindow: selection.custom.contextWindow ?? CUSTOM_CONTEXT_WINDOW,
         maxTokens: selection.custom.maxTokens ?? CUSTOM_MAX_TOKENS,

package/dist/model/native-blocks.d.ts

@@ -0,0 +1,35 @@
+import type { TextContent } from "@earendil-works/pi-ai";
+/** The kinds of file a native block carries; images are pi-ai's own. */
+export type NativeFileKind = "pdf" | "office" | "audio" | "video";
+/** A file for one model call: its kind, media type, name and base64 bytes. */
+export interface NativeFile {
+    readonly kind: NativeFileKind;
+    readonly mediaType: string;
+    readonly name: string;
+    /** The bytes, base64-encoded. */
+    readonly data: string;
+}
+/**
+ * The kinds each pi-ai API has a native block for here: the model inputs an operator may add
+ * (`NATIVE_INPUTS`), images aside, so the two tables never disagree.
+ */
+export declare const NATIVE_FILE_KINDS: Readonly<Record<string, readonly NativeFileKind[]>>;
+/** The kinds of file `api` carries in a native block; none for an API without a rewriter. */
+export declare function nativeKindsOf(api: string): readonly NativeFileKind[];
+export declare class NativeBlocks {
+    private readonly files;
+    /** Why the last `rewrite` could not carry every file; undefined when it did. */
+    error?: string;
+    /** How many files this call carries. */
+    get size(): number;
+    /** A text part standing for `file` in pi-ai's context, replaced by `rewrite`. */
+    add(file: NativeFile): TextContent;
+    /**
+     * `payload` (an `onPayload` request body for `api`) with each marker block replaced by its
+     * native block. Rewrites in place and returns the same payload; sets `error` when a file
+     * could not be carried.
+     */
+    rewrite(payload: unknown, api: string): unknown;
+    /** The native block for a marker block of ours; undefined for any other block. */
+    private replace;
+}