@nylorun/runtime 0.25.0-beta → 0.27.0-beta

package/dist/mcp/snapshot.js

@@ -1,20 +1,19 @@
-import { createHash } from "node:crypto";
-import { delegatesOf, pluginOf, deferredToolsInstructions, deferredToolsTools, delegateManifest, mcpToolSettings, } from "@nylorun/core/define";
+import { delegatesOf, pluginOf, delegateManifest, mcpToolSettings, } from "@nylorun/core/define";
+import { findServer } from "./pool.js";
 /**
- * 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).
+ * The `mcp.discovered` payload: each server's outcome, with the tools it added to the snapshot
+ * that its settings in `manifest` (the session's pinned one) leave enabled, and the Agent Plugin
+ * that brought the server.
  */
 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 key = (agentId, serverName) => JSON.stringify([agentId ?? null, serverName]);
     const tools = new Map();
-    const deferred = new Map();
-    for (const tool of snapshot.mcpTools) {
-        tools.set(key(tool), (tools.get(key(tool)) ?? 0) + 1);
-        if (tool.deferred)
-            deferred.set(key(tool), (deferred.get(key(tool)) ?? 0) + 1);
+    for (const server of snapshot.servers) {
+        const enabled = server.tools.filter((tool) => manifest === undefined || isEnabledIn(manifest, server.agentId, server.name, tool.name));
+        tools.set(key(server.agentId, server.name), enabled.length);
     }
     return {
         servers: diagnostics.map((item) => ({
@@ -23,149 +22,108 @@ export function mcpDiscovered(snapshot, diagnostics, manifest) {
             ...withPlugin(pluginOf(agents.get(item.agentId), { server: item.serverName })),
             outcome: item.outcome,
             message: item.message,
-            tools: tools.get(key(item)) ?? 0,
-            ...(deferred.has(key(item)) ? { deferred: deferred.get(key(item)) } : {}),
+            tools: tools.get(key(item.agentId, item.serverName)) ?? 0,
             ...(item.disabled ? { disabled: item.disabled } : {}),
             ...(item.unknownTools?.length ? { unknownTools: [...item.unknownTools] } : {}),
             ...(item.credentialIds === undefined ? {} : { credentialIds: [...item.credentialIds] }),
-            ...(item.renamed?.length ? { renamed: item.renamed.map((tool) => ({ ...tool })) } : {}),
         })),
     };
 }
 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;
-/**
- * The name the model knows an MCP tool by (R2b C6, Q13): `server__tool`, with each character
- * outside `[A-Za-z0-9_-]` replaced by `_`, since MCP allows `.` and 128 characters and OpenAI,
- * Bedrock and Gemini on Vertex do not. A name over 64 characters, or one that collides
- * (`suffixed`), keeps 55 and adds `_` and 8 hex characters of the SHA-256 of the raw
- * `server/tool`.
- */
-export function normalizeToolName(serverName, serverToolName, options = {}) {
-    const name = `${serverName}__${serverToolName}`.replace(/[^A-Za-z0-9_-]/gu, "_");
-    if (name.length <= MODEL_TOOL_NAME_MAX && !options.suffixed)
-        return name;
-    const hash = createHash("sha256")
-        .update(`${serverName}/${serverToolName}`)
-        .digest("hex")
-        .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) {
-    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?.mcpServers?.[tool.serverName];
+/** The tool `tool` of server `server` of agent `agentId` (the root when absent), as discovered. */
+export function mcpToolIn(snapshot, agentId, server, tool) {
+    return snapshot?.servers
+        .find((item) => item.agentId === agentId && item.name === server)
+        ?.tools.find((item) => item.name === tool);
 }
 /** 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" };
+export function mcpToolSettingsIn(manifest, agentId, server, tool) {
+    const declared = findServer(manifest, agentId, server);
+    return declared ? mcpToolSettings(declared.server, tool) : { enabled: true, approval: "never" };
+}
+/** True when the tool's settings in `manifest` leave it enabled (R2b C9). */
+export function isEnabledIn(manifest, agentId, server, tool) {
+    return mcpToolSettingsIn(manifest, agentId, server, tool).enabled;
 }
 /**
- * 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 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.
+ * The snapshot's facts for a turn whose manifest is `manifest` (the session's pin, or a turn
+ * variant that tightened its MCP servers' tools): each tool with whether its settings leave it
+ * `enabled` and, when they say, whether to defer it. A server the turn's manifest no longer
+ * declares is left out.
  */
-export function sessionToolsOf(snapshot, manifest) {
-    if (!snapshot?.mcpTools.length)
-        return undefined;
-    const inline = [];
-    const deferred = new Map();
-    const notes = new Map();
-    for (const tool of snapshot.mcpTools) {
-        const settings = mcpToolSettingsIn(manifest, tool);
-        if (!settings.enabled)
-            continue;
-        const defer = tool.deferred === true;
-        const entry = {
-            ...(tool.agentId === undefined ? {} : { agentId: tool.agentId }),
-            name: tool.name,
-            ...(tool.description === undefined ? {} : { description: tool.description }),
-            inputSchema: tool.inputSchema,
-            ...(tool.outputSchema === undefined ? {} : { outputSchema: tool.outputSchema }),
-            ...(defer ? { deferred: true } : {}),
-        };
-        if (!defer) {
-            inline.push(entry);
-            continue;
-        }
-        deferred.set(tool.agentId, [...(deferred.get(tool.agentId) ?? []), entry]);
-        const servers = notes.get(tool.agentId) ?? new Map();
-        servers.set(tool.serverName, (servers.get(tool.serverName) ?? 0) + 1);
-        notes.set(tool.agentId, servers);
-    }
-    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;
-            return { serverName, tools: count, ...(instructions ? { instructions } : {}) };
-        });
-        const [search, call] = deferredToolsTools();
-        for (const tool of [
-            { ...search, instructions: [deferredToolsInstructions(servers)] },
-            call,
-        ])
-            session.push({ ...(agentId === undefined ? {} : { agentId }), ...tool });
-        session.push(...tools);
-    }
-    return [...inline, ...session];
+export function mcpFactsOf(snapshot, manifest) {
+    return {
+        servers: snapshot.servers.flatMap((server) => {
+            if (!findServer(manifest, server.agentId, server.name))
+                return [];
+            return [
+                {
+                    ...(server.agentId === undefined ? {} : { agentId: server.agentId }),
+                    name: server.name,
+                    ...(server.instructions === undefined ? {} : { instructions: server.instructions }),
+                    tools: server.tools.map((tool) => {
+                        const settings = mcpToolSettingsIn(manifest, server.agentId, server.name, tool.name);
+                        return {
+                            ...tool,
+                            enabled: settings.enabled,
+                            ...(settings.deferred === undefined ? {} : { deferred: settings.deferred }),
+                        };
+                    }),
+                },
+            ];
+        }),
+    };
+}
+/** The manifest of the agent an effect belongs to: the root, or an agent it uses as a tool. */
+export function manifestFor(manifest, agent) {
+    return agent ? delegateManifest(manifest, agent.id) : manifest;
 }
-/** 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;
-/** Characters per token, to estimate what tool definitions take of a context window (Q21). */
-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).
+ * `snapshot` within the Tenant's Runtime limit `mcpSnapshotBytes` (its JSON, which every
+ * `turn.start.mcp` carries): its servers in order while they fit. A server that does not is left
+ * out, so the session never offers its tools, and its diagnostic says so (`failed`, replacing
+ * the one it had). Unchanged when the whole snapshot fits.
  */
-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) => mcpToolSettingsIn(manifest, tool).deferred);
-    snapshot.mcpTools.forEach((tool, i) => {
-        if (set[i] === true)
-            return;
-        const size = JSON.stringify({ name: tool.name, description: tool.description ?? "", inputSchema: tool.inputSchema }).length;
-        listed.set(tool.agentId, (listed.get(tool.agentId) ?? 0) + size);
+export function fitSnapshot(snapshot, diagnostics, limitBytes) {
+    const bytes = (value) => Buffer.byteLength(JSON.stringify(value));
+    if (bytes(snapshot) <= limitBytes)
+        return { snapshot, diagnostics: [...diagnostics] };
+    const kept = [];
+    const dropped = new Map();
+    const key = (agentId, serverName) => JSON.stringify([agentId ?? null, serverName]);
+    for (const server of snapshot.servers) {
+        const next = { ...snapshot, servers: [...kept, server] };
+        const size = bytes(next);
+        if (size <= limitBytes)
+            kept.push(server);
+        else
+            dropped.set(key(server.agentId, server.name), bytes(server));
+    }
+    const tooLarge = (agentId, serverName, size) => ({
+        ...(agentId === undefined ? {} : { agentId }),
+        serverName,
+        outcome: "failed",
+        message: `The server's tools and instructions take ${size} bytes, past what the session may pin with the rest: the Runtime limit mcpSnapshotBytes (${limitBytes} bytes; PUT /v1/tenant/limits). Its tools are not offered.`,
     });
-    const mcpTools = snapshot.mcpTools.map((tool, i) => {
-        const { deferred: _, ...rest } = tool;
-        const defer = set[i] ?? (listed.get(tool.agentId) ?? 0) > limit;
-        return defer ? { ...rest, deferred: true } : rest;
+    const out = diagnostics.map((item) => {
+        const size = dropped.get(key(item.agentId, item.serverName));
+        return size === undefined ? item : tooLarge(item.agentId, item.serverName, size);
     });
-    return { ...snapshot, mcpTools };
-}
-/**
- * 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 function mcpToolOf(snapshot, request, manifest) {
-    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 mcpToolSettingsIn(manifest, tool).enabled;
+    for (const server of snapshot.servers) {
+        const size = dropped.get(key(server.agentId, server.name));
+        if (size !== undefined && !out.some((item) => key(item.agentId, item.serverName) === key(server.agentId, server.name)))
+            out.push(tooLarge(server.agentId, server.name, size));
+    }
+    return { snapshot: { ...snapshot, servers: kept }, diagnostics: out };
 }
-/** The manifest of the agent an effect belongs to: the root, or an agent it uses as a tool. */
-export function manifestFor(manifest, agent) {
-    return agent ? delegateManifest(manifest, agent.id) : manifest;
+/** True for a snapshot of the shape this Runtime pins (`snapshotSchemaVersion` 2). */
+export function isSnapshot(value) {
+    const snapshot = value;
+    return (typeof snapshot === "object" &&
+        snapshot !== null &&
+        snapshot.snapshotSchemaVersion === 2 &&
+        typeof snapshot.manifestHash === "string" &&
+        Array.isArray(snapshot.servers));
 }

package/dist/model/auth-store.js

@@ -1,6 +1,7 @@
 var _a;
 import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
+import { hostTuning } from "../tuning.js";
 export class ProjectCredentialStore {
     file;
     legacyFile;
@@ -68,7 +69,8 @@ export class ProjectCredentialStore {
     async #locked(operation) {
         await mkdir(dirname(this.file), { recursive: true });
         const lock = this.file + ".lock";
-        for (let attempt = 0; attempt < 100; attempt += 1) {
+        const { credentialLockPollMs: pollMs, credentialLockAttempts: attempts } = hostTuning().host;
+        for (let attempt = 0; attempt < attempts; attempt += 1) {
             try {
                 await mkdir(lock);
                 break;
@@ -76,9 +78,9 @@ export class ProjectCredentialStore {
             catch (error) {
                 if (error.code !== "EEXIST")
                     throw error;
-                await new Promise((resolve) => setTimeout(resolve, 25));
+                await new Promise((resolve) => setTimeout(resolve, pollMs));
             }
-            if (attempt === 99)
+            if (attempt === attempts - 1)
                 throw new Error("Timed out waiting for the credential store.");
         }
         try {

package/dist/model/capabilities.d.ts

@@ -1,7 +1,7 @@
 /**
  * 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`.
+ * Gate.
  *
  * 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

package/dist/model/catalog.d.ts

@@ -1,21 +1,7 @@
 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";
+import type { HostModelCatalog, ModelInput } from "@nylorun/core/contracts";
+import { type ModelBindingView } from "./descriptor.js";
 export type { HostModelCatalog };
-/**
- * The context window, in tokens, of the Tenant's model (`GET /v1/tenant/model`'s view): the
- * custom endpoint's setting, else the provider catalog's. A model the catalog does not know, or
- * none configured, is assumed small (`CUSTOM_CONTEXT_WINDOW`), as for a custom endpoint.
- */
-export declare function contextWindowOf(view: {
-    configured: boolean;
-    provider?: string;
-    model?: string;
-    baseUrl?: string;
-    settings?: {
-        contextWindow?: number;
-    };
-}): number;
 /**
  * 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.
@@ -25,25 +11,12 @@ export declare function hostModelCatalog(added?: Readonly<Record<string, readonl
 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.
+ * by default), else its catalog's inputs and the operator's additions (`added`), as its
+ * descriptor says (`hostModelDescriptor`). 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>;
+    readonly configured: false;
+} | ({
+    readonly configured: true;
+} & ModelBindingView), added?: Readonly<Record<string, readonly ModelInput[]>>): ModelInput[] | undefined;

package/dist/model/catalog.js

@@ -1,6 +1,6 @@
-import { readAddedInputs } from "../tenant/model-setting.js";
 import { addableInputs, capabilitiesOf } from "./capabilities.js";
-import { CUSTOM_CONTEXT_WINDOW, modelsFor } from "./models.js";
+import { hostModelDescriptor } from "./descriptor.js";
+import { modelsFor } from "./models.js";
 const emptyStore = {
     async read() {
         return undefined;
@@ -13,19 +13,6 @@ const emptyStore = {
     },
     async delete() { },
 };
-/**
- * The context window, in tokens, of the Tenant's model (`GET /v1/tenant/model`'s view): the
- * custom endpoint's setting, else the provider catalog's. A model the catalog does not know, or
- * none configured, is assumed small (`CUSTOM_CONTEXT_WINDOW`), as for a custom endpoint.
- */
-export function contextWindowOf(view) {
-    if (!view.configured || !view.provider || !view.model)
-        return CUSTOM_CONTEXT_WINDOW;
-    if (view.baseUrl)
-        return view.settings?.contextWindow ?? CUSTOM_CONTEXT_WINDOW;
-    const models = modelsFor({ provider: "", model: "" }, emptyStore, { environment: false });
-    return models.getModel(view.provider, view.model)?.contextWindow ?? CUSTOM_CONTEXT_WINDOW;
-}
 /**
  * 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.
@@ -53,26 +40,12 @@ export function catalogModel(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.
+ * by default), else its catalog's inputs and the operator's additions (`added`), as its
+ * descriptor says (`hostModelDescriptor`). 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)));
+    return hostModelDescriptor(view, added)?.inputs;
 }

package/dist/model/descriptor.d.ts

@@ -0,0 +1,51 @@
+/**
+ * The model descriptor (protocol 15): the Tenant's model as a harness learns it in
+ * `turn.start.model` — its provider and id, what it reads, its context window and output limit.
+ * One resolution serves the descriptor, the catalog's inputs and the Model Gate: the binding
+ * becomes a pi-ai `Selection` (`selectionOf`), the registry finds the model, and
+ * `describeModel` reads it with the operator's additions. So what a harness is told and what the
+ * gate takes cannot disagree.
+ */
+import type { Api, Model } from "@earendil-works/pi-ai";
+import { type CustomModelSettings, type HostModelView, type ModelInput } from "@nylorun/core/contracts";
+import type { ModelDescriptor } from "@nylorun/core/harness-api";
+import type { SessionStore } from "../store/types.js";
+import { type Selection } from "./models.js";
+/** A configured model: its provider and model, and a custom endpoint's address and settings. */
+export interface ModelBindingView {
+    readonly provider: string;
+    readonly model: string;
+    readonly baseUrl?: string;
+    readonly settings?: CustomModelSettings;
+}
+/**
+ * The pi-ai selection for `binding`. A call may name another model of the same provider
+ * (`requested`, as `<model>` or `<provider>/<model>`); a custom endpoint carries its settings.
+ */
+export declare function selectionOf(binding: ModelBindingView, requested?: string): Selection;
+/** The inputs the operator added that apply to `selection`: a custom endpoint's own, or the Tenant's. */
+export declare function addedInputsOf(selection: Selection, binding: Pick<ModelBindingView, "settings">, added: Readonly<Record<string, readonly ModelInput[]>>): readonly ModelInput[] | undefined;
+/** A pi-ai model as a descriptor, with the inputs the operator added (`capabilitiesOf`). */
+export declare function describeModel(found: Model<Api>, added?: readonly ModelInput[]): ModelDescriptor;
+/** The fixture model (`model.fixture`): it reads every input, since it ignores files. */
+export declare const FIXTURE_DESCRIPTOR: ModelDescriptor;
+/**
+ * The descriptor of a configured model (`binding`), with the Tenant's added inputs; undefined
+ * for a model the catalog does not know. No credential is read.
+ */
+export declare function hostModelDescriptor(binding: ModelBindingView, added?: Readonly<Record<string, readonly ModelInput[]>>): ModelDescriptor | undefined;
+/**
+ * The model the Tenant's turns use now: the fixture model's descriptor when the Tenant uses it,
+ * else its active model's; undefined when none is configured (a test's scripted provider, say).
+ */
+export declare function currentModelDescriptor(ctx: {
+    readonly store: SessionStore;
+    readonly vault: {
+        getHostModel(): Promise<HostModelView>;
+    };
+}): Promise<ModelDescriptor | undefined>;
+/**
+ * The context window, in tokens, of the Tenant's model now; without one, or one the catalog does
+ * not know, it is assumed small (`CUSTOM_MODEL_SETTING_DEFAULTS`), as for a custom endpoint.
+ */
+export declare function currentContextWindow(ctx: Parameters<typeof currentModelDescriptor>[0]): Promise<number>;

package/dist/model/descriptor.js

@@ -0,0 +1,83 @@
+import { MODEL_INPUTS, } from "@nylorun/core/contracts";
+import { readAddedInputs, usesFixtureModel } from "../tenant/model-setting.js";
+import { capabilitiesOf } from "./capabilities.js";
+import { CUSTOM_MODEL_SETTING_DEFAULTS } from "@nylorun/core/contracts";
+import { modelsFor } from "./models.js";
+/**
+ * The pi-ai selection for `binding`. A call may name another model of the same provider
+ * (`requested`, as `<model>` or `<provider>/<model>`); a custom endpoint carries its settings.
+ */
+export function selectionOf(binding, requested) {
+    return {
+        provider: binding.provider,
+        model: requested?.startsWith(`${binding.provider}/`)
+            ? requested.slice(binding.provider.length + 1)
+            : (requested ?? binding.model),
+        ...(binding.baseUrl ? { custom: { baseUrl: binding.baseUrl, ...(binding.settings ?? {}) } } : {}),
+    };
+}
+/** The inputs the operator added that apply to `selection`: a custom endpoint's own, or the Tenant's. */
+export function addedInputsOf(selection, binding, added) {
+    return selection.custom ? binding.settings?.inputs : added[`${selection.provider}/${selection.model}`];
+}
+/** A pi-ai model as a descriptor, with the inputs the operator added (`capabilitiesOf`). */
+export function describeModel(found, added) {
+    return {
+        provider: found.provider,
+        id: found.id,
+        inputs: capabilitiesOf(found, added).inputs,
+        contextWindow: found.contextWindow,
+        maxOutputTokens: found.maxTokens,
+        ...(found.reasoning === undefined ? {} : { reasoning: found.reasoning }),
+    };
+}
+/** The fixture model (`model.fixture`): it reads every input, since it ignores files. */
+export const FIXTURE_DESCRIPTOR = Object.freeze({
+    provider: "fixture",
+    id: "fixture",
+    inputs: [...MODEL_INPUTS],
+    contextWindow: CUSTOM_MODEL_SETTING_DEFAULTS.contextWindow,
+    maxOutputTokens: CUSTOM_MODEL_SETTING_DEFAULTS.maxTokens,
+});
+const emptyStore = {
+    async read() {
+        return undefined;
+    },
+    async list() {
+        return [];
+    },
+    async modify(_providerId, fn) {
+        return fn(undefined);
+    },
+    async delete() { },
+};
+/**
+ * The descriptor of a configured model (`binding`), with the Tenant's added inputs; undefined
+ * for a model the catalog does not know. No credential is read.
+ */
+export function hostModelDescriptor(binding, added = {}) {
+    const selection = selectionOf(binding);
+    const found = modelsFor(selection, emptyStore, { environment: false }).getModel(selection.provider, selection.model);
+    return found && describeModel(found, addedInputsOf(selection, binding, added));
+}
+/**
+ * The model the Tenant's turns use now: the fixture model's descriptor when the Tenant uses it,
+ * else its active model's; undefined when none is configured (a test's scripted provider, say).
+ */
+export async function currentModelDescriptor(ctx) {
+    const { fixture, added } = await ctx.store.tx(async (t) => ({
+        fixture: await usesFixtureModel(t),
+        added: await readAddedInputs(t),
+    }));
+    if (fixture)
+        return FIXTURE_DESCRIPTOR;
+    const view = await ctx.vault.getHostModel();
+    return view.configured ? hostModelDescriptor(view, added) : undefined;
+}
+/**
+ * The context window, in tokens, of the Tenant's model now; without one, or one the catalog does
+ * not know, it is assumed small (`CUSTOM_MODEL_SETTING_DEFAULTS`), as for a custom endpoint.
+ */
+export async function currentContextWindow(ctx) {
+    return (await currentModelDescriptor(ctx))?.contextWindow ?? CUSTOM_MODEL_SETTING_DEFAULTS.contextWindow;
+}

package/dist/model/models.d.ts

@@ -13,9 +13,6 @@ export type Selection = Readonly<{
         compat?: Readonly<Record<string, unknown>>;
     }>;
 }>;
-/** A custom endpoint whose window is unknown is assumed small: an early compaction beats a failed call. */
-export declare const CUSTOM_CONTEXT_WINDOW = 32768;
-export declare const CUSTOM_MAX_TOKENS = 8192;
 /**
  * Build the pi-ai model registry from explicit credentials only.
  * Ambient process environment / provider env auth is never consulted (A7, A10).

package/dist/model/models.js

@@ -1,9 +1,7 @@
 import { createProvider, } from "@earendil-works/pi-ai";
 import { stream, streamSimple, } from "@earendil-works/pi-ai/api/openai-completions";
 import { builtinModels } from "@earendil-works/pi-ai/providers/all";
-/** A custom endpoint whose window is unknown is assumed small: an early compaction beats a failed call. */
-export const CUSTOM_CONTEXT_WINDOW = 32_768;
-export const CUSTOM_MAX_TOKENS = 8_192;
+import { CUSTOM_MODEL_SETTING_DEFAULTS } from "@nylorun/core/contracts";
 /**
  * Build the pi-ai model registry from explicit credentials only.
  * Ambient process environment / provider env auth is never consulted (A7, A10).
@@ -27,8 +25,8 @@ export function modelsFor(selection, credentials, options = {}) {
         reasoning: selection.custom.reasoning ?? false,
         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,
+        contextWindow: selection.custom.contextWindow ?? CUSTOM_MODEL_SETTING_DEFAULTS.contextWindow,
+        maxTokens: selection.custom.maxTokens ?? CUSTOM_MODEL_SETTING_DEFAULTS.maxTokens,
         ...(selection.custom.compat
             ? { compat: { ...selection.custom.compat } }
             : {}),

package/dist/model/native-blocks.js

@@ -13,7 +13,7 @@
  * sending a marker to the model.
  */
 import { randomUUID } from "node:crypto";
-import { essence } from "../artifacts/media-types.js";
+import { essence } from "@nylorun/core/contracts";
 import { NATIVE_INPUTS } from "./capabilities.js";
 /**
  * The kinds each pi-ai API has a native block for here: the model inputs an operator may add