@nylorun/runtime 0.3.0-beta → 0.5.0-beta

package/dist/model/models.js

@@ -1,8 +1,29 @@
-import { createProvider, envApiKeyAuth, } from "@earendil-works/pi-ai";
+import { createProvider, defaultProviderAuthContext, envApiKeyAuth, } 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";
 export function modelsFor(selection, credentials) {
-    const models = builtinModels({ credentials });
+    const environmentFirst = {
+        async read(providerId, options) {
+            const explicit = process.env.MODEL_PROVIDER_API_KEY;
+            if (explicit &&
+                (!selection.provider || selection.provider === providerId))
+                return { type: "api_key", key: explicit };
+            const provider = models
+                .getProviders()
+                .find((item) => item.id === providerId);
+            const ambient = await provider?.auth.apiKey?.resolve({
+                ctx: defaultProviderAuthContext(),
+                signal: options?.signal ?? new AbortController().signal,
+            });
+            if (ambient)
+                return undefined;
+            return credentials.read(providerId, options);
+        },
+        list: (options) => credentials.list(options),
+        modify: (id, fn, options) => credentials.modify(id, fn, options),
+        delete: (id, options) => credentials.delete(id, options),
+    };
+    const models = builtinModels({ credentials: environmentFirst });
     if (!selection.custom)
         return models;
     const model = {
@@ -22,7 +43,7 @@ export function modelsFor(selection, credentials) {
         name: "Custom OpenAI-compatible",
         baseUrl: selection.custom.baseUrl,
         auth: {
-            apiKey: envApiKeyAuth("Custom API key", ["NYLO_CUSTOM_API_KEY"]),
+            apiKey: envApiKeyAuth("Custom API key", ["MODEL_PROVIDER_API_KEY"]),
         },
         models: [model],
         api: { stream, streamSimple },

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

@@ -3,8 +3,9 @@ import type { RuntimeMedia } from "../adapters/media.js";
 import { type Selection } from "./models.js";
 export interface PiModelOptions {
     readonly root?: string;
+    readonly onPreview?: (preview: import("./defaults.js").ModelPreview) => void;
     readonly selection?: Selection;
     readonly media?: Pick<RuntimeMedia, "dataUrl">;
 }
-/** A plain portable callable. Provider credentials are read only when it is invoked. */
+/** Node model adapter. Local provider configuration is read only when invoked. */
 export declare function piModel(options?: PiModelOptions): RuntimeModelAdapter;

package/dist/model/pi-model.js

@@ -1,5 +1,5 @@
 import { join } from "node:path";
-import { scrub } from "../adapters/journal.js";
+import { scrub } from "../redact.js";
 import { ProjectCredentialStore } from "./auth-store.js";
 import { modelsFor } from "./models.js";
 import { modelSelection, projectSecrets } from "./settings.js";
@@ -11,13 +11,20 @@ const emptyUsage = () => ({
     cacheWrite: 0,
     cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
 });
-/** A plain portable callable. Provider credentials are read only when it is invoked. */
+/** Node model adapter. Local provider configuration is read only when invoked. */
 export function piModel(options = {}) {
     return async (call, context) => {
         context.signal.throwIfAborted();
         const root = options.root ?? process.cwd();
-        const selection = options.selection ?? modelSelection(root);
-        const registry = modelsFor(selection, new ProjectCredentialStore(join(root, ".env", "auth.json")));
+        const configured = options.selection ?? modelSelection(root);
+        const requested = call.model?.id;
+        const selection = {
+            ...configured,
+            model: requested?.startsWith(`${configured.provider}/`)
+                ? requested.slice(configured.provider.length + 1)
+                : (requested ?? configured.model),
+        };
+        const registry = modelsFor(selection, new ProjectCredentialStore(join(root, ".nylorun", "auth.json"), join(root, ".env", "auth.json")));
         const selected = registry.getModel(selection.provider, selection.model);
         if (!selected)
             throw new Error("Unknown model. Run nylorun configure.");
@@ -65,7 +72,9 @@ export function piModel(options = {}) {
                         typeof ref.agentId !== "string" ||
                         typeof ref.assetId !== "string")
                         throw new Error("Expected a local media reference.");
-                    const asset = await options.media?.dataUrl({ agentId: ref.agentId, assetId: ref.assetId }, call.sessionId);
+                    const asset = await options.media?.dataUrl({ agentId: ref.agentId, assetId: ref.assetId }, "sessionId" in ref && typeof ref.sessionId === "string"
+                        ? ref.sessionId
+                        : call.executionId);
                     if (!asset)
                         throw new Error("Media is unavailable; pass the shared media adapter to piModel({ media }).");
                     const comma = asset.url.indexOf(",");
@@ -156,7 +165,14 @@ export function piModel(options = {}) {
             parameters: { ...tool.inputSchema },
         }));
         const request = {
-            systemPrompt: instructions.join("\n"),
+            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,
         };
@@ -167,14 +183,34 @@ export function piModel(options = {}) {
             call: scrub(call, secrets),
         });
         try {
-            const response = await registry.complete(selected, request, {
+            const invocationOptions = {
                 signal: context.signal,
                 temperature: call.model?.controls?.temperature,
                 maxTokens: call.model?.controls?.maxOutputTokens,
                 ...(call.model?.config
                     ? { samplingParams: { ...call.model.config } }
                     : {}),
-            });
+            };
+            let response;
+            if (options.onPreview) {
+                const stream = registry.streamSimple(selected, request, invocationOptions);
+                for await (const event of stream) {
+                    if (event.type === "text_delta") {
+                        try {
+                            void Promise.resolve(options.onPreview({
+                                invocationId: context.invocationId,
+                                text: event.delta,
+                            })).catch(() => { });
+                        }
+                        catch {
+                            /* Preview delivery is independent. */
+                        }
+                    }
+                }
+                response = await stream.result();
+            }
+            else
+                response = await registry.complete(selected, request, invocationOptions);
             context.signal.throwIfAborted();
             if (response.stopReason === "error" ||
                 response.stopReason === "aborted" ||
@@ -203,6 +239,15 @@ export function piModel(options = {}) {
                         ...metadataFor(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("");
+                const value = JSON.parse(text);
+                output.splice(0, output.length, { type: "json", value });
+            }
             return {
                 output,
                 finishReason: response.stopReason === "toolUse"

package/dist/model/settings.js

@@ -1,6 +1,27 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 export function modelSelection(root = process.cwd()) {
+    const { MODEL_PROVIDER: provider, MODEL: model, MODEL_PROVIDER_BASE_URL: baseUrl, } = process.env;
+    if (provider !== undefined || model !== undefined || baseUrl !== undefined) {
+        if (!provider?.trim() || !model?.trim())
+            throw new Error("Set both MODEL_PROVIDER and MODEL, or run nylorun configure.");
+        if (provider === "custom" && !baseUrl?.trim())
+            throw new Error("Set MODEL_PROVIDER_BASE_URL for MODEL_PROVIDER=custom.");
+        if (baseUrl && provider !== "custom")
+            throw new Error("MODEL_PROVIDER_BASE_URL requires MODEL_PROVIDER=custom.");
+        if (baseUrl) {
+            let url;
+            try {
+                url = new URL(baseUrl);
+            }
+            catch {
+                throw new Error("MODEL_PROVIDER_BASE_URL must be an HTTP(S) URL.");
+            }
+            if (!["http:", "https:"].includes(url.protocol))
+                throw new Error("MODEL_PROVIDER_BASE_URL must be an HTTP(S) URL.");
+        }
+        return { provider, model, ...(baseUrl ? { custom: { baseUrl } } : {}) };
+    }
     try {
         let contents;
         try {
@@ -9,7 +30,7 @@ export function modelSelection(root = process.cwd()) {
         catch (error) {
             if (!(error instanceof Error) ||
                 !("code" in error) ||
-                error.code !== "ENOENT")
+                !["ENOENT", "ENOTDIR"].includes(String(error.code)))
                 throw error;
             contents = readFileSync(join(root, "config", "model.json"), "utf8");
         }
@@ -30,17 +51,18 @@ export function projectSecrets(root = process.cwd()) {
     const values = Object.entries(process.env)
         .filter(([key]) => /key|token|secret|password|credential/i.test(key))
         .flatMap(([, value]) => (value ? [value] : []));
-    try {
-        const collect = (value) => {
-            if (typeof value === "string")
-                values.push(value);
-            else if (value && typeof value === "object")
-                Object.values(value).forEach(collect);
-        };
-        collect(JSON.parse(readFileSync(join(root, ".env", "auth.json"), "utf8")));
-    }
-    catch {
-        /* The vault may not exist before setup. */
-    }
+    for (const directory of [".nylorun", ".env"])
+        try {
+            const collect = (value) => {
+                if (typeof value === "string")
+                    values.push(value);
+                else if (value && typeof value === "object")
+                    Object.values(value).forEach(collect);
+            };
+            collect(JSON.parse(readFileSync(join(root, directory, "auth.json"), "utf8")));
+        }
+        catch {
+            /* The vault may not exist before setup. */
+        }
     return values;
 }

package/dist/node/index.d.ts

@@ -0,0 +1,5 @@
+export { localSessions } from "./local-sessions.js";
+export { localMedia, MediaStore } from "../adapters/media.js";
+export { jsonlObserver } from "../adapters/observe.js";
+export { piModel, type PiModelOptions } from "../model/pi-model.js";
+export { projectAsset } from "../assets.js";

package/dist/node/index.js

@@ -0,0 +1,5 @@
+export { localSessions } from "./local-sessions.js";
+export { localMedia, MediaStore } from "../adapters/media.js";
+export { jsonlObserver } from "../adapters/observe.js";
+export { piModel } from "../model/pi-model.js";
+export { projectAsset } from "../assets.js";

package/dist/node/local-sessions.d.ts

@@ -0,0 +1,5 @@
+import { type ManagedSessionStore } from "../sessions/store.js";
+/** Single-owner local disk store. No lease stealing, replay, or shared-filesystem guarantee. */
+export declare function localSessions(options: {
+    root: string;
+}): ManagedSessionStore;

package/dist/node/local-sessions.js

@@ -0,0 +1,157 @@
+import { mkdir, open, readFile, readdir, rename, rm, realpath, } from "node:fs/promises";
+import { resolve, join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { sessionSummary, } from "../sessions/store.js";
+/** Single-owner local disk store. No lease stealing, replay, or shared-filesystem guarantee. */
+export function localSessions(options) {
+    let closed = false;
+    let directory;
+    const token = randomUUID();
+    const acquired = (async () => {
+        await mkdir(resolve(options.root), { recursive: true, mode: 0o700 });
+        directory = await realpath(resolve(options.root));
+        const path = join(directory, ".owner.lock");
+        let handle;
+        try {
+            handle = await open(path, "wx", 0o600);
+        }
+        catch (cause) {
+            throw new Error(`Session store ${directory} already has an owner. Stop the owner before opening it again. After a crash, confirm it has stopped and manually remove .owner.lock.`, { cause });
+        }
+        try {
+            await handle.writeFile(JSON.stringify({ token, pid: process.pid }));
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+    })();
+    void acquired.catch(() => { });
+    let operations = Promise.resolve();
+    const check = async () => {
+        await acquired;
+        if (closed)
+            throw new Error("Session store is closed");
+        const owner = JSON.parse(await readFile(join(directory, ".owner.lock"), "utf8"));
+        if (owner.token !== token)
+            throw new Error("Session store ownership was lost; refusing further writes");
+    };
+    const pathFor = (agentId, sessionId) => join(directory, safe(agentId), `${safe(sessionId)}.json`);
+    const get = async (agentId, sessionId) => {
+        await check();
+        try {
+            const value = JSON.parse(await readFile(pathFor(agentId, sessionId), "utf8"));
+            if (value.version !== 1 ||
+                value.id !== sessionId ||
+                value.agentId !== agentId ||
+                !Array.isArray(value.events))
+                throw new Error("Invalid stored session document");
+            return value;
+        }
+        catch (error) {
+            if (!isMissing(error))
+                throw error;
+            try {
+                const contents = await readFile(join(directory, safe(agentId), safe(sessionId), "events.jsonl"), "utf8");
+                const events = contents
+                    .split("\n")
+                    .filter(Boolean)
+                    .map((line) => JSON.parse(line));
+                return {
+                    version: 1,
+                    id: sessionId,
+                    agentId,
+                    status: "archived",
+                    startedAt: events[0] ? Date.parse(events[0].ts) : 0,
+                    updatedAt: 0,
+                    events,
+                };
+            }
+            catch (legacyError) {
+                if (isMissing(legacyError))
+                    return undefined;
+                throw legacyError;
+            }
+        }
+    };
+    return {
+        get,
+        put(agentId, sessionId, session) {
+            const contents = JSON.stringify(session);
+            const operation = operations.then(async () => {
+                await check();
+                if (session.id !== sessionId || session.agentId !== agentId)
+                    throw new Error("Session identity mismatch");
+                const target = pathFor(agentId, sessionId);
+                await mkdir(join(directory, safe(agentId)), {
+                    recursive: true,
+                    mode: 0o700,
+                });
+                const temporary = `${target}.${randomUUID()}.tmp`;
+                try {
+                    const file = await open(temporary, "wx", 0o600);
+                    try {
+                        await file.writeFile(contents);
+                        await file.sync();
+                    }
+                    finally {
+                        await file.close();
+                    }
+                    await check();
+                    await rename(temporary, target);
+                    const parent = await open(join(directory, safe(agentId)), "r");
+                    try {
+                        await parent.sync();
+                    }
+                    finally {
+                        await parent.close();
+                    }
+                }
+                finally {
+                    await rm(temporary, { force: true });
+                }
+            });
+            operations = operation.catch(() => { });
+            return operation;
+        },
+        async list(agentId) {
+            await check();
+            let names;
+            try {
+                names = await readdir(join(directory, safe(agentId)), {
+                    withFileTypes: true,
+                });
+            }
+            catch (error) {
+                if (isMissing(error))
+                    return [];
+                throw error;
+            }
+            const sessions = await Promise.all(names
+                .filter((item) => item.isDirectory() || item.name.endsWith(".json"))
+                .map((item) => get(agentId, item.isDirectory() ? item.name : item.name.slice(0, -5))));
+            return sessions
+                .flatMap((session) => (session ? [sessionSummary(session)] : []))
+                .sort((a, b) => b.startedAt - a.startedAt);
+        },
+        async close() {
+            await operations;
+            if (closed)
+                return;
+            await check();
+            closed = true;
+            await rm(join(directory, ".owner.lock"));
+        },
+    };
+}
+function safe(value) {
+    if (value === "." || value === ".." || !/^[a-zA-Z0-9._-]+$/.test(value))
+        throw new Error("Invalid session path identifier");
+    return value;
+}
+function isMissing(error) {
+    return (!!error &&
+        typeof error === "object" &&
+        "code" in error &&
+        error.code === "ENOENT");
+}

package/dist/redact.d.ts

@@ -0,0 +1 @@
+export declare function scrub(value: unknown, secrets: readonly string[]): unknown;

package/dist/redact.js

@@ -0,0 +1,14 @@
+export function scrub(value, secrets) {
+    if (typeof value === "string")
+        return secrets.reduce((text, secret) => secret.length >= 8 ? text.split(secret).join("[redacted]") : text, value.replace(/data:image\/[a-z0-9.+-]+;base64,[A-Za-z0-9+/=]+/giu, "[inline image data redacted]"));
+    if (Array.isArray(value))
+        return value.map((item) => scrub(item, secrets));
+    if (value && typeof value === "object")
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+            key,
+            /^(authorization|api[_-]?key|(?:access|refresh|id|auth)[_-]?token|token|secret|password|cookie|credentials?)$/iu.test(key)
+                ? "[redacted]"
+                : scrub(item, secrets),
+        ]));
+    return value;
+}

package/dist/server/ag-ui.d.ts

@@ -1,4 +1,4 @@
-import type { CanonicalEvent } from "../adapters/journal.js";
+import type { CanonicalEvent } from "../sessions/store.js";
 /** Minimal truthful AG-UI projection from the same canonical events Studio displays. */
 export declare function agUiEvents(events: readonly CanonicalEvent[], threadId: string, runId: string): readonly Record<string, unknown>[];
 /**

package/dist/server/delivery.d.ts

@@ -0,0 +1,24 @@
+/** Bounded per-request delivery. Generation never waits for a subscriber. */
+export declare class EventDelivery {
+    private readonly abort;
+    private readonly limits;
+    readonly response: Response;
+    private controller;
+    private readonly queue;
+    private readonly suppressed;
+    private previewBytes;
+    private readonly previewTotals;
+    private eventBytes;
+    private eventCount;
+    private ended;
+    private closed;
+    constructor(abort: () => void, limits?: {
+        previewBytes?: number;
+        eventBytes?: number;
+        eventCount?: number;
+    }, inherited?: HeadersInit);
+    private waiting;
+    private flush;
+    push(event: Record<string, unknown>, preview?: string): void;
+    end(): void;
+}

package/dist/server/delivery.js

@@ -0,0 +1,107 @@
+/** Bounded per-request delivery. Generation never waits for a subscriber. */
+export class EventDelivery {
+    abort;
+    limits;
+    response;
+    controller;
+    queue = [];
+    suppressed = new Set();
+    previewBytes = 0;
+    previewTotals = new Map();
+    eventBytes = 0;
+    eventCount = 0;
+    ended = false;
+    closed = false;
+    constructor(abort, limits = {}, inherited) {
+        this.abort = abort;
+        this.limits = limits;
+        for (const value of Object.values(limits))
+            if (!Number.isSafeInteger(value) || value <= 0)
+                throw new Error("Delivery limits must be positive integers");
+        const stream = new ReadableStream({
+            start: (controller) => {
+                this.controller = controller;
+            },
+            pull: () => this.flush(),
+            cancel: () => {
+                this.closed = true;
+                this.queue.length = 0;
+                abort();
+            },
+        }, { highWaterMark: 0 });
+        const headers = new Headers(inherited);
+        headers.set("content-type", "text/event-stream; charset=utf-8");
+        headers.set("cache-control", "no-cache");
+        this.response = new Response(stream, { headers });
+    }
+    waiting = false;
+    flush() {
+        if (this.closed)
+            return;
+        const item = this.queue.shift();
+        if (item) {
+            this.waiting = false;
+            if (item.preview)
+                this.previewBytes -= item.bytes.byteLength;
+            else {
+                this.eventBytes -= item.bytes.byteLength;
+                this.eventCount--;
+            }
+            this.controller.enqueue(item.bytes);
+        }
+        else if (this.ended) {
+            this.closed = true;
+            this.controller.close();
+        }
+        else
+            this.waiting = true;
+    }
+    push(event, preview) {
+        if (this.closed || this.ended || (preview && this.suppressed.has(preview)))
+            return;
+        const bytes = new TextEncoder().encode(`data: ${JSON.stringify(event)}\n\n`);
+        if (preview &&
+            Math.max(this.previewBytes, this.previewTotals.get(preview) ?? 0) +
+                bytes.byteLength >
+                (this.limits.previewBytes ?? 64 * 1024)) {
+            this.suppressed.add(preview);
+            for (let i = this.queue.length - 1; i >= 0; i--)
+                if (this.queue[i].preview === preview) {
+                    this.previewBytes -= this.queue[i].bytes.byteLength;
+                    this.queue.splice(i, 1);
+                }
+            this.push({
+                type: "CUSTOM",
+                name: "nylorun.preview.incomplete",
+                value: { invocationId: preview },
+            });
+            return;
+        }
+        if (!preview &&
+            (this.eventCount + 1 > (this.limits.eventCount ?? 256) ||
+                this.eventBytes + bytes.byteLength >
+                    (this.limits.eventBytes ?? 1024 * 1024))) {
+            this.closed = true;
+            this.queue.length = 0;
+            this.controller.error(new Error("Subscriber exceeded execution-event delivery limits"));
+            this.abort();
+            return;
+        }
+        this.queue.push({ bytes, ...(preview ? { preview } : {}) });
+        if (preview) {
+            this.previewBytes += bytes.byteLength;
+            this.previewTotals.set(preview, (this.previewTotals.get(preview) ?? 0) + bytes.byteLength);
+        }
+        else {
+            this.eventBytes += bytes.byteLength;
+            this.eventCount++;
+        }
+        if (this.waiting)
+            this.flush();
+    }
+    end() {
+        this.ended = true;
+        if (this.waiting)
+            this.flush();
+    }
+}

package/dist/server/host.d.ts

@@ -1,14 +1,17 @@
 import { Hono, type Context } from "hono";
 import type { JsonValue, RuntimeAgent } from "../contracts.js";
+import { SessionHost } from "../sessions/host.js";
 import type { RuntimeConfig } from "../config.js";
+import type { ModelEnvironment } from "../model/http-model.js";
 export type RuntimeActor = Readonly<{
     id: string;
     context?: Record<string, JsonValue>;
 }>;
 export type AgentRouterOptions = Readonly<{
-    /** Override the public URL prefix; defaults to the current Hono mount path. */
     basePath?: string;
     getActor?: (context: Context) => RuntimeActor | undefined | Promise<RuntimeActor | undefined>;
+    getInfo?: (context: Context) => unknown | Promise<unknown>;
+    getEnvironment?: (context: Context) => ModelEnvironment | Promise<ModelEnvironment>;
     getRequestMetadata?: (context: Context) => Record<string, JsonValue> | undefined | Promise<Record<string, JsonValue> | undefined>;
 }>;
 export type ServeAgentsOptions = AgentRouterOptions & {
@@ -17,11 +20,13 @@ export type ServeAgentsOptions = AgentRouterOptions & {
 };
 declare const kServe: unique symbol;
 export declare class Runtime {
-    #private;
-    constructor(options?: RuntimeConfig);
+    private readonly config;
+    readonly host: SessionHost;
+    private served;
+    private closing?;
+    constructor(config?: RuntimeConfig);
     close: () => Promise<void>;
-    [kServe](options: Omit<ServeAgentsOptions, "runtime">): Hono;
+    [kServe](options: Omit<ServeAgentsOptions, "runtime">): Hono<any>;
 }
-/** Create the Hono protocol mount for a runtime. Applications may close it during graceful shutdown. */
-export declare function serveAgents(options: ServeAgentsOptions): any;
+export declare function serveAgents(options: ServeAgentsOptions): Hono<any>;
 export {};