@nylorun/runtime 0.4.0-beta → 0.6.0-beta

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,12 +11,19 @@ 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 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)
@@ -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/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,174 @@
+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 delete(agentId, sessionId) {
+            const operation = operations.then(async () => {
+                await check();
+                const target = pathFor(agentId, sessionId);
+                try {
+                    await rm(target);
+                    return true;
+                }
+                catch (error) {
+                    if (isMissing(error))
+                        return false;
+                    throw error;
+                }
+            });
+            operations = operation.then(() => { }, () => { });
+            return operation;
+        },
+        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,27 +1,70 @@
 import { Hono, type Context } from "hono";
 import type { JsonValue, RuntimeAgent } from "../contracts.js";
+import type { BuiltAgent, ModelAdapter } from "@nylorun/core/define";
+import { SessionHost } from "../sessions/host.js";
 import type { RuntimeConfig } from "../config.js";
+import type { ModelEnvironment } from "../model/http-model.js";
+import { type OpenSessionOptions, type SessionHandle } from "../session/handle.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 & {
+/** 1.0 compatibility: requires an explicit Runtime and returns a Hono app. */
+export type ServeAgentsCompatOptions = AgentRouterOptions & {
     readonly agents: readonly RuntimeAgent[];
     readonly runtime: Runtime;
 };
+/** DX v5.6 local: optional Runtime; returns `{ fetch }`. */
+export type ServeAgentsFetchOptions = AgentRouterOptions & {
+    readonly agents?: readonly RuntimeAgent[];
+    readonly runtime?: Runtime;
+    /** Alias for `getInfo` — keep the name `info` (never `user`). */
+    readonly info?: AgentRouterOptions["getInfo"];
+    readonly on?: {
+        readonly session?: {
+            readonly created?: (session: {
+                readonly id: string;
+                readonly agentId: string;
+            }) => void;
+            readonly idle?: (session: {
+                readonly id: string;
+                readonly agentId: string;
+            }) => void;
+            readonly failed?: (session: {
+                readonly id: string;
+                readonly agentId: string;
+            }) => void;
+        };
+    };
+};
+export type ServeAgentsOptions = ServeAgentsCompatOptions;
+export type ServeAgentsFetch = {
+    readonly fetch: (request: Request) => Response | Promise<Response>;
+};
 declare const kServe: unique symbol;
 export declare class Runtime {
-    #private;
-    constructor(options?: RuntimeConfig);
+    readonly config: RuntimeConfig;
+    readonly host: SessionHost;
+    private served;
+    private closing?;
+    constructor(config?: RuntimeConfig);
     close: () => Promise<void>;
-    [kServe](options: Omit<ServeAgentsOptions, "runtime">): Hono;
+    resolveModel(onPreview?: (preview: import("../model/defaults.js").ModelPreview) => void): ModelAdapter;
+    openSession(agent: BuiltAgent<any, any>, options?: OpenSessionOptions): SessionHandle;
+    listSessions(agentId: string): Promise<readonly import("../sessions/store.js").SessionSummary[]>;
+    getSession(agentId: string, sessionId: string): Promise<import("../sessions/store.js").StoredSession | undefined>;
+    deleteSession(agentId: string, sessionId: string): Promise<boolean>;
+    [kServe](options: Omit<ServeAgentsCompatOptions, "runtime"> & {
+        readonly agents: readonly RuntimeAgent[];
+    }): 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: ServeAgentsCompatOptions): Hono<any>;
+export declare function serveAgents(options: ServeAgentsFetchOptions): ServeAgentsFetch;
 export {};