@nylorun/runtime 0.25.0-beta → 0.27.0-beta

package/dist/model/pi-model.d.ts

@@ -1,22 +1,33 @@
 import { type Credential } from "@earendil-works/pi-ai";
 import type { RuntimeModelAdapter } from "../contracts.js";
+import { type RuntimeLimits } from "@nylorun/core/contracts";
 import { type FileResolver } from "../artifacts/files.js";
 import type { HostModelSecret } from "../vault/service.js";
 export interface ModelPreview {
     readonly invocationId: string;
     readonly text: string;
 }
-/** Retry, timeout and cache settings for one model call (Model Calls §5, §6). */
+/**
+ * Retry and timeout settings for one model call (Model Calls §5, §6): the Tenant's Runtime limits
+ * `model*` (`modelCallSettingsOf`), which the gates read for each call. Each left out is that
+ * limit's default.
+ */
 export interface ModelCallSettings {
-    /** Attempts per call, including the first. Default 3. */
+    /** Attempts per call, including the first (`modelAttempts`). */
     readonly attempts?: number;
-    /** Base delay between attempts; doubles each time, with jitter. Default 2 s. */
+    /** Base delay between attempts; doubles each time, with jitter (`modelRetryDelayMs`). */
     readonly retryBaseDelayMs?: number;
-    /** A stream with no event for this long is aborted and retried. Default 300 s. */
+    /** A stream with no event for this long is aborted and retried (`modelIdleMs`). */
     readonly idleTimeoutMs?: number;
-    /** Whole-request timeout passed to the provider SDK. Default 600 s. */
+    /** Whole-request timeout passed to the provider SDK (`modelRequestMs`). */
     readonly requestTimeoutMs?: number;
+    /** Retries the provider SDK makes within one attempt (`modelProviderRetries`). */
+    readonly providerRetries?: number;
+    /** The longest delay the provider SDK waits before one of them (`modelRetryDelayMaxMs`). */
+    readonly maxRetryDelayMs?: number;
 }
+/** The model call settings the Runtime limits `limits` set. */
+export declare function modelCallSettingsOf(limits: RuntimeLimits): Required<ModelCallSettings>;
 export interface PiModelOptions {
     readonly root?: string;
     readonly onPreview?: (preview: ModelPreview) => void;

package/dist/model/pi-model.js

@@ -1,13 +1,25 @@
-import { parseJsonWithRepair, retryAssistantCall, } from "@earendil-works/pi-ai";
+import { retryAssistantCall, } from "@earendil-works/pi-ai";
+import { RUNTIME_LIMIT_DEFAULTS } from "@nylorun/core/contracts";
 import { mediaReferenceOf } from "@nylorun/core/define";
 import { FileUnavailableError, } from "../artifacts/files.js";
-import { essence, inputLabel, isModelImage, isText, modelInputOf, unreadableReason, } from "../artifacts/media-types.js";
+import { essence, inputLabel, isModelImage, modelInputOf } from "@nylorun/core/contracts";
 import { scrub } from "../redact.js";
-import { capabilitiesOf } from "./capabilities.js";
 import { classifyAssistantError, failure } from "./classify.js";
+import { addedInputsOf, describeModel, selectionOf } from "./descriptor.js";
 import { modelsFor } from "./models.js";
 import { NativeBlocks, nativeKindsOf } from "./native-blocks.js";
 import { projectSecrets } from "./settings.js";
+/** The model call settings the Runtime limits `limits` set. */
+export function modelCallSettingsOf(limits) {
+    return {
+        attempts: limits.modelAttempts,
+        retryBaseDelayMs: limits.modelRetryDelayMs,
+        idleTimeoutMs: limits.modelIdleMs,
+        requestTimeoutMs: limits.modelRequestMs,
+        providerRetries: limits.modelProviderRetries,
+        maxRetryDelayMs: limits.modelRetryDelayMaxMs,
+    };
+}
 const OPENAI_COMPATIBLE_REASONING = /^reasoning(_content|_text)?$/;
 const emptyUsage = () => ({
     input: 0,
@@ -31,12 +43,7 @@ const noAmbientAuth = {
  * A provider failure is returned as a failure outcome; only an abort is thrown.
  */
 export function piModel(options = {}) {
-    const settings = {
-        attempts: Math.max(1, options.settings?.attempts ?? 3),
-        retryBaseDelayMs: options.settings?.retryBaseDelayMs ?? 2_000,
-        idleTimeoutMs: options.settings?.idleTimeoutMs ?? 300_000,
-        requestTimeoutMs: options.settings?.requestTimeoutMs ?? 600_000,
-    };
+    const settings = { ...modelCallSettingsOf(RUNTIME_LIMIT_DEFAULTS), ...options.settings };
     return async (call, context) => {
         context.signal.throwIfAborted();
         // The first stream event's time, from here (R7.1): the meter keeps it on the usage row.
@@ -54,25 +61,15 @@ export function piModel(options = {}) {
             ...outcome,
             message: String(scrub(outcome.message, secrets)),
         });
-        const requested = call.model?.id;
-        const selection = {
-            provider: stored.provider,
-            model: requested?.startsWith(`${stored.provider}/`)
-                ? requested.slice(stored.provider.length + 1)
-                : (requested ?? stored.model),
-            ...(stored.baseUrl
-                ? { custom: { baseUrl: stored.baseUrl, ...(stored.settings ?? {}) } }
-                : {}),
-        };
+        const selection = selectionOf(stored, call.model?.id);
         const registry = modelsFor(selection, hostCredentialStore(stored, options.writeHostCredential), { environment: false, authContext: noAmbientAuth });
         const found = registry.getModel(selection.provider, selection.model);
         if (!found)
             return failure("invalid_request", "Unknown model. Run nylorun tenant models set.", false);
-        // What the model reads (protocol 12): its catalog's inputs and the operator's additions.
-        // pi-ai drops an image the model's `input` lacks, so the call's model carries an added one.
-        const { inputs } = capabilitiesOf(found, selection.custom
-            ? stored.settings?.inputs
-            : stored.addedInputs?.[`${selection.provider}/${selection.model}`]);
+        // What the model reads (protocol 12), as `turn.start.model` says: its catalog's inputs and
+        // the operator's additions. pi-ai drops an image the model's `input` lacks, so the call's
+        // model carries an added one.
+        const { inputs } = describeModel(found, addedInputsOf(selection, stored, stored.addedInputs ?? {}));
         const selected = {
             ...found,
             input: inputs.includes("image") ? ["text", "image"] : ["text"],
@@ -80,7 +77,10 @@ export function piModel(options = {}) {
         // PDFs, Office documents, audio and video go in the API's own blocks: pi-ai builds the
         // request with a marker in each one's place and `onPayload` swaps it for the bytes.
         const natives = new NativeBlocks();
+        // A part the provider cannot take fails the call before anything is sent: never retried.
         const request = await buildContext(call, selected, inputs, options, natives);
+        if ("failed" in request)
+            return redacted(request.failed);
         // Publish only portable references, never the materialized provider image bytes.
         context.reportPreparedCall?.({
             adapter: "runtime.pi-ai",
@@ -96,8 +96,8 @@ export function piModel(options = {}) {
             sessionId: call.executionId,
             cacheRetention: "short",
             timeoutMs: settings.requestTimeoutMs,
-            maxRetries: 2,
-            maxRetryDelayMs: 60_000,
+            maxRetries: settings.providerRetries,
+            maxRetryDelayMs: settings.maxRetryDelayMs,
             ...(natives.size > 0
                 ? {
                     // A file that cannot be carried stops the request before it is sent.
@@ -211,21 +211,6 @@ export function piModel(options = {}) {
                     ...metadataFor(selected, part.thoughtSignature),
                 });
         }
-        if (call.outputSchema &&
-            !output.some((part) => part.type === "tool-call")) {
-            const text = output
-                .filter((part) => part.type === "text")
-                .map((part) => part.text)
-                .join("");
-            let value;
-            try {
-                value = parseJsonWithRepair(withoutCodeFence(text));
-            }
-            catch (error) {
-                return failure("invalid_output", `The model's final answer is not valid JSON: ${error instanceof Error ? error.message : String(error)}`, false);
-            }
-            output.splice(0, output.length, { type: "json", value });
-        }
         return {
             output,
             finishReason: response.stopReason === "toolUse"
@@ -255,28 +240,56 @@ export function piModel(options = {}) {
         };
     };
 }
+/** A part the call cannot carry: the call fails with it, before anything is sent. */
+class Unsendable extends Error {
+    outcome;
+    constructor(outcome) {
+        super(outcome.message);
+        this.outcome = outcome;
+    }
+}
+/**
+ * The provider context for `call`. The gate decides nothing about files (protocol 15): a media
+ * part names an artifact version the session may read, which it fetches (`options.files`) and
+ * translates, an image to an image block and a PDF, Office document, audio or video to a marker
+ * for its native block (`natives`). A part the model or its API cannot take is refused
+ * (`unsupported_input`): a text file (the harness inlines text), a kind the model does not read.
+ * A file it cannot fetch is `invalid_request`. Bytes go only into the provider request built
+ * here, never into the transcript or the journal.
+ */
 async function buildContext(call, selected, inputs, options, natives) {
+    try {
+        return await translate(call, selected, inputs, options, natives);
+    }
+    catch (error) {
+        if (error instanceof Unsendable)
+            return { failed: error.outcome };
+        throw error;
+    }
+}
+async function translate(call, selected, inputs, options, natives) {
     const messages = [];
     const instructions = [];
-    /**
-     * A file a media part names (protocol 6, 12), as the model gets it: a text file as a `<file>`
-     * block, an image the model reads as an image, a PDF, Office document, audio or video the model
-     * reads as a marker for its native block (`natives`), and anything else, or a file that cannot
-     * be read, as a note. Its bytes go only into the provider request built here, never into the
-     * transcript or the journal, and no file fails the call here.
-     */
-    const materialize = async (part) => {
-        let name = mediaReferenceOf(part.reference)?.name ?? "file";
-        let type = essence(part.mediaType);
-        const note = (why) => ({
-            type: "text",
-            text: `(File ${JSON.stringify(name)}, ${type}, is not shown: ${why}.)`,
-        });
-        const refused = unreadableReason(part.mediaType, inputs);
-        if (refused)
-            return note(refused);
+    const unsupported = (message) => new Unsendable(failure("unsupported_input", message, false));
+    /** Why the model cannot take a file of `type`, or undefined when it can. */
+    const refusal = (name, type) => {
+        const kind = modelInputOf(type);
+        const file = `File ${JSON.stringify(name)} (${essence(type)})`;
+        if (kind === "text")
+            return unsupported(`${file} is text: send its contents as a text part.`);
+        if (kind === undefined ||
+            !inputs.includes(kind) ||
+            (kind === "image" && !isModelImage(type)) ||
+            (kind !== "image" && !(isNativeKind(kind) && nativeKindsOf(selected.api).includes(kind))))
+            return unsupported(`This model (${selected.provider}/${selected.id}) does not read ${kind === "image" && inputs.includes("image") ? "this image format" : inputLabel(kind)}: ${file}.`);
+        return undefined;
+    };
+    const toProvider = async (part) => {
+        const declared = refusal(mediaReferenceOf(part.reference)?.name ?? "file", part.mediaType);
+        if (declared)
+            throw declared;
         if (!options.files)
-            return note("files are unavailable");
+            throw new Unsendable(failure("invalid_request", "This gate cannot fetch files: no artifact store.", false));
         let file;
         try {
             file = await options.files(part.reference);
@@ -284,37 +297,21 @@ async function buildContext(call, selected, inputs, options, natives) {
         catch (error) {
             if (!(error instanceof FileUnavailableError))
                 throw error;
-            return note(error.message.replace(/\.$/u, ""));
+            throw new Unsendable(failure("invalid_request", error.message, false));
         }
-        name = file.name;
-        type = essence(file.mediaType);
-        const stored = unreadableReason(file.mediaType, inputs);
+        const stored = refusal(file.name, file.mediaType);
         if (stored)
-            return note(stored);
+            throw stored;
+        const type = essence(file.mediaType);
+        const data = Buffer.from(file.bytes).toString("base64");
         if (isModelImage(file.mediaType))
-            return { type: "image", data: Buffer.from(file.bytes).toString("base64"), mimeType: type };
-        if (isText(file.mediaType)) {
-            let text;
-            try {
-                text = new TextDecoder("utf-8", { fatal: true }).decode(file.bytes);
-            }
-            catch {
-                return note("it is not UTF-8 text");
-            }
-            return {
-                type: "text",
-                text: `<file name=${JSON.stringify(file.name)} type=${JSON.stringify(type)}>\n${text}\n</file>`,
-            };
-        }
-        const kind = modelInputOf(file.mediaType);
-        if (isNativeKind(kind) && nativeKindsOf(selected.api).includes(kind))
-            return natives.add({
-                kind,
-                mediaType: type,
-                name: file.name,
-                data: Buffer.from(file.bytes).toString("base64"),
-            });
-        return note(`the Runtime does not send ${inputLabel(kind)} to this model's API (${selected.api})`);
+            return { type: "image", data, mimeType: type };
+        return natives.add({
+            kind: modelInputOf(file.mediaType),
+            mediaType: type,
+            name: file.name,
+            data,
+        });
     };
     const content = async (parts) => {
         const result = [];
@@ -322,7 +319,7 @@ async function buildContext(call, selected, inputs, options, natives) {
             if (part.type === "text")
                 result.push({ type: "text", text: part.text });
             else if (part.type === "media")
-                result.push(await materialize(part));
+                result.push(await toProvider(part));
         }
         return result;
     };
@@ -355,18 +352,7 @@ async function buildContext(call, selected, inputs, options, natives) {
         description: tool.description ?? "",
         parameters: { ...tool.inputSchema },
     }));
-    return {
-        systemPrompt: [
-            ...instructions,
-            ...(call.outputSchema
-                ? [
-                    `Return the final answer as JSON matching this schema: ${JSON.stringify(call.outputSchema)}. Use tools when needed before returning the final JSON.`,
-                ]
-                : []),
-        ].join("\n"),
-        messages,
-        tools,
-    };
+    return { systemPrompt: instructions.join("\n"), messages, tools };
 }
 const isNativeKind = (input) => input === "pdf" || input === "office" || input === "audio" || input === "video";
 /**
@@ -456,11 +442,6 @@ function metadataFor(selected, signature, redacted) {
         },
     };
 }
-/** Open-weight models often wrap a JSON answer in a Markdown code fence. */
-function withoutCodeFence(text) {
-    const fenced = /^\s*```[a-zA-Z]*\s*\n([\s\S]*?)\n?```\s*$/.exec(text);
-    return fenced ? fenced[1] : text;
-}
 function usageOf(usage) {
     return {
         inputTokens: usage.input,