@nylorun/runtime 0.4.0-beta → 0.6.0-beta

package/CHANGELOG.md

@@ -1,5 +1,60 @@
 # Changelog
 
+## 0.6.0-beta
+
+### Major Changes
+
+- 2898d02: Extract shared definitions and contracts into core and local orchestration into
+  CLI. Harness becomes execution-only; the SDK no longer installs the engine and
+  Runtime no longer depends on the SDK. Author applications through agents and
+  install cli for the unchanged nylorun commands. See the package architecture and
+  migration guide. Cloud installs published packages from npm independently.
+
+### Minor Changes
+
+- 41e613c: Ship the local SDK registry workflow with an independent SQLite Runtime, connected tool executor, authenticated Studio proxy, and a text-and-tool starter. Replace the legacy Hono starter and AG-UI transport. Require Node 24 and include the SDK in exact release compatibility pins.
+
+  Break the Harness execution import from `/engine` to `/run` and rename hosted execution APIs to durable execution APIs, including RunBinding, BoundRunOptions, and createRunState. Update all consumers without compatibility aliases; retain persisted checkpoint fields and version pins.
+
+### Patch Changes
+
+- Pin core to the tested release.
+- Pin harness to the tested release.
+- Updated dependencies [41e613c]
+- Updated dependencies [2898d02]
+- Updated dependencies
+  - @nylorun/core@0.1.1-beta
+  - @nylorun/harness@0.15.0-beta
+
+## 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
+
+- Remove the experimental Cloud Agents API destination client and related
+  `RuntimeConfig.cloud` / `NYLORUN_*` Cloud-mode wiring from OSS Runtime.
+  Local `openSession` remains the only destination. Cloud upgrades published
+  packages from npm independently.
+- 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

package/README.md

@@ -1,65 +1,47 @@
 # @nylorun/runtime
 
-Portable agent lifecycle, a mountable Hono protocol router, pi-ai model providers, and the `nylorun` CLI. Runtime has no Harness dependency.
+The independent OSS HTTP execution host consumes `@nylorun/harness/run` and `@nylorun/core/contracts`. Cloud installs published `@nylorun/harness` from npm and does not import this Runtime package. Client authoring, sessions and connected executors belong to `@nylorun/agents`.
 
-```ts
-import { Runtime, serveAgents } from "@nylorun/runtime";
+Requires Node 24+. Build from the repository root:
 
-const runtime = new Runtime();
-app.route(
-  "/agents",
-  serveAgents({ agents, runtime })
-);
+```sh
+npm install
+npm run build --workspace @nylorun/core
+npm run build --workspace @nylorun/harness
+npm run build --workspace @nylorun/runtime
+NYLORUN_SERVER_KEY='<separate-secret-at-least-16-characters>' npm start --workspace @nylorun/runtime
 ```
 
-`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.
-
-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.
-
-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.
-
-`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.
-
-`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.
+Default address: `http://127.0.0.1:8787`. `HOST`, `PORT`, and `NYLORUN_SQLITE_PATH` configure binding and storage. Missing server credentials fail startup. The default model is a credential-free scripted development response. It does not simulate conversations, tools or provider compatibility.
 
-## Commands
+`NYLORUN_EXECUTORS_JSON` is an array of `{token, agentId, manifestHash, implementationVersion}`. Each secret must differ from the application server key and every other executor token. The manifest hash is available from `@nylorun/core/compatibility` or saved definition registration. SDK clients use `NYLORUN_RUNTIME_URL`, `NYLORUN_SERVER_KEY`, and `NYLORUN_EXECUTOR_KEY`; runtime executor scope is configured explicitly, never broadened by client input.
 
-- `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]`
+For a model gateway, set `NYLORUN_MODEL_GATEWAY_URL`, `NYLORUN_MODEL_GATEWAY_KEY`, and `NYLORUN_MODEL`. The gateway receives `{model, call, context}` and returns a harness ModelCandidate or string. Provider credentials remain host configuration. The generic gateway requires an implementation of this envelope; it does not claim arbitrary provider wire compatibility. Alternatively supply a `ModelProvider` to `startRuntime`.
 
-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
-
-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
+```ts
+import { startRuntime } from '@nylorun/runtime/core';
+const runtime = await startRuntime({
+  sqlitePath: './nylorun.sqlite',
+  serverToken: process.env.NYLORUN_SERVER_KEY!,
+  executors: [], // Configure exact scoped executor credentials before customer actions.
+  port: 8787,
+});
+// Application owns lifecycle.
+await runtime.close();
 ```
 
-`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.
+The session-first `/v1` API is specified in [HOST_CONTRACT.md](../harness/HOST_CONTRACT.md). `/health` confirms HTTP liveness; `/ready` checks SQLite and scheduler availability. Readiness is not a provider connectivity probe or functional correctness claim. Application tokens authorize definition/session APIs, while exact scoped executor credentials authorize authenticated SSE `/v1/executors/connect`, action discovery, claims, renewal and results. Session observers cannot claim actions.
 
-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.
+SQLite transactions persist session checkpoints, command receipts, individual effects/actions, waits and canonical history. Actions are committed before notifications. Accepted execution is detached from HTTP request lifetime. Restart schedules persisted runnable sessions; model intents lacking recorded outcomes become uncertain. Expired customer claims become uncertain and are not automatically repeated. `GET /v1/sessions/:id` exposes waits, outstanding actions and uncertain effect summaries. Cancellation ends the current turn; a later message can start another turn from the state preceding the cancelled turn. Canonical events and uncertain external work remain inspectable. Reconciliation operations are not implemented in this pass.
 
-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.
+One process owns each SQLite database. A local PID lock rejects concurrent owners and recovers only when the recorded process no longer exists. Shared/network filesystems and multiple replicas are unsupported. Keep the database and its WAL/journal together; do not delete persisted effects separately from checkpoints. Invalid lock contents or PID reuse fail closed and require operator inspection. TLS and external ingress belong to deployment infrastructure.
 
-### Upgrading an existing starter
+## Local project workflow
 
-Migration is manual; the CLI will not replace a legacy `.env` directory.
+Install `@nylorun/cli` (generated projects already include it). Use `npm run configure`, then `nylorun dev` in a generated project. It loads the exported `agents` registry from `agents/index.ts`, starts this Runtime in a separate process, registers manifests, connects scoped SDK executors, and opens Studio. Use `--no-studio` or `--no-open` as needed. Runtime binds loopback on port 8787 (`PORT` override). The CLI creates separate server and executor credentials with mode 0600 in `.nylorun/local-credentials.json`; SQLite defaults to `.nylorun/runtime.sqlite`.
 
-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.
+`nylorun start [entry]` loads `dist/agents/index.js` by default and runs without Studio/watch. `nylorun studio --runtime-url http://127.0.0.1:8787` attaches using the project's local server credential (or `NYLORUN_SERVER_KEY`). Provider selection uses the existing `MODEL_PROVIDER`, `MODEL`, `MODEL_PROVIDER_API_KEY`, and optional `MODEL_PROVIDER_BASE_URL` configuration. No provider request occurs during configuration.
 
-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.
+Definitions have no `agent.run()`; applications use `@nylorun/agents`. Remove old Hono `src/index.ts`, `Runtime`, `serveAgents`, and `openSession` usage from supported starters. Historical implementations remain internal for regression coverage and advanced examples; they are not root exports or supported hosting alternatives.
 
-The exported app follows Hono composition conventions. This change does not establish verified serverless persistence, execution lifetime, or Workers support. `projectAsset()` resolves bundled assets from source or compiled deployments.
+Source changes restart the local stack. Start a new session after definition or implementation edits; live upgrades are deferred. `GET /v1/agents` and `GET /v1/sessions?agentId=...` are server-authenticated local discovery conveniences. See the repository handoff for verification and remaining scope.

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/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/core/define";
+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/configuration.d.ts

@@ -0,0 +1,3 @@
+export { modelsFor, type Selection } from "./model/models.js";
+export { modelSelection, projectSecrets } from "./model/settings.js";
+export { ProjectCredentialStore } from "./model/auth-store.js";

package/dist/configuration.js

@@ -0,0 +1,3 @@
+export { modelsFor } from "./model/models.js";
+export { modelSelection, projectSecrets } from "./model/settings.js";
+export { ProjectCredentialStore } from "./model/auth-store.js";

package/dist/contracts.d.ts

@@ -1,166 +1,5 @@
-/** 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, InputEvent as RuntimeInputEvent } from "@nylorun/core/define";
+export type { ExecutionInput as RuntimeInput, RunResult as RuntimeCompletion, ExecutionEvent as RuntimeEvent, Session, Turn, Event, Result, InputAccepted, AgentIdentity } from "@nylorun/harness";
+export type { RunBinding, BoundRunOptions, } from "@nylorun/harness/run";
+export type RuntimeAgent = import("@nylorun/core/define").BuiltAgent<any, any>;

package/dist/core/main.js

@@ -0,0 +1,40 @@
+import { piModel } from "../model/pi-model.js";
+import { startRuntime } from "./runtime.js";
+import { gatewayModel, scriptedModel, toolFixtureModel } from "./provider.js";
+const serverToken = process.env.NYLORUN_SERVER_KEY;
+if (!serverToken)
+    throw new Error("Set NYLORUN_SERVER_KEY (at least 16 characters)");
+const executors = JSON.parse(process.env.NYLORUN_EXECUTORS_JSON ?? "[]");
+const configured = piModel();
+const projectModel = (effect, signal) => configured(effect.input, {
+    request: effect.context.request,
+    invocationId: String(effect.context.invocationId),
+    signal,
+    reportPreparedCall() { },
+});
+const model = process.env.NYLORUN_DEV_MODEL === "fixture"
+    ? toolFixtureModel()
+    : process.env.NYLORUN_PROJECT_PROVIDER === "1"
+        ? projectModel
+        : process.env.NYLORUN_MODEL_GATEWAY_URL
+            ? gatewayModel({
+                url: process.env.NYLORUN_MODEL_GATEWAY_URL,
+                token: process.env.NYLORUN_MODEL_GATEWAY_KEY ?? "",
+                model: process.env.NYLORUN_MODEL ?? "",
+            })
+            : scriptedModel(process.env.NYLORUN_SCRIPTED_OUTPUT);
+const runtime = await startRuntime({
+    sqlitePath: process.env.NYLORUN_SQLITE_PATH ?? "./nylorun.sqlite",
+    serverToken,
+    executors,
+    model,
+    port: Number(process.env.PORT ?? 8787),
+    hostname: process.env.HOST ?? "127.0.0.1",
+});
+console.log(`Nylorun Runtime listening at ${runtime.url}`);
+process.send?.({ type: "ready", url: runtime.url });
+let closing;
+for (const signal of ["SIGINT", "SIGTERM"])
+    process.on(signal, () => {
+        closing ??= runtime.close().then(() => { process.exit(0); });
+    });

package/dist/core/provider.d.ts

@@ -0,0 +1,12 @@
+import type { HostEffect } from "@nylorun/harness/run";
+/** Providers are runtime-owned; neither credentials nor model selection enter manifests. */
+export type ModelProvider = (effect: HostEffect, signal: AbortSignal) => Promise<unknown>;
+export declare function scriptedModel(output?: string): ModelProvider;
+/** A configured gateway receives the complete harness model call, including history and schemas. */
+export declare function gatewayModel(options: {
+    url: string;
+    token: string;
+    model: string;
+}): ModelProvider;
+/** Deterministic release fixture; still uses the real engine and remote customer tool. */
+export declare function toolFixtureModel(): ModelProvider;

package/dist/core/provider.js

@@ -0,0 +1,60 @@
+export function scriptedModel(output = "Scripted development response") {
+    return async () => ({ output: [{ type: "text", text: output }] });
+}
+/** A configured gateway receives the complete harness model call, including history and schemas. */
+export function gatewayModel(options) {
+    return async (effect, signal) => {
+        const response = await fetch(options.url, {
+            method: "POST",
+            signal,
+            headers: {
+                authorization: `Bearer ${options.token}`,
+                "content-type": "application/json",
+            },
+            body: JSON.stringify({
+                model: options.model,
+                call: effect.input,
+                context: effect.context,
+            }),
+        });
+        if (!response.ok)
+            throw new Error(`Model gateway returned ${response.status}`);
+        return response.json();
+    };
+}
+/** Deterministic release fixture; still uses the real engine and remote customer tool. */
+export function toolFixtureModel() {
+    return async (effect) => {
+        const call = effect.input;
+        const last = call.prompt.at(-1);
+        if (last?.kind === "tool-result")
+            return {
+                output: [
+                    {
+                        type: "text",
+                        text: `Order lookup complete: ${last.content.map((part) => (part.type === "text" ? part.text : JSON.stringify(part))).join(" ")}`,
+                    },
+                ],
+            };
+        const users = call.prompt.filter((p) => p.kind === "message" && p.role === "user");
+        if (users.length > 1)
+            return {
+                output: [
+                    {
+                        type: "text",
+                        text: `I remember: ${users[0].content.map((part) => (part.type === "text" ? part.text : "")).join(" ")}`,
+                    },
+                ],
+            };
+        return {
+            output: [
+                {
+                    type: "tool-call",
+                    id: "fixture_lookup",
+                    name: "lookup_order",
+                    args: { orderId: "demo-123" },
+                },
+            ],
+        };
+    };
+}