@nylorun/runtime 0.4.0-beta → 0.5.0-beta

package/dist/model/http-model.js

@@ -0,0 +1,299 @@
+/** Fetch-only adapter for OpenAI-compatible and Anthropic HTTP endpoints. */
+export function httpModel(options = {}) {
+    return async (call, context) => {
+        const env = options.environment ??
+            (typeof process === "undefined" ? {} : process.env);
+        const provider = options.provider ?? env.MODEL_PROVIDER;
+        const model = call.model?.id ?? options.model ?? env.MODEL;
+        const baseUrl = options.baseUrl ?? env.MODEL_PROVIDER_BASE_URL;
+        if (!provider || !model)
+            throw new Error("Set both MODEL_PROVIDER and MODEL, or supply a model adapter.");
+        if (!["openai", "custom", "anthropic"].includes(provider))
+            throw new Error(`The portable HTTP adapter does not support '${provider}'. Supply onModelCall or use the Node piModel adapter.`);
+        if (provider === "custom" && !baseUrl)
+            throw new Error("MODEL_PROVIDER=custom requires MODEL_PROVIDER_BASE_URL.");
+        const apiKey = options.apiKey ??
+            env.MODEL_PROVIDER_API_KEY ??
+            (provider === "anthropic" ? env.ANTHROPIC_API_KEY : env.OPENAI_API_KEY);
+        if (!apiKey)
+            throw new Error("Set MODEL_PROVIDER_API_KEY or the provider-native API key variable.");
+        const text = (parts) => parts
+            .flatMap((part) => (part.type === "text" ? [part.text] : []))
+            .join("\n");
+        if (call.prompt.some((item) => item.content.some((part) => part.type === "media")))
+            throw new Error("Supply a media-aware model adapter for media inputs.");
+        context.signal.throwIfAborted();
+        let body;
+        let url;
+        let headers;
+        const streaming = provider !== "anthropic" && options.onPreview !== undefined;
+        if (provider === "anthropic") {
+            const messages = call.prompt
+                .filter((item) => item.kind !== "instructions")
+                .map((item) => {
+                if (item.kind === "tool-result")
+                    return {
+                        role: "user",
+                        content: [
+                            {
+                                type: "tool_result",
+                                tool_use_id: item.toolCallId,
+                                content: text(item.content),
+                                is_error: item.status !== "completed",
+                            },
+                        ],
+                    };
+                return {
+                    role: item.role === "assistant" ? "assistant" : "user",
+                    content: item.content.flatMap((part) => part.type === "tool-call"
+                        ? [
+                            {
+                                type: "tool_use",
+                                id: part.id,
+                                name: part.name,
+                                input: part.args,
+                            },
+                        ]
+                        : part.type === "text"
+                            ? [{ type: "text", text: part.text }]
+                            : []),
+                };
+            });
+            body = {
+                model,
+                messages,
+                max_tokens: call.model?.controls?.maxOutputTokens ?? 4096,
+                system: call.prompt
+                    .filter((item) => item.kind === "instructions")
+                    .map((item) => text(item.content))
+                    .join("\n"),
+                ...(call.tools.length
+                    ? {
+                        tools: call.tools.map((tool) => ({
+                            name: tool.name,
+                            description: tool.description ?? "",
+                            input_schema: tool.inputSchema,
+                        })),
+                    }
+                    : {}),
+                ...(call.outputSchema
+                    ? {
+                        output_config: {
+                            format: { type: "json_schema", schema: call.outputSchema },
+                        },
+                    }
+                    : {}),
+                ...(call.model?.controls?.temperature === undefined
+                    ? {}
+                    : { temperature: call.model.controls.temperature }),
+            };
+            url = `${(baseUrl ?? "https://api.anthropic.com").replace(/\/$/, "")}/v1/messages`;
+            headers = {
+                "content-type": "application/json",
+                "x-api-key": apiKey,
+                "anthropic-version": "2023-06-01",
+            };
+        }
+        else {
+            const messages = call.prompt.map((item) => {
+                if (item.kind === "tool-result")
+                    return {
+                        role: "tool",
+                        tool_call_id: item.toolCallId,
+                        content: text(item.content),
+                    };
+                const calls = item.content
+                    .filter((part) => part.type === "tool-call")
+                    .map((part) => ({
+                    id: part.id,
+                    type: "function",
+                    function: { name: part.name, arguments: JSON.stringify(part.args) },
+                }));
+                return {
+                    role: item.kind === "instructions" ? "system" : item.role,
+                    content: text(item.content),
+                    ...(calls.length ? { tool_calls: calls } : {}),
+                };
+            });
+            body = {
+                model,
+                messages,
+                stream: streaming,
+                ...(call.tools.length
+                    ? {
+                        tools: call.tools.map((tool) => ({
+                            type: "function",
+                            function: {
+                                name: tool.name,
+                                description: tool.description,
+                                parameters: tool.inputSchema,
+                            },
+                        })),
+                    }
+                    : {}),
+                ...(call.outputSchema
+                    ? {
+                        response_format: {
+                            type: "json_schema",
+                            json_schema: {
+                                name: "agent_output",
+                                strict: true,
+                                schema: call.outputSchema,
+                            },
+                        },
+                    }
+                    : {}),
+                ...(call.model?.controls?.temperature === undefined
+                    ? {}
+                    : { temperature: call.model.controls.temperature }),
+                ...(call.model?.controls?.maxOutputTokens === undefined
+                    ? {}
+                    : { max_completion_tokens: call.model.controls.maxOutputTokens }),
+            };
+            url = `${(baseUrl ?? "https://api.openai.com/v1").replace(/\/$/, "")}/chat/completions`;
+            headers = {
+                "content-type": "application/json",
+                authorization: `Bearer ${apiKey}`,
+            };
+        }
+        if (!["https:", "http:"].includes(new URL(url).protocol))
+            throw new Error("Model endpoint must use HTTP(S).");
+        context.reportPreparedCall?.({
+            adapter: "runtime.http",
+            call: JSON.parse(JSON.stringify(body)),
+        });
+        const response = await (options.fetch ?? fetch)(url, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body),
+            signal: context.signal,
+        });
+        if (!response.ok)
+            throw new Error(`Model provider returned HTTP ${response.status}. Check the selected model, credentials, and endpoint.`);
+        let result;
+        if (streaming)
+            result = await readOpenAIStream(response, (value) => {
+                try {
+                    void Promise.resolve(options.onPreview?.({
+                        invocationId: context.invocationId,
+                        text: value,
+                    })).catch(() => { });
+                }
+                catch {
+                    /* Preview delivery cannot affect generation. */
+                }
+            });
+        else
+            result = await response.json();
+        context.signal.throwIfAborted();
+        const output = [];
+        if (provider === "anthropic") {
+            for (const part of result.content ?? []) {
+                if (part.type === "text")
+                    output.push(call.outputSchema &&
+                        !(result.content ?? []).some((item) => item.type === "tool_use")
+                        ? { type: "json", value: JSON.parse(part.text) }
+                        : { type: "text", text: part.text });
+                if (part.type === "tool_use")
+                    output.push({
+                        type: "tool-call",
+                        id: part.id,
+                        name: part.name,
+                        args: part.input,
+                    });
+            }
+        }
+        else {
+            const message = result.choices?.[0]?.message;
+            if (!message)
+                throw new Error("Model provider returned no message.");
+            if (message.content)
+                output.push(call.outputSchema && !message.tool_calls?.length
+                    ? { type: "json", value: JSON.parse(message.content) }
+                    : { type: "text", text: message.content });
+            for (const tool of message.tool_calls ?? [])
+                output.push({
+                    type: "tool-call",
+                    id: tool.id,
+                    name: tool.function.name,
+                    args: JSON.parse(tool.function.arguments),
+                });
+        }
+        return { output, evidence: { resolvedModel: result.model ?? model } };
+    };
+}
+async function readOpenAIStream(response, preview) {
+    if (!response.body)
+        throw new Error("Model provider returned no stream.");
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "", content = "", complete = false;
+    const calls = new Map();
+    const line = (value) => {
+        if (!value.startsWith("data:"))
+            return;
+        const data = value.slice(5).trim();
+        if (data === "[DONE]") {
+            complete = true;
+            return;
+        }
+        if (!data)
+            return;
+        const chunk = JSON.parse(data);
+        if (chunk.error)
+            throw new Error("Model provider reported a streaming error.");
+        const delta = chunk.choices?.[0]?.delta;
+        if (typeof delta?.content === "string") {
+            content += delta.content;
+            preview(delta.content);
+        }
+        for (const tool of delta?.tool_calls ?? []) {
+            const target = calls.get(tool.index) ?? {
+                id: "",
+                type: "function",
+                function: { name: "", arguments: "" },
+            };
+            if (tool.id)
+                target.id = tool.id;
+            if (tool.function?.name)
+                target.function.name += tool.function.name;
+            if (tool.function?.arguments)
+                target.function.arguments += tool.function.arguments;
+            calls.set(tool.index, target);
+        }
+    };
+    try {
+        while (!complete) {
+            const next = await reader.read();
+            buffer += decoder.decode(next.value, { stream: !next.done });
+            let end;
+            while ((end = buffer.indexOf("\n")) >= 0) {
+                line(buffer.slice(0, end).replace(/\r$/, ""));
+                buffer = buffer.slice(end + 1);
+            }
+            if (next.done) {
+                if (buffer)
+                    line(buffer);
+                break;
+            }
+        }
+        if (!complete)
+            throw new Error("Model stream ended before completion.");
+        return {
+            choices: [
+                {
+                    message: {
+                        content,
+                        tool_calls: [...calls]
+                            .sort(([a], [b]) => a - b)
+                            .map(([, value]) => value),
+                    },
+                },
+            ],
+        };
+    }
+    finally {
+        await reader.cancel().catch(() => { });
+        reader.releaseLock();
+    }
+}

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