@nylorun/harness 0.11.1-beta → 0.12.0-beta

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.12.0-beta
+
+### Minor Changes
+
+- 4badb5b: Move model execution to session startup, provide Runtime as a mountable Hono router, and generate Hono-first projects with supervised application and Studio development. Studio now resolves root-relative Runtime endpoints correctly for custom mount paths.
+
 ## 0.11.1-beta
 
 ### Patch Changes

package/dist/build/agent.d.ts

@@ -7,12 +7,11 @@ export interface LoopAgent {
     readonly invoke: ModelAdapter;
 }
 export declare class BuiltAgent {
-    #private;
     readonly middleware: readonly BoundMiddleware[];
     readonly manifest: AgentManifest;
     readonly id: string;
     readonly name: string;
     private constructor();
-    run(options?: SessionRunOptions): Session;
+    run(options: SessionRunOptions): Session;
 }
-export declare function bindAgent(middleware: readonly BoundMiddleware[], invoke: ModelAdapter, manifest: AgentManifest): BuiltAgent;
+export declare function bindAgent(middleware: readonly BoundMiddleware[], manifest: AgentManifest): BuiltAgent;

package/dist/build/agent.js

@@ -7,21 +7,16 @@ export class BuiltAgent {
     manifest;
     id;
     name;
-    #loopAgent;
-    constructor(middleware, invoke, manifest) {
+    constructor(middleware, manifest) {
         this.middleware = middleware;
         this.manifest = manifest;
         this.id = manifest.id;
         this.name = manifest.name;
-        this.#loopAgent = Object.freeze({
-            middleware,
-            invoke,
-        });
     }
     static {
-        createBoundAgent = (middleware, invoke, manifest) => new BuiltAgent(middleware, invoke, manifest);
+        createBoundAgent = (middleware, manifest) => new BuiltAgent(middleware, manifest);
     }
-    run(options = {}) {
+    run(options) {
         const seeded = "seed" in options && options.seed !== undefined;
         if (seeded &&
             (("id" in options && options.id !== undefined) ||
@@ -29,9 +24,9 @@ export class BuiltAgent {
                 ("context" in options && options.context !== undefined)))
             throw new HarnessError("session.invalid-seed", "Seeded run options cannot include id, userId, or context outside the seed");
         const id = (seeded ? options.seed.id : "id" in options ? options.id : undefined) ?? createId("session");
-        return new LiveSession(id, this.#loopAgent, options);
+        return new LiveSession(id, Object.freeze({ middleware: this.middleware, invoke: options.onModelCall }), options);
     }
 }
-export function bindAgent(middleware, invoke, manifest) {
-    return createBoundAgent(middleware, invoke, manifest);
+export function bindAgent(middleware, manifest) {
+    return createBoundAgent(middleware, manifest);
 }

package/dist/build/assemble.d.ts

@@ -1,8 +1,7 @@
 import type { BuildResult } from "../types/manifest.js";
 import type { BoundMiddleware } from "../types/middleware.js";
-import type { ModelAdapter } from "../types/model.js";
 import { type BuiltAgent } from "./agent.js";
-export declare function assembleAgent(middleware: readonly BoundMiddleware[], invoke: ModelAdapter, identity: Readonly<{
+export declare function assembleAgent(middleware: readonly BoundMiddleware[], identity: Readonly<{
     id: string;
     name: string;
 }>): BuildResult<BuiltAgent>;

package/dist/build/assemble.js

@@ -1,7 +1,7 @@
 import { bindAgent } from "./agent.js";
 import { createManifest } from "./manifest.js";
 const diagnostic = (code, message, extra = {}) => Object.freeze({ code, message, ...extra });
-export function assembleAgent(middleware, invoke, identity) {
+export function assembleAgent(middleware, identity) {
     const diagnostics = [];
     if (typeof identity.id !== "string" || identity.id.length === 0) {
         diagnostics.push(diagnostic("agent.invalid-id", "Agent id must be a non-empty string"));
@@ -9,9 +9,6 @@ export function assembleAgent(middleware, invoke, identity) {
     if (typeof identity.name !== "string" || identity.name.length === 0) {
         diagnostics.push(diagnostic("agent.invalid-name", "Agent name must be a non-empty string"));
     }
-    if (typeof invoke !== "function") {
-        diagnostics.push(diagnostic("harness.invalid-model", "A model invoke function is required"));
-    }
     const middlewareIds = new Set();
     const frozen = [];
     for (const item of middleware) {
@@ -39,6 +36,6 @@ export function assembleAgent(middleware, invoke, identity) {
         name: identity.name,
         middleware: frozenMiddleware,
     });
-    const agent = bindAgent(frozenMiddleware, invoke, manifest);
+    const agent = bindAgent(frozenMiddleware, manifest);
     return Object.freeze({ ok: true, agent, manifest });
 }

package/dist/build/builder.d.ts

@@ -1,5 +1,4 @@
 import type { BoundMiddleware, CapabilityDeclaration, StepMiddleware } from "../types/middleware.js";
-import type { ModelAdapter } from "../types/model.js";
 import type { BuildDiagnostic } from "../types/shared.js";
 import { HarnessError } from "../errors.js";
 import type { BuiltAgent } from "./agent.js";
@@ -12,8 +11,6 @@ interface BuilderState {
     readonly id: string;
     readonly name: string;
     readonly middleware: BoundMiddleware[];
-    invoke?: ModelAdapter;
-    bound: boolean;
     sealed: boolean;
     agent?: BuiltAgent;
     error?: AgentBuildError;
@@ -33,14 +30,9 @@ export declare class AgentBuilder {
     use(middleware: StepMiddleware): this;
     use(id: string, middleware: StepMiddleware): this;
     use<State>(declaration: CapabilityDeclaration<State>): this;
-    with(onModelCall: ModelAdapter): BoundAgentBuilder;
+    build(): BuiltAgent;
     private nextMiddlewareId;
     private push;
     private assertOpen;
 }
-export declare class BoundAgentBuilder {
-    private readonly state;
-    constructor(state: BuilderState);
-    build(): BuiltAgent;
-}
 export {};

package/dist/build/builder.js

@@ -30,45 +30,13 @@ export class AgentBuilder {
             return this.push(compileDeclaration(idOrMiddleware));
         return this.push({ id: idOrMiddleware, handle: middleware });
     }
-    with(onModelCall) {
-        this.assertOpen("with()");
-        this.state.bound = true;
-        this.state.invoke = onModelCall;
-        return new BoundAgentBuilder(this.state);
-    }
-    nextMiddlewareId() {
-        const taken = new Set(this.state.middleware.map((item) => item.id));
-        let id;
-        do {
-            this.state.middlewareSeq += 1;
-            id = `middleware-${this.state.middlewareSeq}`;
-        } while (taken.has(id));
-        return id;
-    }
-    push(entry) {
-        this.assertOpen("build()");
-        this.state.middleware.push(entry);
-        return this;
-    }
-    assertOpen(after) {
-        if (this.state.bound)
-            throw new AgentLifecycleError("AgentBuilder cannot be changed after with()");
-        if (this.state.sealed)
-            throw new AgentLifecycleError(`AgentBuilder cannot be changed after ${after}`);
-    }
-}
-export class BoundAgentBuilder {
-    state;
-    constructor(state) {
-        this.state = state;
-    }
     build() {
         if (this.state.agent)
             return this.state.agent;
         if (this.state.error)
             throw this.state.error;
         this.state.sealed = true;
-        const result = assembleAgent(this.state.middleware, this.state.invoke, {
+        const result = assembleAgent(this.state.middleware, {
             id: this.state.id,
             name: this.state.name,
         });
@@ -79,6 +47,24 @@ export class BoundAgentBuilder {
         this.state.agent = result.agent;
         return this.state.agent;
     }
+    nextMiddlewareId() {
+        const taken = new Set(this.state.middleware.map((item) => item.id));
+        let id;
+        do {
+            this.state.middlewareSeq += 1;
+            id = `middleware-${this.state.middlewareSeq}`;
+        } while (taken.has(id));
+        return id;
+    }
+    push(entry) {
+        this.assertOpen();
+        this.state.middleware.push(entry);
+        return this;
+    }
+    assertOpen() {
+        if (this.state.sealed)
+            throw new AgentLifecycleError("AgentBuilder cannot be changed after build()");
+    }
 }
 function createState(options) {
     const middleware = [];
@@ -90,7 +76,6 @@ function createState(options) {
         id: options.id,
         name: options.name,
         middleware,
-        bound: false,
         sealed: false,
         middlewareSeq: 0,
     };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { Agent, AgentBuilder, AgentBuildError, AgentLifecycleError, BoundAgentBuilder, } from "./build/builder.js";
+export { Agent, AgentBuilder, AgentBuildError, AgentLifecycleError } from "./build/builder.js";
 export type { AgentOptions } from "./build/builder.js";
 export { HarnessError, isHarnessError } from "./errors.js";
 export type { HarnessErrorCode, HarnessErrorDetails, HarnessErrorOptions } from "./errors.js";

package/dist/index.js

@@ -1,4 +1,4 @@
-export { Agent, AgentBuilder, AgentBuildError, AgentLifecycleError, BoundAgentBuilder, } from "./build/builder.js";
+export { Agent, AgentBuilder, AgentBuildError, AgentLifecycleError } from "./build/builder.js";
 export { HarnessError, isHarnessError } from "./errors.js";
 export { BuiltAgent } from "./build/agent.js";
 export { middleware, model, tool } from "./build/helpers.js";

package/dist/session/scheduler.d.ts

@@ -23,7 +23,6 @@ export declare class SessionScheduler {
     private generation;
     private stopPromise?;
     private recordFailure?;
-    private readonly observers;
     private readonly turns;
     private readonly states;
     constructor(id: string, agent: LoopAgent, session: Readonly<{
@@ -32,11 +31,12 @@ export declare class SessionScheduler {
     }>, options?: {
         readonly seed?: NormalizedSessionSeed;
         readonly recorder?: SessionRecorder;
+        readonly observer?: Observer;
     });
     private readonly session;
     private readonly recorder?;
+    private readonly observer?;
     get snapshot(): SessionSnapshot;
-    observe(listener: Observer): () => void;
     submit(event: InputEvent, options?: InputOptions): SubmissionStream;
     continue(options?: InputOptions): SubmissionStream;
     private submitWork;

package/dist/session/scheduler.js

@@ -1,6 +1,6 @@
 import { HarnessError } from "../errors.js";
 import { createId } from "../utils/ids.js";
-import { createObserverRegistry } from "../utils/observe.js";
+import { emitObserve } from "../utils/observe.js";
 import { InputQueue, isInteractionReply, snapshotWork, watchInputAbort, } from "./input-queue.js";
 import { SessionEventLog } from "./event-log.js";
 import { SubmissionStream } from "./submission-stream.js";
@@ -28,7 +28,6 @@ export class SessionScheduler {
     generation = 0;
     stopPromise;
     recordFailure;
-    observers = createObserverRegistry();
     turns;
     states;
     constructor(id, agent, session, options = {}) {
@@ -37,6 +36,7 @@ export class SessionScheduler {
         this.turns = new TurnRunner(agent, id, session);
         this.session = session;
         this.recorder = options.recorder;
+        this.observer = options.observer;
         this.states = new CapabilityStateRegistry(agent.middleware, Object.freeze({ id, ...session }), (event) => this.emitObserve(event));
         if (options.seed) {
             const event = Object.freeze({
@@ -44,24 +44,15 @@ export class SessionScheduler {
                 revision: options.seed.revision,
                 transcriptEntries: options.seed.transcript.length,
             });
-            // Construction precedes public observer registration. Defer this live-only fact
-            // by one microtask so callers can subscribe immediately after run({ seed }).
-            queueMicrotask(() => {
-                if (!this.stopped)
-                    this.emitObserve(event);
-            });
+            this.emitObserve(event);
         }
     }
     session;
     recorder;
+    observer;
     get snapshot() {
         return this.snapshotValue;
     }
-    observe(listener) {
-        if (this.stopped)
-            return () => undefined;
-        return this.observers.observe(listener);
-    }
     submit(event, options) {
         return this.submitWork(event, options);
     }
@@ -130,7 +121,6 @@ export class SessionScheduler {
             }
             this.emitObserve({ type: "session.stopped", reason });
             await this.states.shutdown(stopError);
-            this.observers.clear();
         })();
         return this.stopPromise;
     }
@@ -377,7 +367,7 @@ export class SessionScheduler {
         }
     }
     emitObserve(event) {
-        this.observers.emit(event);
+        emitObserve(this.observer, event);
     }
     async commitCancelledPlan(pending, reason) {
         this.snapshotValue = await this.commit(commitToolResults(this.snapshotValue, pending.turnId, pending.stepId, pending.plan.cancelledResults(reason)), "tool-results");

package/dist/session/session.d.ts

@@ -1,6 +1,6 @@
 import type { InputHandle, InputOptions, MessageInput, Session, SessionEvent, SessionRunOptions, SessionSnapshot, SessionInput } from "../types/session.js";
 import type { ToolSchemaSource } from "../types/tool.js";
-import type { JsonValue, Observer } from "../types/shared.js";
+import type { JsonValue } from "../types/shared.js";
 import type { LoopAgent } from "../build/agent.js";
 export declare class LiveSession implements Session {
     readonly id: string;
@@ -13,6 +13,5 @@ export declare class LiveSession implements Session {
     interrupt(event: MessageInput, options?: InputOptions): InputHandle<any>;
     continue(options?: InputOptions): InputHandle<any>;
     stream(): AsyncIterable<SessionEvent<JsonValue>>;
-    observe(listener: Observer): () => void;
     stop(reason?: string): Promise<void>;
 }

package/dist/session/session.js

@@ -20,6 +20,7 @@ export class LiveSession {
         this.scheduler = new SessionScheduler(id, agent, session, {
             ...(seed === undefined ? {} : { seed }),
             ...(options.recorder === undefined ? {} : { recorder: options.recorder }),
+            ...(options.observer === undefined ? {} : { observer: options.observer }),
         });
     }
     get state() {
@@ -43,9 +44,6 @@ export class LiveSession {
     stream() {
         return this.scheduler.events;
     }
-    observe(listener) {
-        return this.scheduler.observe(listener);
-    }
     stop(reason) {
         return this.scheduler.stop(reason);
     }

package/dist/turn/plan-runner.d.ts

@@ -1,4 +1,5 @@
 import type { ObserveEmit } from "../utils/observe.js";
+import type { ModelAdapter } from "../types/model.js";
 import type { InputEvent } from "../types/session.js";
 import type { ActiveInteractionExecutionRecord, ActiveToolsExecutionRecord } from "../types/session.js";
 import type { RequiredInteraction, ToolExecutionResume, ToolResult } from "../types/tool.js";
@@ -33,6 +34,7 @@ export interface ToolPlanRunContext {
         readonly stepId: string;
     };
     readonly states?: CapabilityStateRegistry;
+    readonly onModelCall: ModelAdapter;
 }
 /** Owns one sealed plan's deterministic interaction and concurrent execution progress. */
 export declare class ToolPlanRunner {

package/dist/turn/plan-runner.js

@@ -179,6 +179,7 @@ export class ToolPlanRunner {
                 callId: entry.call.callId,
                 invocationId: entry.invocationId,
                 signal: context.signal,
+                onModelCall: context.onModelCall,
                 resume: this.takeResume(entry.call.callId),
             };
             if (context.states?.has(entry.owner.middlewareId))

package/dist/turn/runner.js

@@ -150,6 +150,7 @@ export class TurnRunner {
             observe: context.observe,
             ids: { sessionId: this.sessionId, turnId: pending.turnId, stepId: pending.stepId },
             states: context.states,
+            onModelCall: this.agent.invoke,
         }, resume);
         context.assertCurrent();
         context.onPlanActive(undefined);

package/dist/types/session.d.ts

@@ -1,4 +1,4 @@
-import type { ModelCall, ModelCandidate } from "./model.js";
+import type { ModelAdapter, ModelCall, ModelCandidate } from "./model.js";
 import type { JsonObject, JsonValue, Observer, Tripwire } from "./shared.js";
 import type { RequiredInteraction, SchemaOutput, ToolExecutionResume, ToolOwner, ToolResult, ToolSchemaSource } from "./tool.js";
 export type InputEvent = {
@@ -70,11 +70,13 @@ export interface InputHandle<Output = string> {
     readonly completed: Promise<InputCompletion<Output>>;
 }
 export interface SessionOptions {
+    readonly onModelCall: ModelAdapter;
     readonly id?: string;
     readonly userId?: string;
     readonly context?: JsonObject;
     readonly seed?: never;
     readonly recorder?: SessionRecorder;
+    readonly observer?: Observer;
 }
 /** Stable host-owned facts available while a capability creates session-local state. */
 export interface SessionIdentity {
@@ -83,8 +85,10 @@ export interface SessionIdentity {
     readonly context?: JsonObject;
 }
 export interface SeededSessionOptions {
+    readonly onModelCall: ModelAdapter;
     readonly seed: SessionSeed;
     readonly recorder?: SessionRecorder;
+    readonly observer?: Observer;
     readonly id?: never;
     readonly userId?: never;
     readonly context?: never;
@@ -222,6 +226,5 @@ export interface Session {
     interrupt(event: MessageInput, options?: InputOptions): InputHandle;
     continue(options?: InputOptions): InputHandle;
     stream(): AsyncIterable<SessionEvent<JsonValue>>;
-    observe(listener: Observer): () => void;
     stop(reason?: string): Promise<void>;
 }

package/dist/types/tool.d.ts

@@ -1,5 +1,6 @@
 import type { ZodType } from "zod";
 import type { DeferredOutcome, JsonObject, JsonValue } from "./shared.js";
+import type { ModelAdapter } from "./model.js";
 export interface SchemaIssue {
     readonly path: readonly (string | number)[];
     readonly code: string;
@@ -90,6 +91,8 @@ interface ToolExecutionContextBase {
     readonly callId: string;
     readonly invocationId: string;
     readonly signal: AbortSignal;
+    /** The session's model callable, for tools that explicitly run a child agent. */
+    readonly onModelCall?: ModelAdapter;
     readonly resume?: ToolExecutionResume;
 }
 export type ToolExecutionContext<State = never> = ToolExecutionContextBase & ([State] extends [never] ? object : {

package/dist/utils/observe.d.ts

@@ -1,8 +1,3 @@
 import type { ObserveEvent, Observer } from "../types/shared.js";
 export type ObserveEmit = (event: ObserveEvent | (() => ObserveEvent)) => void;
-export interface ObserverRegistry {
-    observe(listener: Observer): () => void;
-    emit(event: ObserveEvent | (() => ObserveEvent)): void;
-    clear(): void;
-}
-export declare function createObserverRegistry(): ObserverRegistry;
+export declare function emitObserve(listener: Observer | undefined, event: ObserveEvent | (() => ObserveEvent)): void;

package/dist/utils/observe.js

@@ -1,29 +1,13 @@
-export function createObserverRegistry() {
-    const listeners = new Set();
-    return {
-        observe(listener) {
-            listeners.add(listener);
-            return () => listeners.delete(listener);
-        },
-        emit(event) {
-            if (listeners.size === 0)
-                return;
-            const resolved = typeof event === "function" ? event() : event;
-            const snapshot = Object.freeze({ ...resolved });
-            for (const listener of [...listeners]) {
-                try {
-                    const result = listener(snapshot);
-                    if (result && typeof result.then === "function") {
-                        void Promise.resolve(result).catch(() => undefined);
-                    }
-                }
-                catch {
-                    // Observation is deliberately fail-open.
-                }
-            }
-        },
-        clear() {
-            listeners.clear();
-        },
-    };
+export function emitObserve(listener, event) {
+    if (!listener)
+        return;
+    const snapshot = Object.freeze({ ...(typeof event === "function" ? event() : event) });
+    try {
+        const result = listener(snapshot);
+        if (result && typeof result.then === "function")
+            void Promise.resolve(result).catch(() => undefined);
+    }
+    catch {
+        // Observation is deliberately fail-open.
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nylorun/harness",
-  "version": "0.11.1-beta",
+  "version": "0.12.0-beta",
   "description": "Nylorun's TypeScript agent runtime. See github.com/nylorun/harness.",
   "type": "module",
   "license": "Apache-2.0",
@@ -59,11 +59,11 @@
     "prepack": "npm run build"
   },
   "devDependencies": {
-    "@types/node": "^22.18.0",
+    "@types/node": "^26.5.0",
     "@typescript/native": "npm:typescript@^7.0.2",
     "prettier": "^3.9.6",
     "typescript": "npm:@typescript/typescript6@^6.0.2",
-    "vitest": "^4.1.11",
+    "vitest": "^5.0.0",
     "zod": "^4.1.12"
   },
   "peerDependencies": {