@nylorun/harness 0.13.0-beta → 0.16.0-beta

package/dist/{execution → loop}/state.js

@@ -1,9 +1,9 @@
 import { z } from "zod";
-import { HarnessError } from "../errors.js";
-import { assertJson, copyJson } from "../utils/immutable.js";
+import { HarnessError } from "@nylorun/core/define";
+import { assertJson, copyJson } from "@nylorun/core/define";
 import { definitionFor } from "../definition/agent-definition.js";
 import { initializeExecutionState } from "./initial-state.js";
-import { validateTranscript } from "../execution/transcript.js";
+import { validateTranscript } from "./transcript.js";
 const id = z.string().min(1);
 const json = z.unknown().refine((value) => {
     try {
@@ -74,12 +74,21 @@ const call = z
     ])
         .optional(),
     token: json.optional(),
+    wait: z
+        .object({
+        kind: z.enum(["ask", "approve", "sleep", "waitFor"]),
+        waitId: id,
+        name: z.string().optional(),
+    })
+        .strict()
+        .optional(),
 })
     .strict();
 const schema = z
     .object({
     version: z.literal(1),
     agentId: id,
+    manifestHash: id.optional(),
     executionId: id,
     outputContract: z.record(z.string(), json).optional(),
     revision: z.number().int().nonnegative(),
@@ -87,6 +96,7 @@ const schema = z
     transcript: z.array(json),
     status: z.enum(["ready", "active", "completed", "paused", "cancelled", "failed"]),
     cancelledCalls: z.array(call).optional(),
+    state: z.record(z.string(), json).optional(),
     plan: z
         .object({
         turnId: id,

package/dist/{execution → loop}/step/canonicalize.d.ts

@@ -1,5 +1,5 @@
-import type { ModelCandidate, ModelOutputBlock, ModelToolCall } from "../../types/model.js";
-import type { JsonObject } from "../../types/shared.js";
+import type { ModelCandidate, ModelOutputBlock, ModelToolCall } from "@nylorun/core/define";
+import type { JsonObject } from "@nylorun/core/define";
 export interface CanonicalCall {
     readonly id: string;
     readonly name: string;

package/dist/{execution → loop}/step/canonicalize.js

@@ -1,5 +1,5 @@
 import { createId } from "../../utils/ids.js";
-import { copyJson } from "../../utils/immutable.js";
+import { copyJson } from "@nylorun/core/define";
 export function canonicalizeCalls(calls) {
     const idCounts = new Map();
     for (const call of calls) {

package/dist/{execution → loop}/step/compose.d.ts

@@ -1,5 +1,5 @@
-import type { BoundMiddleware } from "../../definition/bound.js";
-import type { StepResponse } from "../../types/middleware.js";
+import type { BoundMiddleware } from "@nylorun/core/define";
+import type { StepResponse } from "@nylorun/core/define";
 import type { ObserveEmit } from "../observe.js";
 import { StepContext } from "./step-context.js";
 export declare function runMiddleware(middleware: readonly BoundMiddleware[], context: StepContext, terminal: () => Promise<StepResponse>, observe: ObserveEmit): Promise<StepResponse>;

package/dist/{execution → loop}/step/compose.js

@@ -1,4 +1,5 @@
-import { HarnessError, isHarnessError } from "../../errors.js";
+import { HostSuspension } from "../host-suspension.js";
+import { HarnessError, isHarnessError } from "@nylorun/core/define";
 import { isBrandedResponse, StepContext } from "./step-context.js";
 export async function runMiddleware(middleware, context, terminal, observe) {
     const dispatch = async (index) => {
@@ -49,6 +50,8 @@ export async function runMiddleware(middleware, context, terminal, observe) {
                     handlerError ??= error;
                 }
             }
+            if (handlerError instanceof HostSuspension)
+                throw handlerError;
             if (handlerError) {
                 if (nextCalledTwice ||
                     (isHarnessError(handlerError) && handlerError.code === "middleware.next-called-twice")) {

package/dist/{execution → loop}/step/context-draft.d.ts

@@ -1,5 +1,5 @@
-import type { ContextMutationOptions, ContextSnapshot } from "../../types/model.js";
-import type { ContextItem } from "../../types/shared.js";
+import type { ContextMutationOptions, ContextSnapshot } from "@nylorun/core/define";
+import type { ContextItem } from "@nylorun/core/define";
 /** Per-step model-visible context supplied explicitly by middleware. */
 export declare class ContextDraft {
     #private;

package/dist/{execution → loop}/step/context-draft.js

@@ -1,5 +1,5 @@
-import { HarnessError } from "../../errors.js";
-import { copyJson } from "../../utils/immutable.js";
+import { HarnessError } from "@nylorun/core/define";
+import { copyJson } from "@nylorun/core/define";
 import { SlotDraft } from "./slot-assembly.js";
 const CONTEXT_TYPE = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/;
 /** Per-step model-visible context supplied explicitly by middleware. */

package/dist/{execution → loop}/step/describe.d.ts

@@ -1,6 +1,6 @@
-import type { ModelConfigurationSnapshot } from "../../types/model.js";
-import type { ToolDescriptor } from "../../types/tool.js";
-import type { BoundToolDefinition } from "../../definition/bound.js";
+import type { ModelConfigurationSnapshot } from "@nylorun/core/define";
+import type { ToolDescriptor } from "@nylorun/core/define";
+import type { BoundToolDefinition } from "@nylorun/core/define";
 /** Executable configuration stays inside the invocation. */
 export interface InternalModelConfigurationSnapshot extends Omit<ModelConfigurationSnapshot, "tools"> {
     readonly tools: readonly BoundToolDefinition[];

package/dist/{execution → loop}/step/describe.js

@@ -1,4 +1,4 @@
-import { copyJson } from "../../utils/immutable.js";
+import { copyJson } from "@nylorun/core/define";
 export function describeTool(tool) {
     return copyJson({
         name: tool.name,

package/dist/loop/step/dynamics.d.ts

@@ -0,0 +1,29 @@
+import type { AgentDefinition } from "../../definition/agent-definition.js";
+import type { Decision } from "@nylorun/core/define";
+import type { JsonValue } from "@nylorun/core/define";
+import type { PromptItem } from "@nylorun/core/define";
+import type { InputEvent } from "@nylorun/core/define";
+import type { ModelConfigurationDraft } from "./model-configuration.js";
+export interface DynamicsContext {
+    readonly agent: AgentDefinition;
+    readonly info?: unknown;
+    readonly step: number;
+    readonly arrivals: readonly InputEvent[];
+    readonly messages: readonly PromptItem[];
+    sessionState: Record<string, JsonValue>;
+}
+/** Run all beforeModelCall handlers in capability `.use()` order. */
+export declare function applyBeforeModelCall(ctx: DynamicsContext, configuration: ModelConfigurationDraft): Promise<{
+    readonly blocked?: string;
+}>;
+/** Run all afterModelCall handlers; merge with strictest-wins rules. */
+export declare function applyAfterModelCall(ctx: DynamicsContext, args: {
+    readonly text?: string;
+    readonly toolCalls: readonly {
+        readonly id: string;
+        readonly name: string;
+        readonly args: JsonValue;
+    }[];
+}): Promise<Decision>;
+export declare function mergeDecisions(decisions: readonly Decision[]): Decision;
+export declare function hasDynamics(agent: AgentDefinition): boolean;

package/dist/loop/step/dynamics.js

@@ -0,0 +1,149 @@
+import { HarnessError } from "@nylorun/core/define";
+/** Run all beforeModelCall handlers in capability `.use()` order. */
+export async function applyBeforeModelCall(ctx, configuration) {
+    const patches = [];
+    for (const capability of ctx.agent.manifest.capabilities) {
+        const impl = ctx.agent.implementations[capability.id];
+        if (!impl?.beforeModelCall)
+            continue;
+        const raw = await impl.beforeModelCall({
+            input: projectInput(ctx.arrivals),
+            info: ctx.info,
+            state: { ...ctx.sessionState },
+            messages: ctx.messages,
+            step: ctx.step,
+        });
+        const patch = normalizeCapabilityPatch(capability.id, raw ?? {}, capability.id === "agent");
+        patches.push({ id: capability.id, patch, agentLevel: capability.id === "agent" });
+    }
+    if (!patches.length)
+        return {};
+    let blocked;
+    const capabilitySwitches = new Map();
+    const toolSwitches = new Map();
+    const extraInstructions = [];
+    for (const { id, patch, agentLevel } of patches) {
+        if (patch.block)
+            blocked = patch.block;
+        if (patch.state) {
+            for (const [key, value] of Object.entries(patch.state))
+                ctx.sessionState[key] = value;
+        }
+        if (patch.instructions)
+            extraInstructions.push(...patch.instructions);
+        if (patch.capabilities) {
+            for (const [name, on] of Object.entries(patch.capabilities)) {
+                if (!agentLevel && name !== id)
+                    throw new HarnessError("configuration.invalid", `Capability '${id}' beforeModelCall may only toggle itself, not '${name}'`);
+                if (!ctx.agent.manifest.capabilities.some((item) => item.id === name))
+                    throw new HarnessError("configuration.invalid", `beforeModelCall referenced unknown capability '${name}'`);
+                capabilitySwitches.set(name, on);
+            }
+        }
+        if (patch.tools) {
+            for (const [name, on] of Object.entries(patch.tools)) {
+                const known = ctx.agent.manifest.capabilities.some((cap) => cap.tools?.some((tool) => tool.name === name) ||
+                    ctx.agent.implementations[cap.id]?.tools?.[name] !== undefined);
+                if (!known)
+                    throw new HarnessError("configuration.invalid", `beforeModelCall referenced unknown tool '${name}'`);
+                if (!agentLevel) {
+                    const declared = ctx.agent.manifest.capabilities
+                        .find((cap) => cap.id === id)
+                        ?.tools?.some((tool) => tool.name === name);
+                    const owned = declared || ctx.agent.implementations[id]?.tools?.[name] !== undefined;
+                    if (!owned)
+                        throw new HarnessError("configuration.invalid", `Capability '${id}' beforeModelCall may only toggle its own tools`);
+                }
+                toolSwitches.set(name, on);
+            }
+        }
+    }
+    if (blocked)
+        return { blocked };
+    let order = 10_000;
+    for (const [capabilityId, on] of capabilitySwitches) {
+        if (on)
+            continue;
+        configuration.setTools("dynamics", order++, capabilityId, []);
+    }
+    for (const [toolName, on] of toolSwitches) {
+        if (on)
+            continue;
+        for (const capability of ctx.agent.manifest.capabilities) {
+            const tools = ctx.agent.implementations[capability.id]?.tools;
+            if (!tools?.[toolName])
+                continue;
+            const remaining = Object.values(tools).filter((tool) => tool.name !== toolName);
+            configuration.setTools("dynamics", order++, capability.id, remaining);
+        }
+    }
+    if (extraInstructions.length)
+        configuration.setInstructions("dynamics", order++, "dynamics", Object.freeze([...extraInstructions]));
+    return {};
+}
+/** Run all afterModelCall handlers; merge with strictest-wins rules. */
+export async function applyAfterModelCall(ctx, args) {
+    const decisions = [];
+    for (const capability of ctx.agent.manifest.capabilities) {
+        const impl = ctx.agent.implementations[capability.id];
+        if (!impl?.afterModelCall)
+            continue;
+        const decision = await impl.afterModelCall(args, {
+            info: ctx.info,
+            state: { ...ctx.sessionState },
+        });
+        decisions.push(decision ?? {});
+    }
+    return mergeDecisions(decisions);
+}
+export function mergeDecisions(decisions) {
+    let block;
+    let retry;
+    const deny = new Map();
+    const approve = new Map();
+    let text;
+    for (const decision of decisions) {
+        if (decision.block)
+            block = decision.block;
+        if (decision.retry)
+            retry = decision.retry;
+        for (const item of decision.deny ?? [])
+            deny.set(item.id, item.reason);
+        for (const item of decision.approve ?? [])
+            approve.set(item.id, item.prompt);
+        if (decision.text !== undefined)
+            text = decision.text;
+    }
+    if (block)
+        return { block };
+    if (retry)
+        return { retry, ...(text === undefined ? {} : { text }) };
+    return {
+        ...(text === undefined ? {} : { text }),
+        ...(deny.size ? { deny: [...deny.entries()].map(([id, reason]) => ({ id, reason })) } : {}),
+        ...(approve.size
+            ? { approve: [...approve.entries()].map(([id, prompt]) => ({ id, prompt })) }
+            : {}),
+    };
+}
+export function hasDynamics(agent) {
+    return agent.manifest.capabilities.some((capability) => capability.beforeModelCall || capability.afterModelCall);
+}
+function normalizeCapabilityPatch(id, patch, agentLevel) {
+    if (patch.active === undefined)
+        return patch;
+    if (agentLevel)
+        throw new HarnessError("configuration.invalid", "Agent-level beforeModelCall must use capabilities{}, not active");
+    return {
+        ...patch,
+        capabilities: { ...(patch.capabilities ?? {}), [id]: patch.active },
+    };
+}
+function projectInput(arrivals) {
+    const message = arrivals.find((item) => item.kind === "user-message");
+    if (!message)
+        return undefined;
+    if ("text" in message && typeof message.text === "string")
+        return message.text;
+    return undefined;
+}

package/dist/{execution → loop}/step/model-configuration.d.ts

@@ -1,6 +1,6 @@
 import type { InternalModelConfigurationSnapshot } from "./describe.js";
-import type { ModelConfigurationMutationOptions, ModelDirective } from "../../types/model.js";
-import type { ToolDefinition } from "../../types/tool.js";
+import type { ModelConfigurationMutationOptions, ModelDirective } from "@nylorun/core/define";
+import type { ToolDefinition } from "@nylorun/core/define";
 /** Per-step, middleware-owned model configuration draft. It never persists past the call. */
 export declare class ModelConfigurationDraft {
     #private;

package/dist/{execution → loop}/step/model-configuration.js

@@ -1,7 +1,7 @@
-import { bindTool } from "../../definition/bind-tool.js";
-import { HarnessError, isHarnessError } from "../../errors.js";
+import { bindTool } from "@nylorun/core/define";
+import { HarnessError, isHarnessError } from "@nylorun/core/define";
 import { normalizeDirective, sameDirective } from "../model/normalize.js";
-import { copyJson } from "../../utils/immutable.js";
+import { copyJson } from "@nylorun/core/define";
 import { checkedReason, slotOwner, SlotDraft } from "./slot-assembly.js";
 /** Per-step, middleware-owned model configuration draft. It never persists past the call. */
 export class ModelConfigurationDraft {

package/dist/{execution → loop}/step/resolve.d.ts

@@ -1,7 +1,7 @@
-import type { TurnOutputContract } from "../../definition/output-contract.js";
-import type { InputEvent } from "../../types/transcript.js";
-import type { ModelRequest } from "../../types/model.js";
-import type { ToolResult } from "../../types/tool.js";
+import type { TurnOutputContract } from "@nylorun/core/define";
+import type { InputEvent } from "@nylorun/core/define";
+import type { ModelRequest } from "@nylorun/core/define";
+import type { ToolResult } from "@nylorun/core/define";
 import type { StepContext } from "./step-context.js";
 export declare function resolveModelRequest(input: {
     context: StepContext;

package/dist/{execution → loop}/step/run.d.ts

@@ -1,8 +1,8 @@
 import type { ExecutionSnapshot, StepRuntime } from "./runtime.js";
-import type { TurnOutputContract } from "../../definition/output-contract.js";
-import type { ModelCandidate } from "../../types/model.js";
-import type { InputEvent } from "../../types/transcript.js";
-import type { ToolResult } from "../../types/tool.js";
+import type { TurnOutputContract } from "@nylorun/core/define";
+import type { ModelCandidate } from "@nylorun/core/define";
+import type { InputEvent } from "@nylorun/core/define";
+import type { ToolResult } from "@nylorun/core/define";
 import type { ObserveEmit } from "../observe.js";
 import { type SealedStepOutput } from "./seal.js";
 export interface StepRunResult {
@@ -11,6 +11,7 @@ export interface StepRunResult {
     readonly output: SealedStepOutput;
     readonly requestedModelId?: string;
     readonly modelInvocationId?: string;
+    readonly retry?: string;
 }
 export declare function runStep(input: {
     agent: StepRuntime;

package/dist/{execution → loop}/step/run.js

@@ -1,6 +1,7 @@
+import { HostSuspension } from "../host-suspension.js";
 import { normalizeCandidate } from "../model/normalize.js";
-import { HarnessError, isHarnessError } from "../../errors.js";
-import { copyJson } from "../../utils/immutable.js";
+import { HarnessError, isHarnessError } from "@nylorun/core/define";
+import { copyJson } from "@nylorun/core/define";
 import { runMiddleware } from "./compose.js";
 import { ContextDraft } from "./context-draft.js";
 import { StepContext } from "./step-context.js";
@@ -9,9 +10,11 @@ import { resolveModelRequest } from "./resolve.js";
 import { sealStep } from "./seal.js";
 import { ModelConfigurationDraft } from "./model-configuration.js";
 import { createId } from "../../utils/ids.js";
+import { applyAfterModelCall, applyBeforeModelCall, hasDynamics, } from "./dynamics.js";
 export async function runStep(input) {
     let requestedModelId;
     let modelInvocationId;
+    let retryFeedback;
     const stepInput = Object.freeze({
         executionId: input.executionId,
         turnId: input.turnId,
@@ -38,6 +41,46 @@ export async function runStep(input) {
         input.signal.throwIfAborted();
         if (context.currentTripwire)
             return context.tripwire(context.currentTripwire);
+        const definition = input.agent.definition;
+        const dynamicsCtx = definition && hasDynamics(definition)
+            ? {
+                agent: definition,
+                info: input.info,
+                step: input.stepNumber - 1,
+                arrivals: input.arrivals,
+                messages: projectModelCall(resolveModelRequest({
+                    context,
+                    arrivals: input.arrivals,
+                    toolResults: input.toolResults,
+                    output: input.output,
+                })).prompt,
+                sessionState: input.agent.sessionState ?? {},
+            }
+            : undefined;
+        if (dynamicsCtx) {
+            try {
+                const before = await applyBeforeModelCall(dynamicsCtx, configuration);
+                if (input.agent.sessionState) {
+                    Object.assign(input.agent.sessionState, dynamicsCtx.sessionState);
+                }
+                if (input.agent.recordAfterDynamics)
+                    await input.agent.recordAfterDynamics();
+                if (before.blocked) {
+                    return context.tripwire({
+                        code: "dynamics.blocked",
+                        message: before.blocked,
+                    });
+                }
+            }
+            catch (error) {
+                if (error instanceof HostSuspension)
+                    throw error;
+                return context.tripwire({
+                    code: isHarnessError(error) ? error.code : "configuration.invalid",
+                    message: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
         try {
             const selected = configuration.snapshot();
             for (const tool of selected.tools)
@@ -46,6 +89,8 @@ export async function runStep(input) {
             context.sealContext(runtimeContext.snapshot());
         }
         catch (error) {
+            if (error instanceof HostSuspension)
+                throw error;
             const message = error instanceof Error ? error.message : String(error);
             return context.tripwire({
                 code: isHarnessError(error) ? error.code : "configuration.invalid",
@@ -103,9 +148,48 @@ export async function runStep(input) {
             const candidate = context.currentCandidate;
             if (!candidate)
                 throw new HarnessError("model.candidate-missing", "Model candidate missing after mint");
+            if (dynamicsCtx) {
+                const text = candidate.output
+                    ?.filter((block) => block.type === "text")
+                    .map((block) => block.text)
+                    .join("");
+                const toolCalls = (candidate.output ?? [])
+                    .filter((block) => block.type === "tool-call")
+                    .map((block) => {
+                    const call = block;
+                    return { id: call.id, name: call.name, args: call.args };
+                });
+                const decision = await applyAfterModelCall(dynamicsCtx, {
+                    ...(text ? { text } : {}),
+                    toolCalls,
+                });
+                if (input.agent.recordAfterDynamics)
+                    await input.agent.recordAfterDynamics();
+                if (decision.block) {
+                    return context.tripwire({ code: "dynamics.blocked", message: decision.block });
+                }
+                if (decision.retry) {
+                    retryFeedback = decision.retry;
+                    return context.tripwire({ code: "dynamics.retry", message: decision.retry });
+                }
+                if (decision.text !== undefined) {
+                    minted.replace({
+                        output: [{ type: "text", text: decision.text }],
+                    });
+                }
+                for (const item of decision.deny ?? [])
+                    minted.deny(item.id, item.reason);
+                for (const item of decision.approve ?? [])
+                    minted.requireInteraction(item.id, {
+                        kind: "approval",
+                        prompt: item.prompt,
+                    });
+            }
             return minted;
         }
         catch (error) {
+            if (error instanceof HostSuspension)
+                throw error;
             if (input.signal.aborted)
                 throw input.signal.reason;
             return context.tripwire({
@@ -122,6 +206,7 @@ export async function runStep(input) {
         ...(requestedModelId === undefined ? {} : { requestedModelId }),
         output,
         ...(modelInvocationId ? { modelInvocationId } : {}),
+        ...(retryFeedback ? { retry: retryFeedback } : {}),
     });
 }
 function snapshotStepStart(input) {

package/dist/{execution → loop}/step/runtime.d.ts

@@ -1,13 +1,21 @@
 import type { ToolRegistry } from "../../definition/registry.js";
-import type { ModelAdapter } from "../../types/model.js";
-import type { InputEvent, TranscriptEntry } from "../../types/transcript.js";
-import type { ToolResult } from "../../types/tool.js";
-import type { BoundMiddleware } from "../../definition/bound.js";
+import type { AgentDefinition } from "../../definition/agent-definition.js";
+import type { ModelAdapter } from "@nylorun/core/define";
+import type { InputEvent, TranscriptEntry } from "@nylorun/core/define";
+import type { ToolResult } from "@nylorun/core/define";
+import type { BoundMiddleware } from "@nylorun/core/define";
+import type { JsonValue } from "@nylorun/core/define";
 /** Compiled definition pieces plus the per-run model adapter for one step. */
 export interface StepRuntime {
     readonly middleware: readonly BoundMiddleware[];
     readonly invoke: ModelAdapter;
     readonly registry: ToolRegistry;
+    /** Full definition for before/after dynamics (optional for middleware-only agents). */
+    readonly definition?: AgentDefinition;
+    /** Mutable session memory bag shared with tools. */
+    sessionState?: Record<string, JsonValue>;
+    /** Called after Patch/Decision applied so the host can record. */
+    recordAfterDynamics?: () => Promise<void>;
 }
 export interface StepInput {
     readonly executionId: string;

package/dist/{execution → loop}/step/seal.d.ts

@@ -1,9 +1,9 @@
-import type { BoundToolDefinition } from "../../definition/bound.js";
-import type { ModelCandidate } from "../../types/model.js";
-import type { JsonValue, Tripwire } from "../../types/shared.js";
-import type { RequiredInteraction, ToolOwner, ToolResult } from "../../types/tool.js";
+import type { BoundToolDefinition } from "@nylorun/core/define";
+import type { ModelCandidate } from "@nylorun/core/define";
+import type { JsonValue, Tripwire } from "@nylorun/core/define";
+import type { RequiredInteraction, ToolOwner, ToolResult } from "@nylorun/core/define";
 import type { StepContext } from "./step-context.js";
-import type { TurnOutputContract } from "../../definition/output-contract.js";
+import type { TurnOutputContract } from "@nylorun/core/define";
 export interface SealedToolCall {
     readonly callId: string;
     readonly toolName: string;

package/dist/{execution → loop}/step/seal.js

@@ -1,7 +1,7 @@
 import { textFromOutput } from "../model/normalize.js";
 import { createId } from "../../utils/ids.js";
-import { HarnessError, isHarnessError } from "../../errors.js";
-import { assertJson, copyJson } from "../../utils/immutable.js";
+import { HarnessError, isHarnessError } from "@nylorun/core/define";
+import { assertJson, copyJson } from "@nylorun/core/define";
 const failed = (callId, toolName, code, message, details) => Object.freeze({
     kind: "failed",
     callId,

package/dist/{execution → loop}/step/slot-assembly.d.ts

@@ -1,4 +1,4 @@
-import { type HarnessErrorCode } from "../../errors.js";
+import { type HarnessErrorCode } from "@nylorun/core/define";
 export interface SlotOwner {
     readonly middlewareId: string;
     readonly middlewareOrder: number;

package/dist/{execution → loop}/step/slot-assembly.js

@@ -1,4 +1,4 @@
-import { HarnessError } from "../../errors.js";
+import { HarnessError } from "@nylorun/core/define";
 /**
  * Shared per-step slot store. Declarations are discarded with the draft that owns this instance.
  * Configuration and context supply their typed values and snapshot them after this assembler has

package/dist/{execution → loop}/step/step-context.d.ts

@@ -1,11 +1,11 @@
-import type { BoundToolDefinition } from "../../definition/bound.js";
+import type { BoundToolDefinition } from "@nylorun/core/define";
 import type { StepInput } from "./runtime.js";
 import type { InternalModelConfigurationSnapshot } from "./describe.js";
-import type { ContextSnapshot, ModelCandidate, ModelDirective } from "../../types/model.js";
-import type { StepRequest, StepResponse } from "../../types/middleware.js";
-import type { Tripwire } from "../../types/shared.js";
+import type { ContextSnapshot, ModelCandidate, ModelDirective } from "@nylorun/core/define";
+import type { StepRequest, StepResponse } from "@nylorun/core/define";
+import type { Tripwire } from "@nylorun/core/define";
 import type { ObserveEmit } from "../observe.js";
-import type { Interaction } from "../../types/tool.js";
+import type { Interaction } from "@nylorun/core/define";
 import { type CanonicalCall } from "./canonicalize.js";
 import { ContextDraft } from "./context-draft.js";
 import { ModelConfigurationDraft } from "./model-configuration.js";

package/dist/{execution → loop}/step/step-context.js

@@ -1,5 +1,5 @@
-import { HarnessError, isHarnessError } from "../../errors.js";
-import { freezeGraph } from "../../utils/immutable.js";
+import { HarnessError, isHarnessError } from "@nylorun/core/define";
+import { freezeGraph } from "@nylorun/core/define";
 import { callsFromCanonical, candidateFromCanonical, canonicalizeOutput, identityKey, } from "./canonicalize.js";
 import { normalizeCandidate } from "../model/normalize.js";
 import { ContextDraft } from "./context-draft.js";

package/dist/{execution → loop}/tool-result.d.ts

@@ -1,4 +1,4 @@
-import type { BoundToolDefinition } from "../definition/bound.js";
+import type { BoundToolDefinition } from "@nylorun/core/define";
 import type { SavedToolCall } from "../types/execution.js";
-import type { ToolOutcome, ToolResult } from "../types/tool.js";
+import type { ToolOutcome, ToolResult } from "@nylorun/core/define";
 export declare function toolResult(call: SavedToolCall, definition: BoundToolDefinition, outcome: ToolOutcome): ToolResult;

package/dist/{execution → loop}/tool-result.js

@@ -1,5 +1,5 @@
-import { HarnessError } from "../errors.js";
-import { copyJson } from "../utils/immutable.js";
+import { HarnessError } from "@nylorun/core/define";
+import { copyJson } from "@nylorun/core/define";
 export function toolResult(call, definition, outcome) {
     const identity = { callId: call.callId, toolName: call.toolName };
     if (outcome.kind === "completed") {

package/dist/{execution → loop}/transcript.d.ts

@@ -1,2 +1,2 @@
-import type { TranscriptEntry } from "../types/transcript.js";
+import type { TranscriptEntry } from "@nylorun/core/define";
 export declare function validateTranscript(value: readonly TranscriptEntry[]): readonly TranscriptEntry[];

package/dist/{execution → loop}/transcript.js

@@ -1,6 +1,6 @@
-import { HarnessError } from "../errors.js";
+import { HarnessError } from "@nylorun/core/define";
 import { normalizeCandidate } from "./model/normalize.js";
-import { assertJson, copyJson, copyJsonObject } from "../utils/immutable.js";
+import { assertJson, copyJson, copyJsonObject } from "@nylorun/core/define";
 export function validateTranscript(value) {
     try {
         if (!Array.isArray(value))