@nylorun/runtime 0.3.0-beta → 0.5.0-beta

package/CHANGELOG.md

@@ -1,5 +1,36 @@
 # Changelog
 
+## 0.5.0-beta
+
+### Minor Changes
+
+- Breaking beta: Runtime hosts use Harness `info` (`getInfo` / `SubmitOptions.info`) instead of
+  `scope`. Session scheduling stays in Runtime; Node-only adapters remain under
+  `@nylorun/runtime/node`. Compatible with Harness capability manifests and ToolDescriptor-only
+  model requests.
+- c5bbb1a: Breaking beta: make Harness `run()` a direct async state-in/state-out executor with
+  serializable pauses, application `info`, cancellation signals, awaited recording, and
+  agent-level output schemas. Runtime owns session scheduling with memory-default or exclusive
+  local storage and imports Harness contracts. Isolate Node adapters under `runtime/node`, stream
+  observations incrementally, and add opt-in bounded token previews with Studio reconciliation.
+  Migrate consumers and deployment guidance together; legacy event records remain archived, not
+  automatically replayed.
+
+### Patch Changes
+
+- Ignore Hono Node `context.env` stream bindings (`incoming`/`outgoing`) when
+  resolving model environment so Node `nylorun dev` uses process `.env` /
+  `piModel` instead of an empty portable HTTP adapter.
+- Update Runtime's canonical Harness dependency to the tested release.
+- Updated dependencies [c5bbb1a]
+  - @nylorun/harness@0.13.0-beta
+
+## 0.4.0-beta
+
+### Minor Changes
+
+- fa1860a: Use standard MODEL_PROVIDER, MODEL, MODEL_PROVIDER_API_KEY, and MODEL_PROVIDER_BASE_URL environment configuration. Export starter Hono apps and provide CLI development and production Node launchers. Existing starters require manual migration. Release preparation must update the creator Runtime compatibility pin with this release.
+
 ## 0.3.0-beta
 
 ### Minor Changes

package/README.md

@@ -1,46 +1,79 @@
 # @nylorun/runtime
 
-Portable agent lifecycle, a mountable Hono protocol router, pi-ai model providers, and the `nylorun` CLI. Runtime has no Harness dependency.
+Optional hosting for stateless Harness agents: session coordination, replaceable storage, Hono routes, model adapters, and the Node CLI. Runtime depends directly on canonical Harness types; Harness does not depend on Runtime.
 
 ```ts
+import { Hono } from "hono";
 import { Runtime, serveAgents } from "@nylorun/runtime";
-
 const runtime = new Runtime();
-app.route(
-  "/agents",
-  serveAgents({ agents, runtime })
-);
+const app = new Hono();
+app.route("/agents", serveAgents({ agents, runtime }));
+export default app;
+```
+
+The default is `memorySessions()` and no file observer. Portable imports do not initialize the filesystem. `httpModel()` supports text/tool/structured-output requests to OpenAI-compatible and Anthropic HTTP endpoints using injected environment values or process variables where available. It requires API keys; media inputs require a supplied media-aware adapter. The Node CLI installs `piModel()` for its broader provider catalog, local credential fallback, OAuth, and media support. Direct portable imports do not load dotenv or local credentials.
+
+## Storage and coordination
+
+```ts
+import { localSessions, piModel } from "@nylorun/runtime/node";
+const runtime = new Runtime({
+  sessions: localSessions({ root: ".data/sessions" }),
+  onModelCall: piModel(),
+});
 ```
 
-`Runtime` is the primitive stack: model adapter (`piModel` by default), observer (`jsonlObserver` per session by default), and durability (`localJsonl` by default). Session files live together under `.data/sessions/<agent>/<session>/` as `events.jsonl` and `observe.jsonl`. Agents bind only when served.
+A `SessionStore` provides `get(agentId, sessionId)`, atomic `put(agentId, sessionId, document)`, and `list(agentId)`. StoredSession includes Runtime metadata, Harness state, an active marker, and committed event history. Stores implement data operations only. The built-in SessionHost serializes inputs, cancels and awaits active work before replacement, persists accepted inputs before execution, and commits terminal state before reporting success. It restores completed and explicitly paused sessions; active markers found after a crash require reconciliation. Legacy event-only records remain archived history.
+
+`localSessions` exclusively owns its root through `.owner.lock`. Multiple owners are rejected, including adapters in the same process. Writes use temporary files and atomic replacement; lost ownership stops writes. Orderly `runtime.close()` releases the matching lock. Locks are never stolen by age or PID: after a crash, confirm the owner stopped before manually removing the lock. No shared-filesystem or multi-replica guarantee is made.
+
+The host's scheduling scope is one process. A shared store is not a distributed scheduler. Advanced applications can use `SessionHost` without Hono, reuse `agUiEvents()` protocol translation, or compose Harness with their own host. Managed Cloud Runtime remains future work.
 
-The application owns Hono composition, authentication, CORS, logging, process lifecycle, and deployment. Runtime owns agent sessions, durability, media, and AG-UI/session protocol routes. Graceful shutdown is optional: if the application installs signal handlers and wants to drain live sessions, flush pending journal writes, and run optional agent cleanup, it should await `runtime.close()`. An application that does not install handlers exits normally on its host's shutdown policy; `runtime.close()` does not run on crash, OOM, or SIGKILL.
+## Info, delivery, and resources
 
-Runtime publishes root-relative discovery and endpoint URLs. It infers the Hono
-mount from each request URL (so a separate consumer `hono` install still works).
-Mount at `/agents` or `/api/agents` without repeating that path in `serveAgents`.
-Pass explicit `basePath` when a reverse proxy rewrites the public prefix.
+Application middleware authorizes every route. `getInfo(context)` supplies extra application data for each invocation; Runtime adds `sessionId`. `getEnvironment(context)` can supply per-request provider bindings without changing process globals. Neither info nor live resources are implicitly model-visible. `getActor` remains a convenience for userId; use `getInfo` for typed application identity.
 
-`nylorun dev` enables local Studio connections automatically by setting `NYLORUN_DEV=1` for its child application. This allows HTTP/HTTPS browser origins on `localhost`, `127.0.0.1`, or `[::1]`, including Studio's fallback ports. Ordinary production startup does not enable this policy; the application owns production CORS and authorization.
+Runtime delivers ordered observations incrementally, separately from committed history. `tokens: true` enables provisional text previews on compatible model adapters; the default is off. `createModel({ environment, media, onPreview })` supplies preview support for custom adapters. Studio shows drafts separately and discards them on settlement; accepted output remains authoritative. Partial tool arguments never dispatch tools.
 
-`getActor(context)` supplies an optional actor id and session context for newly created sessions. `getRequestMetadata(context)` supplies JSON-safe metadata for inbound messages. Application middleware remains responsible for authorizing every agent route.
+Delivery limits default to 64 KiB of preview data per model invocation (also bounding queued previews), and 256 events or 1 MiB of queued execution/control data. Configure them with `delivery: { previewBytes, eventCount, eventBytes }`. Preview overflow suppresses further previews for that model invocation and emits an incomplete marker. Authoritative overflow closes the subscription. Neither path blocks model consumption; request-attached execution is cooperatively cancelled on disconnect. Independent execution/reconnection belongs to a custom host.
+
+Runtime owns controllers and its store lifecycle. It does not close application tools, databases, browsers, or subprocesses. The Node launcher drains registered Runtime hosts during orderly shutdown; application resource cleanup remains explicit. Imports never open a listening socket. Root-relative discovery supports ordinary Hono mounts; use `basePath` for a rewriting proxy. Production authentication, CORS, ingress timeouts, and TLS belong to the application and infrastructure.
 
 ## Commands
 
 - `nylorun configure`
 - `nylorun dev [--no-studio] [--no-open]`
+- `nylorun start [entry]` (default: `dist/src/index.js`)
 - `nylorun studio --agent-url http://localhost:3000/agents [--port 4161] [--no-open]`
 
-Studio attaches to an application you run. Use your own TypeScript/build tooling and a Node adapter such as `@hono/node-server` when applicable. `projectAsset("agents/skills/catalog")` resolves bundled application assets from source or a compiled `dist/` deployment.
+Export your Hono application with `export default app`. The CLI supplies the Node server adapter. `nylorun dev` watches `src/index.ts`, waits for `/agents/v1/agents`, and starts project-local Studio. `PORT` defaults to 3000. `--no-studio` runs only the application; `--no-open` keeps the browser closed. Ctrl-C stops both processes. `nylorun start` serves the built app without Studio or development CORS.
+
+### Environment configuration
 
-Provider credentials are stored in `.env/auth.json`, and selection in `.env/model.json`. `nylorun configure` can run before an agent graph is importable.
+Copy `.env.example` to `.env` and fill it in, or run `nylorun configure` before your agent graph is importable:
+
+```dotenv
+MODEL_PROVIDER=custom
+MODEL=your-model-id
+MODEL_PROVIDER_API_KEY=your-key
+MODEL_PROVIDER_BASE_URL=https://your-provider.example/v1
+```
 
-`nylorun dev` runs project-local `tsx watch src/index.ts`, waits for `/agents/v1/agents`, then starts project-local Studio. `PORT` defaults to 3000. `--no-studio` runs just the application; `--no-open` keeps the browser closed. Both flags can be combined. Ctrl-C stops both processes.
+`MODEL_PROVIDER_BASE_URL` is required only for `MODEL_PROVIDER=custom`; omit it for built-in providers. `configure`, `dev`, and `start` load `.env` before importing the app. Existing process variables win; a missing `.env` is valid. `.env.local` is ignored by Git but is not automatically loaded. Direct imports of Runtime do not load dotenv files.
+
+Explicit `piModel({ selection })` options take precedence over environment selection. Environment selection takes precedence over legacy files; incomplete selection produces an error. `MODEL_PROVIDER_API_KEY` overrides provider-native variables such as `OPENAI_API_KEY` and `ANTHROPIC_API_KEY`, which override stored credentials. API-key deployments require no credential files. Supply the same variables through your hosting provider's environment settings.
+
+The optional wizard writes selection and entered API keys to `.env`, preserving unrelated configuration. It reuses environment credentials without copying them into the file. OAuth is an alternative where supported; its credentials and refresh state live in ignored `.nylorun/auth.json`. Keep `.env` and `.nylorun/` private.
 
 ### Upgrading an existing starter
 
-After upgrading Runtime to a release containing `nylorun dev`, change the development script to `"dev": "nylorun dev"` and remove `dev:app` and `scripts/dev.mjs`. Remove the duplicated `basePath` option for normal Hono mounts.
+Migration is manual; the CLI will not replace a legacy `.env` directory.
+
+1. Back up the existing `.env/` directory to a private location outside the project before replacing it with a file. Preserve any `config/model.json` too.
+2. Translate `model.json` fields `provider`, `model`, and `custom.baseUrl` into `MODEL_PROVIDER`, `MODEL`, and `MODEL_PROVIDER_BASE_URL`. Copy API keys into `MODEL_PROVIDER_API_KEY` or provider-native variables. Replace the old `NYLO_CUSTOM_API_KEY` variable with `MODEL_PROVIDER_API_KEY`.
+3. Merge `integrations.env` variables into `.env`. Move OAuth records into `.nylorun/auth.json`. Add `.env`, `.env.local`, and `.nylorun/` to `.gitignore`; remove the old `.env/` exceptions.
+4. Replace the entrypoint's `serve(...)` call and Node adapter import with `export default app`. Set scripts to `"dev": "nylorun dev"` and `"start": "nylorun start"`. Remove the application's `@hono/node-server` dependency if unused elsewhere. Keep your build and asset-copy steps.
 
-Run `npm run configure` to move model selection to `.env/model.json`. Runtime reads the legacy `config/model.json` only when the new file is absent. Successful configuration removes the legacy file and its directory only if empty; credentials remain in `.env/auth.json`. Do not set `NYLORUN_DEV` in production.
+Runtime retains legacy `.env/model.json`, `config/model.json`, and `.env/auth.json` reads for existing applications using their own launcher. It does not automatically move or delete these files. Use the matching Runtime release pinned by the new creator; older releases cannot launch an exported app.
 
-The starter now uses one `tsconfig.json` with `rootDir: "."` and `outDir: "dist"`. Remove `noEmit` from that file and use `tsc --noEmit` for checks. Change the build's compiler invocation to `tsc -p tsconfig.json` before deleting `tsconfig.build.json`. Keep your existing asset-copy step. Projects whose checks include tests may retain separate build configuration.
+The exported app follows Hono composition conventions. See [deployment verification and limits](../DEPLOYMENT.md) and the [breaking migration guide](../MIGRATION.md). Node-only `projectAsset()` resolves bundled assets from source or compiled deployments.

package/dist/adapters/media.d.ts

@@ -1,16 +1,5 @@
-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;
-}
+import { type MediaAsset, type MediaReference } from "../media.js";
+export * from "../media.js";
 /** Explicit local asset store; agents receive only opaque references. */
 export declare class MediaStore {
     private readonly root;
@@ -30,11 +19,6 @@ export declare class MediaStore {
     private readMetadata;
     private directory;
 }
-/** Decode one canonical base64 image before it is persisted or sent to a provider. */
-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 declare function localMedia(options?: {
     root?: string;
 }): MediaStore;
-export type RuntimeMedia = Pick<MediaStore, "saveInput" | "saveGenerated" | "dataUrl" | "latestInput" | "read">;

package/dist/adapters/media.js

@@ -1,12 +1,8 @@
 import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { randomUUID } from "node:crypto";
-export const IMAGE_MEDIA_TYPES = Object.freeze([
-    "image/jpeg",
-    "image/png",
-    "image/webp",
-]);
-export const MAX_IMAGE_BYTES = 8 * 1024 * 1024;
+import { IMAGE_MEDIA_TYPES, MAX_IMAGE_BYTES, decodeImageBase64, validateImageBytes, } from "../media.js";
+export * from "../media.js";
 /** Explicit local asset store; agents receive only opaque references. */
 export class MediaStore {
     root;
@@ -91,52 +87,6 @@ export class MediaStore {
     }
 }
 /** Decode one canonical base64 image before it is persisted or sent to a provider. */
-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 bytes = Buffer.from(base64, "base64");
-    if (bytes.toString("base64") !== 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}.`);
-}
 function validAsset(value) {
     if (!value || typeof value !== "object")
         return false;

package/dist/adapters/observe.js

@@ -1,6 +1,6 @@
 import { appendFile, mkdir } from "node:fs/promises";
 import { join } from "node:path";
-import { scrub } from "./journal.js";
+import { scrub } from "../redact.js";
 import { projectSecrets } from "../model/settings.js";
 /** Local JSONL observer. Writes raw engine events beside session durability files. */
 export function jsonlObserver(options) {

package/dist/cli.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
-import { existsSync } from "node:fs";
-import { loadEnvFile } from "node:process";
 import { join } from "node:path";
 import { pathToFileURL } from "node:url";
 import { createRequire } from "node:module";
 import { ConfigurationCancelled, configureProvider, } from "./model/configure.js";
+import { loadProjectEnvironment } from "./environment.js";
 import { develop } from "./dev.js";
-const usage = `nylorun <configure|dev|studio>
+const usage = `nylorun <configure|dev|start|studio>
   dev [--no-studio] [--no-open]
+  start [entry]
   configure
   studio --agent-url <http(s)-url> [--port <n>] [--no-open]`;
 async function startStudio(agentServerUrl, open, port) {
@@ -37,6 +37,14 @@ async function main() {
     const [command, ...args] = process.argv.slice(2);
     if (!command || command === "--help" || command === "-h")
         return void console.log(usage);
+    if (["configure", "dev", "start"].includes(command))
+        loadProjectEnvironment();
+    if (command === "start") {
+        if (args.length > 1 || args[0]?.startsWith("--"))
+            throw new Error(usage);
+        await (await import("./launcher.js")).start(args[0]);
+        return;
+    }
     if (command === "dev") {
         process.exitCode = await develop(args);
         return;
@@ -48,9 +56,6 @@ async function main() {
         const cancel = (signal) => controller.abort(new ConfigurationCancelled(signal));
         process.once("SIGINT", () => cancel("SIGINT"));
         process.once("SIGTERM", () => cancel("SIGTERM"));
-        const integrations = join(process.cwd(), ".env", "integrations.env");
-        if (existsSync(integrations))
-            loadEnvFile(integrations);
         await configureProvider({ signal: controller.signal });
         return;
     }

package/dist/config.d.ts

@@ -1,13 +1,20 @@
-import type { RuntimeModelAdapter } from "./contracts.js";
-import type { RuntimeDurability } from "./adapters/journal.js";
-import type { RuntimeMedia } from "./adapters/media.js";
+import type { ModelAdapter } from "@nylorun/harness";
+import type { SessionStore } from "./sessions/store.js";
+import type { RuntimeMedia } from "./media.js";
+import type { ModelEnvironment } from "./model/http-model.js";
 export interface RuntimeConfig {
-    readonly onModelCall?: RuntimeModelAdapter;
-    readonly observer?: {
-        (event: {
-            readonly type: string;
-        }): void | Promise<void>;
-    };
-    readonly durability?: RuntimeDurability;
+    readonly onModelCall?: ModelAdapter;
+    readonly createModel?: (options: import("./model/defaults.js").ModelFactoryOptions) => ModelAdapter;
+    readonly observer?: (event: {
+        readonly type: string;
+    }) => void | Promise<void>;
+    readonly sessions?: SessionStore;
     readonly media?: RuntimeMedia;
+    readonly environment?: ModelEnvironment;
+    readonly tokens?: boolean;
+    readonly delivery?: {
+        readonly previewBytes?: number;
+        readonly eventBytes?: number;
+        readonly eventCount?: number;
+    };
 }

package/dist/contracts.d.ts

@@ -1,166 +1,3 @@
-/** Portable values and callable interfaces. No agent engine is required. */
-export type JsonValue = string | number | boolean | null | JsonObject | readonly JsonValue[];
-export type JsonObject = {
-    readonly [key: string]: JsonValue;
-};
-export type UserContentPart = {
-    readonly type: "text";
-    readonly text: string;
-} | {
-    readonly type: "media";
-    readonly mediaType: string;
-    readonly reference: JsonValue;
-};
-export type MessageInput = string | {
-    readonly text: string;
-    readonly metadata?: JsonObject;
-} | {
-    readonly content: readonly UserContentPart[];
-    readonly metadata?: JsonObject;
-};
-export type InteractionReply = {
-    readonly kind: "approve";
-    readonly interactionId: string;
-    readonly approved: boolean;
-} | {
-    readonly kind: "respond";
-    readonly interactionId: string;
-    readonly value: JsonValue;
-};
-export type RuntimeInput = MessageInput | InteractionReply;
-export type RuntimeInputEvent = InteractionReply | {
-    readonly kind: "user-message" | "interrupt";
-    readonly text?: string;
-    readonly content?: readonly UserContentPart[];
-};
-/** Lifecycle events are delivered in completion order; other events are diagnostics. */
-export interface RuntimeEvent {
-    readonly type: string;
-    readonly output?: JsonValue;
-    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";
-    readonly events: readonly RuntimeEvent[];
-}
-export interface RuntimeSession {
-    readonly id: string;
-    input(event: RuntimeInput, options?: {
-        readonly signal?: AbortSignal;
-    }): {
-        readonly completed: Promise<RuntimeCompletion>;
-    };
-    stream(): AsyncIterable<RuntimeEvent>;
-    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;
-    readonly manifest: {
-        readonly id: string;
-        readonly name: string;
-    };
-    run(options: RuntimeRunOptions): RuntimeSession;
-    close?(): Promise<void>;
-}
-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;
-};
-export type PromptItem = {
-    readonly kind: "instructions";
-    readonly role: "system";
-    readonly content: readonly PromptContentPart[];
-} | {
-    readonly kind: "message";
-    readonly role: "user" | "assistant";
-    readonly content: readonly PromptContentPart[];
-} | {
-    readonly kind: "context";
-    readonly role: "user";
-    readonly content: readonly PromptContentPart[];
-} | {
-    readonly kind: "tool-result";
-    readonly toolCallId: string;
-    readonly toolName: string;
-    readonly status: "completed" | "denied" | "failed";
-    readonly content: readonly PromptContentPart[];
-};
-export interface RuntimeModelCall {
-    readonly sessionId: string;
-    readonly prompt: readonly PromptItem[];
-    readonly tools: readonly {
-        readonly name: string;
-        readonly description?: string;
-        readonly inputSchema: JsonObject;
-    }[];
-    readonly outputSchema?: JsonObject;
-    readonly model?: {
-        readonly id?: string;
-        readonly controls?: {
-            readonly temperature?: number;
-            readonly maxOutputTokens?: number;
-        };
-        readonly config?: JsonObject;
-    };
-}
-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;
-    })[];
-    readonly finishReason?: "stop" | "length" | "tool-calls" | "content-filter" | "other";
-    readonly usage?: {
-        readonly inputTokens?: number;
-        readonly outputTokens?: number;
-        readonly totalTokens?: number;
-        readonly costUsd?: number;
-    };
-    readonly evidence?: {
-        readonly resolvedModel?: string;
-    };
-}
-export interface RuntimeModelContext {
-    readonly signal: AbortSignal;
-    reportPreparedCall?(prepared: {
-        readonly adapter: string;
-        readonly call: JsonValue;
-    }): void;
-}
-export type RuntimeModelAdapter = (call: RuntimeModelCall, context: RuntimeModelContext) => Promise<RuntimeModelCandidate>;
+/** Execution contracts are owned by Harness. */
+export type { JsonValue, JsonObject, MessageInput, UserContentPart, PromptContentPart, PromptItem, ModelCall as RuntimeModelCall, ModelCandidate as RuntimeModelCandidate, ModelAdapter as RuntimeModelAdapter, ModelAdapterContext as RuntimeModelContext, ExecutionInput as RuntimeInput, InputEvent as RuntimeInputEvent, RunResult as RuntimeCompletion, ExecutionEvent as RuntimeEvent, } from "@nylorun/harness";
+export type RuntimeAgent = import("@nylorun/harness").BuiltAgent<any, any>;

package/dist/dev-entry.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/dev-entry.js

@@ -0,0 +1,2 @@
+import { start } from "./launcher.js";
+await start(process.argv[2] ?? "src/index.ts", true);

package/dist/dev.js

@@ -69,7 +69,12 @@ export async function develop(args) {
         }));
     };
     try {
-        launch([tsx, "watch", "src/index.ts"]);
+        launch([
+            tsx,
+            "watch",
+            fileURLToPath(new URL("./dev-entry.js", import.meta.url)),
+            "src/index.ts",
+        ]);
         if (!args.includes("--no-studio")) {
             const url = `http://127.0.0.1:${port}/agents/v1/agents`;
             const deadline = Date.now() + 20_000;

package/dist/environment.d.ts

@@ -0,0 +1,2 @@
+export declare function loadProjectEnvironment(root?: string): void;
+export declare function saveEnvironment(root: string, updates: Record<string, string | undefined>, signal?: AbortSignal): Promise<void>;

package/dist/environment.js

@@ -0,0 +1,64 @@
+import { readFileSync, statSync } from "node:fs";
+import { writeFile, rename, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { loadEnvFile } from "node:process";
+export function loadProjectEnvironment(root = process.cwd()) {
+    const file = join(root, ".env");
+    try {
+        if (statSync(file).isDirectory())
+            throw new Error("The .env directory must be migrated manually: back it up, create a .env file with MODEL_PROVIDER, MODEL and MODEL_PROVIDER_API_KEY, and move OAuth credentials to .nylorun/auth.json. See the Runtime migration guide.");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return;
+        throw error;
+    }
+    loadEnvFile(file);
+}
+// Match complete dotenv assignments, including quoted multiline values.
+const assignment = /^(?:export\s+)?([\w]+)[\t ]*=[\t ]*(?:"[^"]*"|'[^']*'|`[^`]*`|[^#\r\n]*)([^\r\n]*)(?:\r?\n|$)/gm;
+export async function saveEnvironment(root, updates, signal) {
+    const file = join(root, ".env");
+    let contents = "";
+    try {
+        contents = readFileSync(file, "utf8");
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    const encode = (value) => {
+        // Node's dotenv parser has no general quote-escaping syntax. Select a
+        // delimiter absent from the value rather than changing the credential.
+        for (const quote of ["'", '"', "`"]) {
+            if (!value.includes(quote) && !(quote === '"' && /\\[nr]/.test(value)))
+                return quote + value + quote;
+        }
+        throw new Error("This value contains all dotenv quote delimiters; set it through your process environment instead.");
+    };
+    const remaining = new Set(Object.keys(updates));
+    contents = contents.replace(assignment, (whole, key, suffix) => {
+        if (!(key in updates))
+            return whole;
+        if (!remaining.delete(key))
+            return "";
+        return updates[key] === undefined
+            ? ""
+            : `${key}=${encode(updates[key])}${suffix}\n`;
+    });
+    if (contents && !contents.endsWith("\n"))
+        contents += "\n";
+    for (const key of remaining)
+        if (updates[key] !== undefined)
+            contents += `${key}=${encode(updates[key])}\n`;
+    const temporary = join(root, `.env-${randomUUID()}.tmp`);
+    try {
+        await writeFile(temporary, contents, { mode: 0o600, signal });
+        signal?.throwIfAborted();
+        await rename(temporary, file);
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+}

package/dist/index.d.ts

@@ -1,11 +1,11 @@
 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 { SessionHost, type SubmitOptions } from "./sessions/host.js";
+export { memorySessions } from "./sessions/store.js";
+export type { SessionStore, ManagedSessionStore, StoredSession, SessionSummary, CanonicalEvent, } from "./sessions/store.js";
+export { IMAGE_MEDIA_TYPES, MAX_IMAGE_BYTES, decodeImageBase64, validateImageBytes, } from "./media.js";
+export type { RuntimeMedia, MediaAsset, MediaReference } from "./media.js";
+export { httpModel, type HttpModelOptions, type ModelEnvironment, } from "./model/http-model.js";
+export { agUiEvents } from "./server/ag-ui.js";
+export type { ModelFactoryOptions, ModelPreview } from "./model/defaults.js";

package/dist/index.js

@@ -1,6 +1,6 @@
 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 { SessionHost } from "./sessions/host.js";
+export { memorySessions } from "./sessions/store.js";
+export { IMAGE_MEDIA_TYPES, MAX_IMAGE_BYTES, decodeImageBase64, validateImageBytes, } from "./media.js";
+export { httpModel, } from "./model/http-model.js";
+export { agUiEvents } from "./server/ag-ui.js";

package/dist/launcher.d.ts

@@ -0,0 +1 @@
+export declare function start(entry?: string, development?: boolean): Promise<void>;