@nylorun/harness 0.5.0-beta.1 → 0.8.0-beta.1

package/dist/build/helpers.d.ts

@@ -1,7 +1,6 @@
 import type { ModelAdapter } from "../types/model.js";
 import type { StepMiddleware } from "../types/middleware.js";
-import type { ToolAdapter, ToolDefinition } from "../types/tool.js";
-export declare const tool: <T extends ToolDefinition>(value: T) => T;
-export declare const adapter: <T extends ToolAdapter>(value: T) => T;
+import type { ToolDefinition, ToolObjectSchema } from "../types/tool.js";
+export declare const tool: <Parameters extends ToolObjectSchema, State = never>(value: ToolDefinition<Parameters, State>) => ToolDefinition<Parameters, State>;
 export declare const model: <T extends ModelAdapter>(value: T) => T;
 export declare const middleware: <T extends StepMiddleware>(value: T) => T;

package/dist/build/helpers.js

@@ -1,5 +1,4 @@
 import { prepareTool } from "./schema.js";
 export const tool = (value) => prepareTool(value);
-export const adapter = (value) => value;
 export const model = (value) => value;
 export const middleware = (value) => value;

package/dist/build/manifest.d.ts

@@ -1,9 +1,7 @@
 import type { AgentManifest } from "../types/manifest.js";
 import type { BoundMiddleware } from "../types/middleware.js";
-import type { ModelDirective } from "../types/model.js";
-import type { AdapterRegistry } from "./adapters.js";
 export declare function createManifest(input: {
+    id: string;
+    name: string;
     middleware: readonly BoundMiddleware[];
-    directive?: ModelDirective;
-    adapters: AdapterRegistry;
 }): AgentManifest;

package/dist/build/manifest.js

@@ -1,15 +1,9 @@
 import { deepFreeze } from "../utils/immutable.js";
 export function createManifest(input) {
     const middleware = input.middleware.map(({ id }) => ({ id }));
-    const adapters = [...input.adapters.entries].map(([, entry]) => ({
-        id: entry.adapter.id,
-        ...(entry.options.maxConcurrentCalls === undefined
-            ? {}
-            : { maxConcurrentCalls: entry.options.maxConcurrentCalls }),
-    }));
     return deepFreeze({
+        id: input.id,
+        name: input.name,
         middleware,
-        ...(input.directive === undefined ? {} : { model: input.directive }),
-        adapters,
     });
 }

package/dist/errors.d.ts

@@ -1,5 +1,5 @@
 /** Machine-readable error raised by Harness-owned code. */
-export type HarnessErrorCode = "adapter.invalid-outcome" | "adapter.not-registered" | "agent.build-failed" | "agent.lifecycle-sealed" | "context.invalid-item" | "context.invalid-item-type" | "context.invalid-order" | "context.invalid-reason" | "context.invalid-slot" | "interaction.invalid" | "interaction.missing-resume" | "interaction.uncorrelated-resume" | "json.invalid-data" | "json.invalid-object" | "middleware.next-after-return" | "middleware.next-called-twice" | "middleware.request-mutators-revoked" | "model.candidate-missing" | "model.invalid-candidate" | "model.invalid-directive" | "configuration.duplicate-tool-name" | "configuration.invalid" | "configuration.invalid-instructions" | "configuration.invalid-order" | "configuration.invalid-reason" | "configuration.invalid-slot" | "configuration.invalid-tools" | "configuration.model-selection-conflict" | "response.invalid-replacement" | "session.stale-result" | "tool.invalid-arguments" | "tool.invalid-name" | "tool.invalid-schema" | "tool.invalid-tool-result";
+export type HarnessErrorCode = "agent.build-failed" | "agent.lifecycle-sealed" | "capability.state.create-failed" | "capability.state.undeclared" | "context.invalid-item" | "context.invalid-item-type" | "context.invalid-order" | "context.invalid-reason" | "context.invalid-slot" | "interaction.invalid" | "interaction.missing-resume" | "interaction.uncorrelated-resume" | "json.invalid-data" | "json.invalid-object" | "middleware.next-after-return" | "middleware.next-called-twice" | "middleware.request-mutators-revoked" | "model.candidate-missing" | "model.invalid-candidate" | "model.invalid-directive" | "configuration.duplicate-tool-name" | "configuration.invalid" | "configuration.invalid-instructions" | "configuration.invalid-order" | "configuration.invalid-reason" | "configuration.invalid-slot" | "configuration.invalid-tools" | "configuration.model-selection-conflict" | "response.invalid-replacement" | "session.invalid-seed" | "session.record-failed" | "session.stale-result" | "tool.invalid" | "tool.invalid-arguments" | "tool.invalid-name" | "tool.invalid-schema" | "tool.invalid-tool-result";
 export type HarnessErrorDetails = Readonly<Record<string, string | number | boolean>>;
 export interface HarnessErrorOptions {
     readonly cause?: unknown;

package/dist/index.d.ts

@@ -1,11 +1,12 @@
-export { Agent, AgentBuilder, AgentBuildError, AgentLifecycleError } from "./build/builder.js";
+export { Agent, AgentBuilder, AgentBuildError, AgentLifecycleError, BoundAgentBuilder, } 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";
 export { BuiltAgent } from "./build/agent.js";
-export { adapter, middleware, model, tool } from "./build/helpers.js";
+export { middleware, model, tool } from "./build/helpers.js";
 export type { AgentManifest } from "./types/manifest.js";
 export type { ModelCandidate, ModelControls, ModelDirective, ModelEvidence, ModelFinishReason, ModelAdapter, ModelAdapterContext, ContextContributor, ContextMutationOptions, ContextSnapshot, ModelCall, ModelCallTool, ModelOutputBlock, PromptContentPart, PromptItem, ModelConfigurationContributor, ModelConfigurationInstruction, ModelConfigurationMutationOptions, ModelConfigurationSnapshot, ModelConfigurationTool, ModelRequest, ModelToolCall, ModelUsage, } from "./types/model.js";
-export type { BoundMiddleware, StepInput, StepMiddleware, StepRequest, StepResponse, } from "./types/middleware.js";
-export type { BuildDiagnostic, ContextItem, JsonObject, JsonPrimitive, JsonValue, ObserveEvent, ObserveModelConfigurationSnapshot, ObserveModelRequested, ObserveSealedCall, ObserveToolSnapshot, Observer, Tripwire, } from "./types/shared.js";
-export type { InteractionReply, InputCompletion, InputEvent, InputHandle, InputOptions, MessageInput, Session, SessionInput, SessionEvent, SessionOptions, SessionSnapshot, TranscriptEntry, } from "./types/session.js";
-export type { BoundToolSchema, BoundToolDefinition, Interaction, PreflightOutcome, RequiredInteraction, SealedToolCall, ToolAdapter, AdapterExecutionOptions, ToolContent, ToolDefinition, ToolExecutionResume, ToolObjectSchema, ToolOutcome, ToolResult, } from "./types/tool.js";
+export type { BoundMiddleware, CapabilityDeclaration, CapabilityItems, CapabilityState, StepInput, StepMiddleware, StepRequest, StepResponse, } from "./types/middleware.js";
+export type { BuildDiagnostic, ContextItem, DeferredOutcome, JsonObject, JsonPrimitive, JsonValue, ObserveEvent, ObserveModelConfigurationSnapshot, ObserveModelRequested, ObserveSealedCall, ObserveToolSnapshot, Observer, Tripwire, } from "./types/shared.js";
+export type { ActiveExecutionRecord, ActiveInteractionExecutionRecord, ActiveModelExecutionRecord, ActiveToolCallRecord, ActiveToolsExecutionRecord, InteractionReply, InputCompletion, InputEvent, InputHandle, InputOptions, MessageInput, Session, SessionInput, SessionIdentity, SessionEvent, SessionOptions, SessionRecord, SessionRecorder, SessionRunOptions, SessionSeed, SeededSessionOptions, SessionSnapshot, TranscriptEntry, } from "./types/session.js";
+export type { BoundToolSchema, BoundToolDefinition, Interaction, RequiredInteraction, SealedToolCall, ToolContent, ToolDefinition, ToolExecutionContext, ToolExecutionResume, ToolObjectSchema, ToolOwner, ToolOutcome, ToolResult, } from "./types/tool.js";

package/dist/index.js

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

package/dist/session/capability-state.d.ts

@@ -0,0 +1,14 @@
+import type { BoundMiddleware } from "../types/middleware.js";
+import type { SessionIdentity } from "../types/session.js";
+import type { ObserveEmit } from "../utils/observe.js";
+/** Owns declared, process-local state for exactly one Session. */
+export declare class CapabilityStateRegistry {
+    #private;
+    private readonly session;
+    private readonly observe;
+    constructor(middleware: readonly BoundMiddleware[], session: SessionIdentity, observe: ObserveEmit);
+    has(id: string): boolean;
+    get(id: string): Promise<unknown>;
+    abort(reason: unknown): void;
+    shutdown(reason: unknown): Promise<void>;
+}

package/dist/session/capability-state.js

@@ -0,0 +1,67 @@
+import { HarnessError } from "../errors.js";
+/** Owns declared, process-local state for exactly one Session. */
+export class CapabilityStateRegistry {
+    session;
+    observe;
+    #entries = new Map();
+    #controller = new AbortController();
+    #shutdown;
+    constructor(middleware, session, observe) {
+        this.session = session;
+        this.observe = observe;
+        for (const middlewareEntry of middleware) {
+            if (middlewareEntry.state)
+                this.#entries.set(middlewareEntry.id, {
+                    id: middlewareEntry.id,
+                    state: middlewareEntry.state,
+                });
+        }
+    }
+    has(id) {
+        return this.#entries.has(id);
+    }
+    get(id) {
+        const entry = this.#entries.get(id);
+        if (!entry)
+            return Promise.reject(new HarnessError("capability.state.undeclared", `Capability '${id}' did not declare session state`));
+        if (!entry.promise) {
+            entry.promise = Promise.resolve()
+                .then(() => entry.state.create(this.session, this.#controller.signal))
+                .then((value) => {
+                entry.value = value;
+                entry.created = true;
+                return value;
+            }, (cause) => {
+                throw new HarnessError("capability.state.create-failed", `Capability '${id}' failed to create session state`, { cause });
+            });
+        }
+        return entry.promise;
+    }
+    abort(reason) {
+        this.#controller.abort(reason);
+    }
+    shutdown(reason) {
+        if (this.#shutdown)
+            return this.#shutdown;
+        this.abort(reason);
+        this.#shutdown = (async () => {
+            const created = [...this.#entries.values()].filter((entry) => entry.promise);
+            await Promise.allSettled(created.map((entry) => entry.promise));
+            for (const entry of [...created].reverse()) {
+                if (!entry.created || !entry.state.dispose)
+                    continue;
+                try {
+                    await entry.state.dispose(entry.value);
+                }
+                catch (error) {
+                    this.observe({
+                        type: "capability.state.dispose.failed",
+                        capabilityId: entry.id,
+                        attributes: { message: error instanceof Error ? error.message : String(error) },
+                    });
+                }
+            }
+        })();
+        return this.#shutdown;
+    }
+}

package/dist/session/input-queue.d.ts

@@ -1,11 +1,19 @@
 import type { InputEvent, InputOptions } from "../types/session.js";
 import { SubmissionStream } from "./submission-stream.js";
+export type WorkEvent = InputEvent | {
+    readonly kind: "continue";
+};
 export interface QueuedInput {
-    readonly event: InputEvent;
+    readonly event: WorkEvent;
     readonly options?: InputOptions;
     readonly stream: SubmissionStream;
     cancelled: boolean;
 }
+export type QueuedInterrupt = Omit<QueuedInput, "event"> & {
+    readonly event: Extract<InputEvent, {
+        kind: "interrupt";
+    }>;
+};
 export interface QueueAbortHandlers {
     readonly isActive: () => boolean;
     readonly abortActive: (reason: unknown) => void;
@@ -15,13 +23,14 @@ export declare function isInteractionReply(event: InputEvent): event is Extract<
     kind: "approve" | "respond";
 }>;
 export declare function snapshotInput(event: InputEvent): InputEvent;
+export declare function snapshotWork(event: WorkEvent): WorkEvent;
 /** Serializes ordinary input while allowing a matching interaction reply to resume immediately. */
 export declare class InputQueue {
     private readonly values;
     get size(): number;
     add(input: QueuedInput, priority?: boolean): void;
     take(waitingForInteraction: boolean): QueuedInput | undefined;
-    takeInterrupts(): QueuedInput[];
+    takeInterrupts(): QueuedInterrupt[];
     remove(input: QueuedInput): boolean;
     drain(): readonly QueuedInput[];
 }

package/dist/session/input-queue.js

@@ -18,6 +18,9 @@ export function snapshotInput(event) {
             return Object.freeze({ ...event, value: copyJson(event.value) });
     }
 }
+export function snapshotWork(event) {
+    return event.kind === "continue" ? Object.freeze({ kind: "continue" }) : snapshotInput(event);
+}
 /** Serializes ordinary input while allowing a matching interaction reply to resume immediately. */
 export class InputQueue {
     values = [];
@@ -32,7 +35,8 @@ export class InputQueue {
     }
     take(waitingForInteraction) {
         const next = this.values[0];
-        if (!next || (waitingForInteraction && !isInteractionReply(next.event)))
+        if (!next ||
+            (waitingForInteraction && (next.event.kind === "continue" || !isInteractionReply(next.event))))
             return undefined;
         return this.values.shift();
     }

package/dist/session/record.d.ts

@@ -0,0 +1,11 @@
+import type { ActiveExecutionRecord, SessionRecord, SessionSnapshot } from "../types/session.js";
+import type { JsonObject } from "../types/shared.js";
+export declare function sessionRecord(input: {
+    readonly state: SessionSnapshot;
+    readonly transition: SessionRecord["transition"];
+    readonly session: Readonly<{
+        readonly userId?: string;
+        readonly context?: JsonObject;
+    }>;
+    readonly active?: ActiveExecutionRecord;
+}): SessionRecord;

package/dist/session/record.js

@@ -0,0 +1,26 @@
+import { copyJson } from "../utils/immutable.js";
+export function sessionRecord(input) {
+    const value = {
+        version: 1,
+        revision: input.state.revision,
+        transition: input.transition,
+        session: {
+            id: input.state.id,
+            ...(input.session.userId === undefined ? {} : { userId: input.session.userId }),
+            ...(input.session.context === undefined ? {} : { context: copyJson(input.session.context) }),
+            turnCount: input.state.turnCount,
+            status: input.state.status,
+        },
+        transcript: copyJson(input.state.transcript),
+        ...(input.active === undefined ? {} : { active: copyJson(input.active) }),
+    };
+    return deepFreeze(value);
+}
+function deepFreeze(value, seen = new WeakSet()) {
+    if (!value || typeof value !== "object" || seen.has(value))
+        return value;
+    seen.add(value);
+    for (const child of Object.values(value))
+        deepFreeze(child, seen);
+    return Object.freeze(value);
+}

package/dist/session/scheduler.d.ts

@@ -1,8 +1,9 @@
-import type { InputEvent, InputOptions, SessionSnapshot } from "../types/session.js";
+import type { InputEvent, InputOptions, SessionRecorder, SessionSnapshot } from "../types/session.js";
 import type { Observer } from "../types/shared.js";
 import { SessionEventLog } from "./event-log.js";
 import { SubmissionStream } from "./submission-stream.js";
 import { type LoopAgent } from "../build/agent.js";
+import type { NormalizedSessionSeed } from "./seed.js";
 /** Coordinates one active turn at a time; TurnRunner owns the turn's internal state machine. */
 export declare class SessionScheduler {
     readonly id: string;
@@ -16,18 +17,29 @@ export declare class SessionScheduler {
     private pending?;
     private inFlightPlan?;
     private running;
+    private stopping;
     private stopped;
+    private suspended;
     private generation;
     private stopPromise?;
+    private recordFailure?;
     private readonly observers;
     private readonly turns;
+    private readonly states;
     constructor(id: string, agent: LoopAgent, session: Readonly<{
         readonly userId?: string;
         readonly context?: import("../types/shared.js").JsonObject;
-    }>);
+    }>, options?: {
+        readonly seed?: NormalizedSessionSeed;
+        readonly recorder?: SessionRecorder;
+    });
+    private readonly session;
+    private readonly recorder?;
     get snapshot(): SessionSnapshot;
     observe(listener: Observer): () => void;
     submit(event: InputEvent, options?: InputOptions): SubmissionStream;
+    continue(options?: InputOptions): SubmissionStream;
+    private submitWork;
     stop(reason?: string): Promise<void>;
     private enqueueReply;
     private enqueueOrdinaryInput;
@@ -40,9 +52,11 @@ export declare class SessionScheduler {
     private run;
     private resumeTurn;
     private applyTurnOutcome;
-    private beginStop;
     private emitObserve;
     private commitCancelledPlan;
     private claimInterrupts;
+    private commit;
+    private assertRecordable;
+    private failRecording;
     private assertCurrent;
 }