@nylorun/runtime 0.4.0-beta → 0.6.0-beta

package/dist/core/store.d.ts

@@ -0,0 +1,16 @@
+import { DatabaseSync } from "node:sqlite";
+import type { LiveEvent } from "@nylorun/core/contracts";
+export declare function canonical(value: unknown): string;
+export declare class Store {
+    readonly db: DatabaseSync;
+    constructor(path: string);
+    tx<T>(fn: () => T): T;
+    get<T = any>(table: string, id: string): T | undefined;
+    all<T = any>(table: string): T[];
+    put(table: string, id: string, body: unknown): void;
+    event(sessionId: string, turnId: string | null, type: string, payload: unknown): LiveEvent;
+    history(sessionId: string, cursor?: string): {
+        items: LiveEvent[];
+        cursor: string | null;
+    };
+}

package/dist/core/store.js

@@ -0,0 +1,101 @@
+import { DatabaseSync } from "node:sqlite";
+import { randomUUID } from "node:crypto";
+export function canonical(value) {
+    if (Array.isArray(value))
+        return "[" + value.map(canonical).join(",") + "]";
+    if (value && typeof value === "object")
+        return ("{" +
+            Object.keys(value)
+                .sort()
+                .filter((k) => value[k] !== undefined)
+                .map((k) => JSON.stringify(k) + ":" + canonical(value[k]))
+                .join(",") +
+            "}");
+    return JSON.stringify(value) ?? "null";
+}
+export class Store {
+    db;
+    constructor(path) {
+        this.db = new DatabaseSync(path);
+        this.db
+            .exec(`PRAGMA journal_mode=WAL; PRAGMA foreign_keys=ON; PRAGMA busy_timeout=5000;
+      CREATE TABLE IF NOT EXISTS definitions(id TEXT PRIMARY KEY, body TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS sessions(id TEXT PRIMARY KEY, body TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS commands(id TEXT PRIMARY KEY, body TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS checkpoints(id TEXT PRIMARY KEY, body TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS effects(id TEXT PRIMARY KEY, body TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS actions(id TEXT PRIMARY KEY, body TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS events(sequence INTEGER PRIMARY KEY AUTOINCREMENT, session_id TEXT NOT NULL, body TEXT NOT NULL);
+      CREATE INDEX IF NOT EXISTS events_session ON events(session_id, sequence);`);
+    }
+    tx(fn) {
+        this.db.exec("BEGIN IMMEDIATE");
+        try {
+            const result = fn();
+            this.db.exec("COMMIT");
+            return result;
+        }
+        catch (e) {
+            this.db.exec("ROLLBACK");
+            throw e;
+        }
+    }
+    get(table, id) {
+        const row = this.db.prepare(`SELECT body FROM ${table} WHERE id=?`).get(id);
+        return row ? JSON.parse(String(row.body)) : undefined;
+    }
+    all(table) {
+        return this.db
+            .prepare(`SELECT body FROM ${table}`)
+            .all()
+            .map((r) => JSON.parse(String(r.body)));
+    }
+    put(table, id, body) {
+        this.db
+            .prepare(`INSERT INTO ${table}(id,body) VALUES(?,?) ON CONFLICT(id) DO UPDATE SET body=excluded.body`)
+            .run(id, JSON.stringify(body));
+    }
+    event(sessionId, turnId, type, payload) {
+        const base = {
+            eventId: randomUUID(),
+            sessionId,
+            turnId,
+            createdAt: new Date().toISOString(),
+            type,
+            payload,
+        };
+        const result = this.db
+            .prepare("INSERT INTO events(session_id,body) VALUES(?,?)")
+            .run(sessionId, "{}");
+        const event = {
+            ...base,
+            cursor: Buffer.from(`${sessionId}:${result.lastInsertRowid}`).toString("base64url"),
+        };
+        this.db
+            .prepare("UPDATE events SET body=? WHERE sequence=?")
+            .run(JSON.stringify(event), result.lastInsertRowid);
+        return event;
+    }
+    history(sessionId, cursor) {
+        let sequence = 0;
+        if (cursor) {
+            const decoded = Buffer.from(cursor, "base64url").toString();
+            const prefix = `${sessionId}:`;
+            if (!decoded.startsWith(prefix) ||
+                !/^\d+$/.test(decoded.slice(prefix.length)))
+                throw new Error("Invalid cursor");
+            sequence = Number(decoded.slice(prefix.length));
+        }
+        const items = this.db
+            .prepare("SELECT body FROM events WHERE session_id=? AND sequence>? ORDER BY sequence")
+            .all(sessionId, sequence)
+            .map((r) => JSON.parse(String(r.body)));
+        const last = this.db
+            .prepare("SELECT body FROM events WHERE session_id=? ORDER BY sequence DESC LIMIT 1")
+            .get(sessionId);
+        return {
+            items,
+            cursor: last ? JSON.parse(String(last.body)).cursor : null,
+        };
+    }
+}

package/dist/index.d.ts

@@ -1,11 +1,6 @@
-export type { RuntimeConfig } from "./config.js";
-export type * from "./contracts.js";
-export { Runtime, serveAgents, type AgentRouterOptions, type RuntimeActor, type ServeAgentsOptions, } from "./server/host.js";
-export { localJsonl, memoryHistory, JsonlJournal } from "./adapters/journal.js";
-export type { RuntimeDurability, CanonicalEvent, SessionSummary, } from "./adapters/journal.js";
-export { jsonlObserver } from "./adapters/observe.js";
-export { localMedia, MediaStore, IMAGE_MEDIA_TYPES, MAX_IMAGE_BYTES, decodeImageBase64, validateImageBytes, } from "./adapters/media.js";
-export type { RuntimeMedia, MediaAsset, MediaReference, } from "./adapters/media.js";
-export { piModel } from "./model/pi-model.js";
-export type { PiModelOptions } from "./model/pi-model.js";
-export { projectAsset } from "./assets.js";
+export { CoreRuntime, createRuntime, startRuntime, type RuntimeOptions } from "./core/runtime.js";
+export { scriptedModel, gatewayModel, type ModelProvider } from "./core/provider.js";
+export { httpModel, type HttpModelOptions, type ModelEnvironment } from "./model/http-model.js";
+export type { RuntimeAgent } from "./contracts.js";
+export { IMAGE_MEDIA_TYPES, MAX_IMAGE_BYTES, decodeImageBase64, validateImageBytes } from "./media.js";
+export type { RuntimeModelAdapter } from "./contracts.js";

package/dist/index.js

@@ -1,6 +1,4 @@
-export { Runtime, serveAgents, } from "./server/host.js";
-export { localJsonl, memoryHistory, JsonlJournal } from "./adapters/journal.js";
-export { jsonlObserver } from "./adapters/observe.js";
-export { localMedia, MediaStore, IMAGE_MEDIA_TYPES, MAX_IMAGE_BYTES, decodeImageBase64, validateImageBytes, } from "./adapters/media.js";
-export { piModel } from "./model/pi-model.js";
-export { projectAsset } from "./assets.js";
+export { CoreRuntime, createRuntime, startRuntime } from "./core/runtime.js";
+export { scriptedModel, gatewayModel } from "./core/provider.js";
+export { httpModel } from "./model/http-model.js";
+export { IMAGE_MEDIA_TYPES, MAX_IMAGE_BYTES, decodeImageBase64, validateImageBytes } from "./media.js";

package/dist/media.d.ts

@@ -0,0 +1,29 @@
+export declare const IMAGE_MEDIA_TYPES: readonly string[];
+export declare const MAX_IMAGE_BYTES: number;
+export interface MediaAsset {
+    readonly id: string;
+    readonly mediaType: string;
+    readonly bytes: number;
+    readonly kind: "input" | "generated";
+}
+/** Opaque reference retained by Harness and resolved by the configured media adapter. */
+export interface MediaReference {
+    readonly agentId: string;
+    readonly assetId: string;
+}
+export declare function decodeImageBase64(mediaType: string, base64: string): Uint8Array;
+/** Verify the asserted media type and lightweight file signature for a supported image. */
+export declare function validateImageBytes(mediaType: string, bytes: Uint8Array): void;
+export interface RuntimeMedia {
+    saveInput(agentId: string, sessionId: string, mediaType: string, base64: string): Promise<MediaAsset>;
+    saveGenerated(agentId: string, sessionId: string, mediaType: string, bytes: Uint8Array): Promise<MediaAsset>;
+    dataUrl(reference: MediaReference, sessionId: string): Promise<{
+        readonly asset: MediaAsset;
+        readonly url: string;
+    } | undefined>;
+    latestInput(agentId: string, sessionId: string): Promise<MediaAsset | undefined>;
+    read(agentId: string, sessionId: string, assetId: string): Promise<{
+        asset: MediaAsset;
+        bytes: Uint8Array;
+    } | undefined>;
+}

package/dist/media.js

@@ -0,0 +1,53 @@
+export const IMAGE_MEDIA_TYPES = Object.freeze([
+    "image/jpeg",
+    "image/png",
+    "image/webp",
+]);
+export const MAX_IMAGE_BYTES = 8 * 1024 * 1024;
+export function decodeImageBase64(mediaType, base64) {
+    if (!IMAGE_MEDIA_TYPES.includes(mediaType))
+        throw new Error("Only JPEG, PNG, and WebP images are supported.");
+    if (typeof base64 !== "string" || base64 === "")
+        throw new Error("Image data is required.");
+    if (base64.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/u.test(base64))
+        throw new Error("Image data must be canonical base64.");
+    const decoded = atob(base64);
+    const bytes = Uint8Array.from(decoded, (character) => character.charCodeAt(0));
+    if (btoa(decoded) !== base64)
+        throw new Error("Image data must be canonical base64.");
+    validateImageBytes(mediaType, bytes);
+    return bytes;
+}
+/** Verify the asserted media type and lightweight file signature for a supported image. */
+export function validateImageBytes(mediaType, bytes) {
+    if (!IMAGE_MEDIA_TYPES.includes(mediaType))
+        throw new Error("Only JPEG, PNG, and WebP images are supported.");
+    if (bytes.byteLength === 0 || bytes.byteLength > MAX_IMAGE_BYTES)
+        throw new Error("Images must be no larger than 8 MiB.");
+    const signature = mediaType === "image/jpeg"
+        ? bytes.byteLength >= 3 &&
+            bytes[0] === 0xff &&
+            bytes[1] === 0xd8 &&
+            bytes[2] === 0xff
+        : mediaType === "image/png"
+            ? bytes.byteLength >= 8 &&
+                bytes[0] === 0x89 &&
+                bytes[1] === 0x50 &&
+                bytes[2] === 0x4e &&
+                bytes[3] === 0x47 &&
+                bytes[4] === 0x0d &&
+                bytes[5] === 0x0a &&
+                bytes[6] === 0x1a &&
+                bytes[7] === 0x0a
+            : bytes.byteLength >= 12 &&
+                bytes[0] === 0x52 &&
+                bytes[1] === 0x49 &&
+                bytes[2] === 0x46 &&
+                bytes[3] === 0x46 &&
+                bytes[8] === 0x57 &&
+                bytes[9] === 0x45 &&
+                bytes[10] === 0x42 &&
+                bytes[11] === 0x50;
+    if (!signature)
+        throw new Error(`Image bytes do not match ${mediaType}.`);
+}

package/dist/model/defaults.d.ts

@@ -0,0 +1,17 @@
+import type { ModelAdapter } from "@nylorun/core/define";
+import { type ModelEnvironment } from "./http-model.js";
+export interface ModelPreview {
+    readonly invocationId: string;
+    readonly text: string;
+}
+export interface ModelFactoryOptions {
+    readonly environment?: ModelEnvironment;
+    readonly media?: import("../media.js").RuntimeMedia;
+    readonly onPreview?: (preview: ModelPreview) => void;
+}
+/** Installed only by the Node launcher before application imports. */
+export declare function installNodeModelFactory(factory: (options: ModelFactoryOptions) => ModelAdapter): void;
+export declare function defaultModel(options: ModelFactoryOptions): ModelAdapter;
+export declare function processEnvironment(): ModelEnvironment;
+export declare function installRuntimeLifecycle(register: (close: () => Promise<void>) => void): void;
+export declare function registerRuntimeLifecycle(close: () => Promise<void>): void;

package/dist/model/defaults.js

@@ -0,0 +1,21 @@
+import { httpModel } from "./http-model.js";
+let nodeFactory;
+/** Installed only by the Node launcher before application imports. */
+export function installNodeModelFactory(factory) {
+    nodeFactory = factory;
+}
+export function defaultModel(options) {
+    return options.environment === undefined && nodeFactory
+        ? nodeFactory(options)
+        : httpModel(options);
+}
+export function processEnvironment() {
+    return typeof process === "undefined" ? {} : process.env;
+}
+let runtimeLifecycle;
+export function installRuntimeLifecycle(register) {
+    runtimeLifecycle = register;
+}
+export function registerRuntimeLifecycle(close) {
+    runtimeLifecycle?.(close);
+}

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

@@ -0,0 +1,12 @@
+import type { ModelAdapter } from "@nylorun/core/define";
+import type { ModelFactoryOptions } from "./defaults.js";
+export type ModelEnvironment = Readonly<Record<string, string | undefined>>;
+export interface HttpModelOptions extends ModelFactoryOptions {
+    readonly provider?: "openai" | "custom" | "anthropic";
+    readonly model?: string;
+    readonly apiKey?: string;
+    readonly baseUrl?: string;
+    readonly fetch?: typeof fetch;
+}
+/** Fetch-only adapter for OpenAI-compatible and Anthropic HTTP endpoints. */
+export declare function httpModel(options?: HttpModelOptions): ModelAdapter;

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;