@nylorun/runtime 0.1.1-beta → 0.2.0-beta

package/dist/config.js

@@ -1,15 +1 @@
-export function defineRuntime(config) {
-    if (!config || !Array.isArray(config.agents))
-        throw new Error("Runtime config must declare an agents array.");
-    for (const agent of config.agents) {
-        if (!agent ||
-            typeof agent.run !== "function" ||
-            typeof agent.id !== "string" ||
-            !agent.manifest)
-            throw new Error("Every registered agent must satisfy RuntimeAgent.");
-    }
-    return Object.freeze({
-        ...config,
-        agents: Object.freeze([...config.agents]),
-    });
-}
+export {};

package/dist/contracts.d.ts

@@ -40,6 +40,10 @@ export interface RuntimeEvent {
     readonly event?: RuntimeInputEvent;
     readonly interaction?: unknown;
     readonly attributes?: unknown;
+    readonly tripwire?: {
+        readonly code: string;
+        readonly message?: string;
+    };
 }
 export interface RuntimeCompletion {
     readonly status: "completed" | "waiting" | "rejected" | "cancelled" | "stopped";
@@ -53,9 +57,19 @@ export interface RuntimeSession {
         readonly completed: Promise<RuntimeCompletion>;
     };
     stream(): AsyncIterable<RuntimeEvent>;
-    observe(listener: (event: RuntimeEvent) => void | Promise<void>): () => void;
     stop(reason?: string): Promise<void>;
 }
+export interface RuntimeRunOptions {
+    readonly id?: string;
+    readonly userId?: string;
+    readonly context?: JsonObject;
+    readonly onModelCall: RuntimeModelAdapter;
+    readonly observer?: {
+        (event: {
+            readonly type: string;
+        }): void | Promise<void>;
+    };
+}
 export interface RuntimeAgent {
     readonly id: string;
     readonly name: string;
@@ -63,15 +77,18 @@ export interface RuntimeAgent {
         readonly id: string;
         readonly name: string;
     };
-    run(options?: {
-        readonly id?: string;
-        readonly userId?: string;
-        readonly context?: JsonObject;
-    }): RuntimeSession;
+    run(options: RuntimeRunOptions): RuntimeSession;
     close?(): Promise<void>;
 }
-export type PromptContentPart = UserContentPart | {
+export type PromptContentPart = Exclude<UserContentPart, {
+    readonly type: "text";
+}> | {
+    readonly type: "text" | "reasoning";
+    readonly text: string;
+    readonly providerMetadata?: JsonObject;
+} | {
     readonly type: "tool-call";
+    readonly providerMetadata?: JsonObject;
     readonly id: string;
     readonly name: string;
     readonly args: JsonObject;
@@ -117,11 +134,13 @@ export interface RuntimeModelCandidate {
     readonly output: readonly ({
         readonly type: "text" | "reasoning";
         readonly text: string;
+        readonly providerMetadata?: JsonObject;
     } | {
         readonly type: "json";
         readonly value: JsonValue;
     } | {
         readonly type: "tool-call";
+        readonly providerMetadata?: JsonObject;
         readonly id: string;
         readonly name: string;
         readonly args: JsonObject;

package/dist/index.d.ts

@@ -1,11 +1,11 @@
-export { defineRuntime } from "./config.js";
 export type { RuntimeConfig } from "./config.js";
 export type * from "./contracts.js";
-export { createRuntime } from "./server/host.js";
-export { piModel } from "./model/pi-model.js";
-export type { PiModelOptions } from "./model/pi-model.js";
+export { Runtime, serveAgents, type AgentRouterOptions, type RuntimeActor, type ServeAgentsOptions, } from "./server/host.js";
 export { localJsonl, memoryHistory, JsonlJournal } from "./adapters/journal.js";
-export type { RuntimePersistence, CanonicalEvent, SessionSummary, } 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";

package/dist/index.js

@@ -1,6 +1,6 @@
-export { defineRuntime } from "./config.js";
-export { createRuntime } from "./server/host.js";
-export { piModel } from "./model/pi-model.js";
+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";

package/dist/model/pi-model.js

@@ -21,6 +21,31 @@ export function piModel(options = {}) {
         const selected = registry.getModel(selection.provider, selection.model);
         if (!selected)
             throw new Error("Unknown model. Run nylorun configure.");
+        const signatureFor = (part) => {
+            const metadata = "providerMetadata" in part ? part.providerMetadata?.pi : undefined;
+            if (!metadata || typeof metadata !== "object" || Array.isArray(metadata))
+                return;
+            if (!("provider" in metadata) ||
+                metadata.provider !== selected.provider ||
+                !("model" in metadata) ||
+                metadata.model !== selected.id ||
+                !("signature" in metadata) ||
+                typeof metadata.signature !== "string")
+                return;
+            return metadata.signature;
+        };
+        const metadataFor = (signature, redacted) => signature === undefined
+            ? {}
+            : {
+                providerMetadata: {
+                    pi: {
+                        provider: selected.provider,
+                        model: selected.id,
+                        signature,
+                        ...(redacted ? { redacted: true } : {}),
+                    },
+                },
+            };
         const messages = [];
         const instructions = [];
         const content = async (parts) => {
@@ -85,11 +110,37 @@ export function piModel(options = {}) {
                                 id: part.id,
                                 name: part.name,
                                 arguments: { ...part.args },
+                                ...(signatureFor(part) === undefined
+                                    ? {}
+                                    : { thoughtSignature: signatureFor(part) }),
                             },
                         ]
                         : part.type === "text"
-                            ? [{ type: "text", text: part.text }]
-                            : []),
+                            ? [
+                                {
+                                    type: "text",
+                                    text: part.text,
+                                    ...(signatureFor(part) === undefined
+                                        ? {}
+                                        : { textSignature: signatureFor(part) }),
+                                },
+                            ]
+                            : part.type === "reasoning" &&
+                                signatureFor(part) !== undefined
+                                ? [
+                                    {
+                                        type: "thinking",
+                                        thinking: part.text,
+                                        thinkingSignature: signatureFor(part),
+                                        ...(typeof part.providerMetadata?.pi === "object" &&
+                                            part.providerMetadata.pi !== null &&
+                                            "redacted" in part.providerMetadata.pi &&
+                                            part.providerMetadata.pi.redacted === true
+                                            ? { redacted: true }
+                                            : {}),
+                                    },
+                                ]
+                                : []),
                 });
             }
             else
@@ -132,15 +183,24 @@ export function piModel(options = {}) {
             const output = [];
             for (const part of response.content) {
                 if (part.type === "text")
-                    output.push({ type: "text", text: part.text });
+                    output.push({
+                        type: "text",
+                        text: part.text,
+                        ...metadataFor(part.textSignature),
+                    });
                 else if (part.type === "thinking")
-                    output.push({ type: "reasoning", text: part.thinking });
+                    output.push({
+                        type: "reasoning",
+                        text: part.thinking,
+                        ...metadataFor(part.thinkingSignature, part.redacted),
+                    });
                 else if (part.type === "toolCall")
                     output.push({
                         type: "tool-call",
                         id: part.id,
                         name: part.name,
                         args: part.arguments,
+                        ...metadataFor(part.thoughtSignature),
                     });
             }
             return {

package/dist/server/ag-ui.js

@@ -40,13 +40,22 @@ export function agUiEvents(events, threadId, runId) {
                 : JSON.stringify(event.payload.output);
             output.push({ type: "TEXT_MESSAGE_START", messageId, role: "assistant" }, { type: "TEXT_MESSAGE_CONTENT", messageId, delta: text }, { type: "TEXT_MESSAGE_END", messageId });
         }
-        else if (event.type === "error") {
+        else if (event.type === "error" || event.type === "tripwire") {
+            const tripwire = event.payload.tripwire;
+            const payload = tripwire && typeof tripwire === "object"
+                ? { ...event.payload, ...tripwire }
+                : event.payload;
+            const attributes = payload.attributes;
+            const message = payload.message ??
+                (attributes && typeof attributes === "object" && "message" in attributes
+                    ? attributes.message
+                    : undefined);
             output.push({
                 type: "RUN_ERROR",
-                message: typeof event.payload.message === "string"
-                    ? event.payload.message
-                    : "Agent run failed.",
+                message: typeof message === "string" ? message : "Agent run failed.",
+                ...(typeof payload.code === "string" ? { code: payload.code } : {}),
             });
+            return Object.freeze(output);
         }
     }
     output.push({ type: "RUN_FINISHED", threadId, runId });

package/dist/server/digests.d.ts

@@ -1,6 +1,8 @@
-import type { RuntimeEvent } from "../contracts.js";
 /** Optional diagnostic enrichment; engines need not emit model diagnostics. */
-export declare function observedPayload(event: RuntimeEvent): Record<string, unknown>;
+export declare function observedPayload(event: {
+    readonly type: string;
+    readonly attributes?: unknown;
+}): Record<string, unknown>;
 export declare function modelRequestDigests(value: unknown): {
     prompt: string;
     tools: string;

package/dist/server/host.d.ts

@@ -1,14 +1,27 @@
-import { Hono } from "hono";
+import { Hono, type Context } from "hono";
+import type { JsonValue, RuntimeAgent } from "../contracts.js";
 import type { RuntimeConfig } from "../config.js";
-export declare function createRuntime(options: RuntimeConfig): Promise<Readonly<{
-    app: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
-    hasSession: (agentId: string, sessionId: string) => boolean;
+export type RuntimeActor = Readonly<{
+    id: string;
+    context?: Record<string, JsonValue>;
+}>;
+export type AgentRouterOptions = Readonly<{
+    /** Public URL prefix of this router, matching the Hono mount path. */
+    basePath?: string;
+    getActor?: (context: Context) => RuntimeActor | undefined | Promise<RuntimeActor | undefined>;
+    getRequestMetadata?: (context: Context) => Record<string, JsonValue> | undefined | Promise<Record<string, JsonValue> | undefined>;
+}>;
+export type ServeAgentsOptions = AgentRouterOptions & {
+    readonly agents: readonly RuntimeAgent[];
+    readonly runtime: Runtime;
+};
+declare const kServe: unique symbol;
+export declare class Runtime {
+    #private;
+    constructor(options?: RuntimeConfig);
     close: () => Promise<void>;
-}>>;
-/** Host headers a loopback bind answers to, on the port actually in use. */
-export declare function loopbackHosts(port: number): readonly string[];
-/**
- * Decide whether a request's Host header is served. Entries are exact
- * `host:port` values or bare host names that accept any port; `*` accepts all.
- */
-export declare function allowedHost(header: string | undefined, allowed: readonly string[]): boolean;
+    [kServe](options: Omit<ServeAgentsOptions, "runtime">): Hono;
+}
+/** Create the Hono protocol mount for a runtime. Applications may close it during graceful shutdown. */
+export declare function serveAgents(options: ServeAgentsOptions): any;
+export {};