@nylorun/runtime 0.4.0-beta → 0.5.0-beta

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 {};